/** * vdpdbg_window_show(): Show the VDP Layer Options window. * @param parent Parent window. */ void MDP_FNCALL vdpdbg_window_show(void *parent) { if (vdpdbg_window) { // VDP Debugger window is already visible. Set focus. gtk_widget_grab_focus(vdpdbg_window); return; } // Initialize VDP Data. vdpdbg_data_init(); // Clear previous CRam buffer. memset(prev_CRam, 0, sizeof(prev_CRam)); // Create the window. vdpdbg_window = gtk_dialog_new(); gtk_container_set_border_width(GTK_CONTAINER(vdpdbg_window), 4); gtk_window_set_title(GTK_WINDOW(vdpdbg_window), "VDP Debugger"); gtk_window_set_position(GTK_WINDOW(vdpdbg_window), GTK_WIN_POS_CENTER); gtk_window_set_resizable(GTK_WINDOW(vdpdbg_window), FALSE); gtk_window_set_type_hint(GTK_WINDOW(vdpdbg_window), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_dialog_set_has_separator(GTK_DIALOG(vdpdbg_window), FALSE); // Callbacks for if the window is closed. g_signal_connect((gpointer)vdpdbg_window, "delete_event", G_CALLBACK(vdpdbg_window_callback_close), NULL); g_signal_connect((gpointer)vdpdbg_window, "destroy_event", G_CALLBACK(vdpdbg_window_callback_close), NULL); // Dialog response callback. g_signal_connect((gpointer)vdpdbg_window, "response", G_CALLBACK(vdpdbg_window_callback_response), NULL); // Get the dialog VBox. GtkWidget *vboxDialog = gtk_bin_get_child(GTK_BIN(vdpdbg_window)); gtk_box_set_spacing(GTK_BOX(vboxDialog), 8); gtk_widget_show(vboxDialog); // Create the CRam image. (each color will be 16x16) pbufCRam = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 16*16, 4*16); imgCRam = gtk_image_new_from_pixbuf(pbufCRam); gtk_widget_show(imgCRam); gtk_box_pack_start(GTK_BOX(vboxDialog), imgCRam, FALSE, FALSE, 0); // Clear the pixel buffer. uint32_t *pixels = (uint32_t*)gdk_pixbuf_get_pixels(pbufCRam); int rowstride = gdk_pixbuf_get_rowstride(pbufCRam); int n_channels = gdk_pixbuf_get_n_channels(pbufCRam); int px_count = ((rowstride * 63) + (16*16*n_channels)) / 4; for (; px_count != 0; px_count -= 4) { *pixels = 0xFF000000U; *(pixels + 1) = 0xFF000000U; *(pixels + 2) = 0xFF000000U; *(pixels + 3) = 0xFF000000U; pixels += 4; } // Create the GtkTreeView for the register listing. vdpdbg_window_create_lstRegList(vboxDialog); // Create the dialog buttons. gtk_dialog_add_buttons(GTK_DIALOG(vdpdbg_window), "gtk-close", GTK_RESPONSE_CLOSE, NULL); // Set the window as modal to the main application window. if (parent) gtk_window_set_transient_for(GTK_WINDOW(vdpdbg_window), GTK_WINDOW(parent)); // Update the window. vdpdbg_window_update(); // Show the window. gtk_widget_show_all(vdpdbg_window); // Register the window with MDP Host Services. vdpdbg_host_srv->window_register(&mdp, vdpdbg_window); }
static gboolean internal_init (NMAWirelessDialog *self, NMConnection *specific_connection, NMDevice *specific_device, gboolean auth_only, gboolean create) { NMAWirelessDialogPrivate *priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self); GtkWidget *widget; char *label, *icon_name = "network-wireless"; gboolean security_combo_focus = FALSE; gtk_window_set_position (GTK_WINDOW (self), GTK_WIN_POS_CENTER_ALWAYS); gtk_container_set_border_width (GTK_CONTAINER (self), 6); gtk_window_set_default_size (GTK_WINDOW (self), 488, -1); gtk_window_set_resizable (GTK_WINDOW (self), FALSE); gtk_dialog_set_has_separator (GTK_DIALOG (self), FALSE); if (auth_only) icon_name = "dialog-password"; else icon_name = "network-wireless"; gtk_window_set_icon_name (GTK_WINDOW (self), icon_name); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "image1")); gtk_image_set_from_icon_name (GTK_IMAGE (widget), icon_name, GTK_ICON_SIZE_DIALOG); gtk_box_set_spacing (GTK_BOX (gtk_bin_get_child (GTK_BIN (self))), 2); widget = gtk_dialog_add_button (GTK_DIALOG (self), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_box_set_child_packing (GTK_BOX (GTK_DIALOG (self)->action_area), widget, FALSE, TRUE, 0, GTK_PACK_END); /* Connect/Create button */ if (create) { GtkWidget *image; widget = gtk_button_new_with_mnemonic (_("C_reate")); image = gtk_image_new_from_stock (GTK_STOCK_CONNECT, GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (widget), image); gtk_widget_show (widget); gtk_dialog_add_action_widget (GTK_DIALOG (self), widget, GTK_RESPONSE_OK); } else widget = gtk_dialog_add_button (GTK_DIALOG (self), GTK_STOCK_CONNECT, GTK_RESPONSE_OK); gtk_box_set_child_packing (GTK_BOX (GTK_DIALOG (self)->action_area), widget, FALSE, TRUE, 0, GTK_PACK_END); g_object_set (G_OBJECT (widget), "can-default", TRUE, NULL); gtk_widget_grab_default (widget); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "hbox1")); if (!widget) { nm_warning ("Couldn't find UI wireless_dialog widget."); return FALSE; } gtk_widget_reparent (widget, gtk_bin_get_child (GTK_BIN (self))); /* If given a valid connection, hide the SSID bits and connection combo */ if (specific_connection) { widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_label")); gtk_widget_hide (widget); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_entry")); gtk_widget_hide (widget); security_combo_focus = TRUE; } else { widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_entry")); g_signal_connect (G_OBJECT (widget), "changed", (GCallback) ssid_entry_changed, self); gtk_widget_grab_focus (widget); } gtk_dialog_set_response_sensitive (GTK_DIALOG (self), GTK_RESPONSE_OK, FALSE); if (!device_combo_init (self, specific_device)) { g_warning ("No wireless devices available."); return FALSE; } if (!connection_combo_init (self, specific_connection)) { g_warning ("Couldn't set up connection combo box."); return FALSE; } if (!security_combo_init (self)) { g_warning ("Couldn't set up wireless security combo box."); return FALSE; } if (security_combo_focus) gtk_widget_grab_focus (priv->sec_combo); security_combo_changed (priv->sec_combo, self); g_signal_connect (G_OBJECT (priv->sec_combo), "changed", G_CALLBACK (security_combo_changed), self); if (priv->connection) { char *tmp; char *esc_ssid = NULL; NMSettingWireless *s_wireless; const GByteArray *ssid; s_wireless = NM_SETTING_WIRELESS (nm_connection_get_setting (priv->connection, NM_TYPE_SETTING_WIRELESS)); ssid = s_wireless ? nm_setting_wireless_get_ssid (s_wireless) : NULL; if (ssid) esc_ssid = nm_utils_ssid_to_utf8 ((const char *) ssid->data, ssid->len); tmp = g_strdup_printf (_("Passwords or encryption keys are required to access the wireless network '%s'."), esc_ssid ? esc_ssid : "<unknown>"); gtk_window_set_title (GTK_WINDOW (self), _("Wireless Network Authentication Required")); label = g_strdup_printf ("<span size=\"larger\" weight=\"bold\">%s</span>\n\n%s", _("Authentication required by wireless network"), tmp); g_free (esc_ssid); g_free (tmp); } else if (priv->adhoc_create) { gtk_window_set_title (GTK_WINDOW (self), _("Create New Wireless Network")); label = g_strdup_printf ("<span size=\"larger\" weight=\"bold\">%s</span>\n\n%s", _("New wireless network"), _("Enter a name for the wireless network you wish to create.")); } else { gtk_window_set_title (GTK_WINDOW (self), _("Connect to Hidden Wireless Network")); label = g_strdup_printf ("<span size=\"larger\" weight=\"bold\">%s</span>\n\n%s", _("Hidden wireless network"), _("Enter the name and security details of the hidden wireless network you wish to connect to.")); } widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "caption_label")); gtk_label_set_markup (GTK_LABEL (widget), label); g_free (label); /* Re-validate from an idle handler so that widgets like file choosers * have had time to find their files. */ g_idle_add (revalidate, self); return TRUE; }
void gtkui_port_stealing(void) { GtkWidget *dialog, *vbox, *hbox, *image, *button1, *button2, *frame; gint response = 0; gboolean remote = FALSE; DEBUG_MSG("gtk_port_stealing"); dialog = gtk_dialog_new_with_buttons("MITM Attack: Port Stealing", 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 = gtk_hbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); 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), image, FALSE, FALSE, 5); gtk_widget_show(image); frame = gtk_frame_new("Optional parameters"); gtk_container_set_border_width(GTK_CONTAINER (frame), 5); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show(frame); vbox = gtk_vbox_new (FALSE, 2); gtk_container_set_border_width(GTK_CONTAINER (vbox), 5); gtk_container_add(GTK_CONTAINER (frame), vbox); gtk_widget_show(vbox); button1 = gtk_check_button_new_with_label("Sniff remote connections."); gtk_box_pack_start(GTK_BOX (vbox), button1, FALSE, FALSE, 0); gtk_widget_show(button1); button2 = gtk_check_button_new_with_label("Propagate to other switches."); gtk_box_pack_start(GTK_BOX (vbox), button2, FALSE, FALSE, 0); gtk_widget_show(button2); response = gtk_dialog_run(GTK_DIALOG(dialog)); if(response == GTK_RESPONSE_OK) { gtk_widget_hide(dialog); sprintf(params, "port:"); if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (button1))) { strcat(params, "remote"); remote = TRUE; } if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (button2))) { if(remote) strcat(params, ","); strcat(params, "tree"); } gtkui_start_mitm(); } gtk_widget_destroy(dialog); /* a simpler method: gtkui_input_call("Parameters :", params + strlen("port:"), PARAMS_LEN - strlen("port:"), gtkui_start_mitm); */ }
void gtkui_icmp_redir(void) { GtkWidget *dialog, *table, *hbox, *image, *label, *entry1, *entry2, *frame, *content_area; gint response = 0; DEBUG_MSG("gtk_icmp_redir"); dialog = gtk_dialog_new_with_buttons("MITM Attack: ICMP Redirect", 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); #if !GTK_CHECK_VERSION(2, 22, 0) gtk_dialog_set_has_separator(GTK_DIALOG (dialog), FALSE); #endif #if GTK_CHECK_VERSION(3, 0, 0) hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); #else hbox = gtk_hbox_new (FALSE, 5); #endif content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); gtk_container_add(GTK_CONTAINER(content_area), hbox); gtk_widget_show(hbox); 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), image, FALSE, FALSE, 5); gtk_widget_show(image); frame = gtk_frame_new("Gateway Information"); gtk_container_set_border_width(GTK_CONTAINER (frame), 5); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show(frame); table = gtk_table_new(2, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE (table), 5); gtk_table_set_col_spacings(GTK_TABLE (table), 5); gtk_container_set_border_width(GTK_CONTAINER (table), 8); gtk_container_add(GTK_CONTAINER (frame), table); gtk_widget_show(table); label = gtk_label_new("MAC Address"); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach(GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show(label); entry1 = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY (entry1), ETH_ASCII_ADDR_LEN); gtk_table_attach_defaults(GTK_TABLE (table), entry1, 1, 2, 0, 1); gtk_widget_show(entry1); label = gtk_label_new("IP Address"); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach(GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show(label); entry2 = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY (entry2), IP6_ASCII_ADDR_LEN); gtk_table_attach_defaults(GTK_TABLE (table), entry2, 1, 2, 1, 2); gtk_widget_show(entry2); response = gtk_dialog_run(GTK_DIALOG(dialog)); if(response == GTK_RESPONSE_OK) { gtk_widget_hide(dialog); // memset(params, '\0', PARAMS_LEN); snprintf(params, PARAMS_LEN+1, "icmp:%s/%s", gtk_entry_get_text(GTK_ENTRY(entry1)), gtk_entry_get_text(GTK_ENTRY(entry2))); gtkui_start_mitm(); } gtk_widget_destroy(dialog); /* a simpler method: gtkui_input_call("Parameters :", params + strlen("icmp:"), PARAMS_LEN - strlen("icmp:"), gtkui_start_mitm); */ }
void gtkui_ndp_poisoning(void) { GtkWidget *dialog, *vbox, *hbox, *image, *button1, *button2, *frame, *content_area; gint response = 0; gboolean remote = FALSE; gboolean oneway = FALSE; DEBUG_MSG("gtk_ndp_poisoning"); // not needed, the \0 is already appended from snprintf // memset(params, '\0', PARAMS_LEN+1); dialog = gtk_dialog_new_with_buttons("MITM Attack: NDP Poisoning", 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); #if !GTK_CHECK_VERSION(2, 22, 0) gtk_dialog_set_has_separator(GTK_DIALOG (dialog), FALSE); #endif #if GTK_CHECK_VERSION(3, 0, 0) hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); #else hbox = gtk_hbox_new (FALSE, 5); #endif content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); gtk_container_add(GTK_CONTAINER(content_area), hbox); gtk_widget_show(hbox); 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), image, FALSE, FALSE, 5); gtk_widget_show(image); frame = gtk_frame_new("Optional parameters"); gtk_container_set_border_width(GTK_CONTAINER (frame), 5); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show(frame); #if GTK_CHECK_VERSION(3, 0, 0) vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2); #else vbox = gtk_vbox_new (FALSE, 2); #endif gtk_container_set_border_width(GTK_CONTAINER (vbox), 5); gtk_container_add(GTK_CONTAINER (frame), vbox); gtk_widget_show(vbox); button1 = gtk_check_button_new_with_label("Sniff remote connections."); gtk_box_pack_start(GTK_BOX (vbox), button1, FALSE, FALSE, 0); gtk_widget_show(button1); button2 = gtk_check_button_new_with_label("Only poison one-way."); gtk_box_pack_start(GTK_BOX (vbox), button2, FALSE, FALSE, 0); gtk_widget_show(button2); response = gtk_dialog_run(GTK_DIALOG(dialog)); if(response == GTK_RESPONSE_OK) { gtk_widget_hide(dialog); const char *s_remote = "", *comma = "", *s_oneway = ""; if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (button1))) { s_remote="remote"; remote = TRUE; } if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (button2))) { if(remote) comma = ","; s_oneway = "oneway"; oneway = TRUE; } if(!remote && !oneway) { ui_error("You must select at least one NDP mode"); return; } snprintf(params, PARAMS_LEN+1, "ndp:%s%s%s", s_remote, comma, s_oneway); gtkui_start_mitm(); } gtk_widget_destroy(dialog); /* a simpler method: gtkui_input_call("Parameters :", params + strlen("ndp:"), PARAMS_LEN - strlen("ndp:"), gtkui_start_mitm); */ }
static gboolean wshed_dialog(WshedArgs *args, GwyContainer *data) { GtkWidget *dialog, *table, *label, *spin, *hbox; WshedControls controls; enum { RESPONSE_RESET = 1, RESPONSE_PREVIEW = 2 }; gint response; gdouble zoomval; GtkObject *layer; GwyDataField *dfield; gint row; dialog = gtk_dialog_new_with_buttons(_("Mark Grains by Watershed"), NULL, 0, _("_Update Preview"), RESPONSE_PREVIEW, _("_Reset"), RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); controls.dialog = dialog; hbox = gtk_hbox_new(FALSE, 2); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), GTK_WIDGET(hbox), FALSE, FALSE, 4); controls.mydata = GWY_CONTAINER(gwy_serializable_duplicate(G_OBJECT(data))); controls.view = gwy_data_view_new(controls.mydata); layer = gwy_layer_basic_new(); gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), GWY_PIXMAP_LAYER(layer)); dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls.mydata, "/0/data")); if (gwy_data_field_get_xres(dfield) >= gwy_data_field_get_yres(dfield)) zoomval = PREVIEW_SIZE/(gdouble)gwy_data_field_get_xres(dfield); else zoomval = PREVIEW_SIZE/(gdouble)gwy_data_field_get_yres(dfield); gwy_data_view_set_zoom(GWY_DATA_VIEW(controls.view), zoomval); gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4); table = gtk_table_new(9, 4, FALSE); gtk_box_pack_start(GTK_BOX(hbox), table, TRUE, TRUE, 4); row = 0; label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<b>Grain Location</b>")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 2, 2); row++; controls.locate_steps = gtk_adjustment_new(args->locate_steps, 1.0, 100.0, 1, 5, 0); gwy_table_attach_hscale(table, row, _("_Number of steps:"), "", controls.locate_steps, 0); g_signal_connect(controls.locate_steps, "value_changed", G_CALLBACK(wshed_invalidate), &controls); row++; controls.locate_dropsize = gtk_adjustment_new(args->locate_dropsize, 0.01, 100.0, 0.1, 5, 0); spin = gwy_table_attach_hscale(table, row, _("_Drop size:"), "%", controls.locate_dropsize, 0); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 2); g_signal_connect(controls.locate_dropsize, "value_changed", G_CALLBACK(wshed_invalidate), &controls); row++; controls.locate_thresh = gtk_adjustment_new(args->locate_thresh, 0.0, 100.0, 1, 5, 0); gwy_table_attach_hscale(table, row, _("_Threshold:"), "px<sup>2</sup>", controls.locate_thresh, 0); g_signal_connect(controls.locate_thresh, "value_changed", G_CALLBACK(wshed_invalidate), &controls); gtk_table_set_row_spacing(GTK_TABLE(table), row, 8); row++; label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<b>Segmentation</b>")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 2, 2); row++; controls.wshed_steps = gtk_adjustment_new(args->wshed_steps, 1.0, 1000.0, 1, 5, 0); gwy_table_attach_hscale(table, row, _("Num_ber of steps:"), "", controls.wshed_steps, 0); g_signal_connect(controls.wshed_steps, "value_changed", G_CALLBACK(wshed_invalidate), &controls); row++; controls.wshed_dropsize = gtk_adjustment_new(args->wshed_dropsize, 0.01, 100.0, 0.1, 5, 0); spin = gwy_table_attach_hscale(table, row, _("Dr_op size:"), "%", controls.wshed_dropsize, 0); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 2); g_signal_connect(controls.wshed_dropsize, "value_changed", G_CALLBACK(wshed_invalidate), &controls); gtk_table_set_row_spacing(GTK_TABLE(table), row, 8); row++; label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<b>Options</b>")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 2, 2); row++; controls.inverted = gtk_check_button_new_with_mnemonic(_("_Invert height")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.inverted), args->inverted); gtk_table_attach(GTK_TABLE(table), controls.inverted, 0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 2, 2); g_signal_connect(controls.inverted, "toggled", G_CALLBACK(wshed_invalidate), &controls); row++; controls.color_button = gwy_color_button_new(); gwy_color_button_set_use_alpha(GWY_COLOR_BUTTON(controls.color_button), TRUE); load_mask_color(controls.color_button, gwy_data_view_get_data(GWY_DATA_VIEW(controls.view))); gwy_table_attach_hscale(table, row++, _("_Mask color:"), NULL, GTK_OBJECT(controls.color_button), GWY_HSCALE_WIDGET_NO_EXPAND); g_signal_connect(controls.color_button, "clicked", G_CALLBACK(mask_color_change_cb), &controls); controls.computed = FALSE; gtk_widget_show_all(dialog); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: wshed_dialog_update_values(&controls, args); gtk_widget_destroy(dialog); case GTK_RESPONSE_NONE: g_object_unref(controls.mydata); return FALSE; break; case GTK_RESPONSE_OK: break; case RESPONSE_RESET: *args = wshed_defaults; wshed_dialog_update_controls(&controls, args); break; case RESPONSE_PREVIEW: wshed_dialog_update_values(&controls, args); preview(&controls, args); break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); save_mask_color(controls.color_button, data); wshed_dialog_update_values(&controls, args); gtk_widget_destroy(dialog); wshed_ok(&controls, args, data); g_object_unref(controls.mydata); return controls.computed; }
void gtkui_help(void) { GtkWidget *dialog, *scrolled, *treeview, *hbox, *textview; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeIter iter; help_pair *section; DEBUG_MSG("gtkui_help"); dialog = gtk_dialog_new_with_buttons(EC_PROGRAM" Help", GTK_WINDOW (window), GTK_DIALOG_MODAL, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_window_set_default_size(GTK_WINDOW (dialog), 780, 580); gtk_dialog_set_has_separator(GTK_DIALOG (dialog), TRUE); 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, TRUE, TRUE, 0); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(hbox), scrolled, FALSE, FALSE, 0); gtk_widget_show(scrolled); treeview = gtk_tree_view_new(); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (treeview), FALSE); gtk_container_add(GTK_CONTAINER (scrolled), treeview); gtk_widget_show(treeview); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect(selection, "changed", G_CALLBACK (gtkui_help_selected), liststore); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Contents", renderer, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id (column, 0); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); liststore = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); for(section = help_list; section->title; section++) { gtk_list_store_append (liststore, &iter); gtk_list_store_set (liststore, &iter, 0, section->title, 1, section->file, -1); } gtk_tree_view_set_model(GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (liststore)); /* text area */ scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0); gtk_widget_show(scrolled); textview = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW (textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW (textview), FALSE); gtk_container_add(GTK_CONTAINER (scrolled), textview); gtk_widget_show(textview); textbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW (textview)); gtk_widget_show_all(hbox); gtk_dialog_run(GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); }
GtkWidget* create_shrimp (void) { GtkWidget *shrimp; GtkWidget *dialog_vbox1; GtkWidget *table2; GtkWidget *label13; GtkWidget *current_version; GtkWidget *label15; GtkWidget *label16; GtkWidget *label17; GtkWidget *drives_combo; GtkWidget *target_version; GtkWidget *target_partitions; GtkWidget *status_label; GtkWidget *dialog_action_area1; GtkWidget *close_button; GtkWidget *install_button; shrimp = gtk_dialog_new (); gtk_widget_set_name (shrimp, "shrimp"); gtk_window_set_title (GTK_WINDOW (shrimp), _("Thin Client Imager")); gtk_window_set_type_hint (GTK_WINDOW (shrimp), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_dialog_set_has_separator (GTK_DIALOG (shrimp), FALSE); dialog_vbox1 = GTK_DIALOG (shrimp)->vbox; gtk_widget_set_name (dialog_vbox1, "dialog_vbox1"); gtk_widget_show (dialog_vbox1); table2 = gtk_table_new (7, 2, FALSE); gtk_widget_set_name (table2, "table2"); gtk_widget_show (table2); gtk_box_pack_start (GTK_BOX (dialog_vbox1), table2, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (table2), 6); gtk_table_set_row_spacings (GTK_TABLE (table2), 6); gtk_table_set_col_spacings (GTK_TABLE (table2), 12); label13 = gtk_label_new (_("Currently Running:")); gtk_widget_set_name (label13, "label13"); gtk_widget_show (label13); gtk_table_attach (GTK_TABLE (table2), label13, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label13), 1, 0.5); current_version = gtk_label_new (_("--")); gtk_widget_set_name (current_version, "current_version"); gtk_widget_show (current_version); gtk_table_attach (GTK_TABLE (table2), current_version, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (current_version), 0, 0.5); label15 = gtk_label_new (_("Target:")); gtk_widget_set_name (label15, "label15"); gtk_widget_show (label15); gtk_table_attach (GTK_TABLE (table2), label15, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label15), 1, 0.5); label16 = gtk_label_new (_("Version:")); gtk_widget_set_name (label16, "label16"); gtk_table_attach (GTK_TABLE (table2), label16, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label16), 1, 0.5); label17 = gtk_label_new (_("Partitions:")); gtk_widget_set_name (label17, "label17"); gtk_widget_show (label17); gtk_table_attach (GTK_TABLE (table2), label17, 0, 1, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label17), 1, 0.5); drives_combo = gtk_combo_box_new_text (); gtk_widget_set_name (drives_combo, "drives_combo"); gtk_widget_show (drives_combo); gtk_table_attach (GTK_TABLE (table2), drives_combo, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); target_version = gtk_label_new (_("--")); gtk_widget_set_name (target_version, "target_version"); gtk_table_attach (GTK_TABLE (table2), target_version, 1, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (target_version), 0, 0.5); target_partitions = gtk_label_new (_("--")); gtk_widget_set_name (target_partitions, "target_partitions"); gtk_widget_show (target_partitions); gtk_table_attach (GTK_TABLE (table2), target_partitions, 1, 2, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_line_wrap (GTK_LABEL (target_partitions), TRUE); gtk_misc_set_alignment (GTK_MISC (target_partitions), 0, 0.5); status_label = gtk_label_new (_("All data on the target device will be erased")); gtk_widget_set_name (status_label, "status_label"); gtk_widget_show (status_label); gtk_table_attach (GTK_TABLE (table2), status_label, 0, 2, 6, 7, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (status_label), 0, 0.5); dialog_action_area1 = GTK_DIALOG (shrimp)->action_area; gtk_widget_set_name (dialog_action_area1, "dialog_action_area1"); gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); close_button = gtk_button_new_from_stock ("gtk-close"); gtk_widget_set_name (close_button, "close_button"); gtk_widget_show (close_button); gtk_dialog_add_action_widget (GTK_DIALOG (shrimp), close_button, GTK_RESPONSE_CLOSE); GTK_WIDGET_SET_FLAGS (close_button, GTK_CAN_DEFAULT); install_button = gtk_button_new_with_mnemonic (_("Install Image")); gtk_widget_set_name (install_button, "install_button"); gtk_widget_show (install_button); gtk_dialog_add_action_widget (GTK_DIALOG (shrimp), install_button, 0); GTK_WIDGET_SET_FLAGS (install_button, GTK_CAN_DEFAULT); g_signal_connect ((gpointer) drives_combo, "changed", G_CALLBACK (on_drives_combo_changed), NULL); g_signal_connect ((gpointer) close_button, "clicked", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect ((gpointer) install_button, "clicked", G_CALLBACK (on_install_button_clicked), NULL); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (shrimp, shrimp, "shrimp"); GLADE_HOOKUP_OBJECT_NO_REF (shrimp, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (shrimp, table2, "table2"); GLADE_HOOKUP_OBJECT (shrimp, label13, "label13"); GLADE_HOOKUP_OBJECT (shrimp, current_version, "current_version"); GLADE_HOOKUP_OBJECT (shrimp, label15, "label15"); GLADE_HOOKUP_OBJECT (shrimp, label16, "label16"); GLADE_HOOKUP_OBJECT (shrimp, label17, "label17"); GLADE_HOOKUP_OBJECT (shrimp, drives_combo, "drives_combo"); GLADE_HOOKUP_OBJECT (shrimp, target_version, "target_version"); GLADE_HOOKUP_OBJECT (shrimp, target_partitions, "target_partitions"); GLADE_HOOKUP_OBJECT (shrimp, status_label, "status_label"); GLADE_HOOKUP_OBJECT_NO_REF (shrimp, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (shrimp, close_button, "close_button"); GLADE_HOOKUP_OBJECT (shrimp, install_button, "install_button"); return shrimp; }
/* * inject interactively with the user */ static void gtkui_connection_inject(void) { GtkWidget *dialog, *text, *label, *vbox, *frame; GtkWidget *button1, *button2, *hbox; GtkTextBuffer *buf; GtkTextIter start, end; char tmp[MAX_ASCII_ADDR_LEN]; gint response = 0; DEBUG_MSG("gtk_connection_inject"); if(curr_conn == NULL) return; dialog = gtk_dialog_new_with_buttons("Character Injection", GTK_WINDOW (window), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_window_set_default_size(GTK_WINDOW (dialog), 400, 200); gtk_dialog_set_has_separator(GTK_DIALOG (dialog), FALSE); gtk_container_set_border_width(GTK_CONTAINER (dialog), 5); vbox = GTK_DIALOG (dialog)->vbox; label = gtk_label_new ("Packet destination:"); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show(label); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); button1 = gtk_radio_button_new_with_label(NULL, ip_addr_ntoa(&curr_conn->L3_addr2, tmp)); gtk_box_pack_start(GTK_BOX(hbox), button1, FALSE, FALSE, 0); gtk_widget_show(button1); button2 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (button1), ip_addr_ntoa(&curr_conn->L3_addr1, tmp)); gtk_box_pack_start(GTK_BOX(hbox), button2, FALSE, FALSE, 0); gtk_widget_show(button2); label = gtk_label_new ("Characters to be injected:"); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show(label); frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX (vbox), frame, TRUE, TRUE, 5); gtk_widget_show(frame); text = gtk_text_view_new(); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW (text), GTK_WRAP_CHAR); gtk_container_add(GTK_CONTAINER (frame), text); gtk_widget_show(text); response = gtk_dialog_run(GTK_DIALOG(dialog)); if(response == GTK_RESPONSE_OK) { gtk_widget_hide(dialog); SAFE_REALLOC(injectbuf, 501 * sizeof(char)); memset(injectbuf, 0, 501); buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW (text)); /* initialize iters for get text */ gtk_text_buffer_get_start_iter(buf, &start); gtk_text_buffer_get_start_iter(buf, &end); /* advance end iter to end of text, 500 char max */ gtk_text_iter_forward_chars(&end, 500); strncpy(injectbuf, gtk_text_buffer_get_text(buf, &start, &end, FALSE), 501); if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (button1))) gtkui_inject_user(1); else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (button2))) gtkui_inject_user(2); } gtk_widget_destroy(dialog); }
/* * 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); }
/* * 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 guint select_which_data(GPtrArray *rhkfile) { RHKControls controls; RHKPage *rhkpage; GtkWidget *dialog, *label, *vbox, *hbox, *align; GwyDataField *dfield; GwyEnum *choices; GwyPixmapLayer *layer; GSList *radio, *rl; guint i, b = (guint)-1; const gchar *s; if (!rhkfile->len) return b; if (rhkfile->len == 1) return 0; controls.file = rhkfile; choices = g_new(GwyEnum, rhkfile->len + 1); for (i = 0; i < rhkfile->len; i++) { rhkpage = g_ptr_array_index(rhkfile, i); choices[i].value = i; s = rhkpage->strings[RHK_STRING_LABEL]; if (s && *s) choices[i].name = g_strdup_printf(_("Page %u (%s)"), rhkpage->pageno, s); else choices[i].name = g_strdup_printf(_("Page %u"), rhkpage->pageno); } rhkpage = g_ptr_array_index(rhkfile, 0); dialog = gtk_dialog_new_with_buttons(_("Select Data"), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); hbox = gtk_hbox_new(FALSE, 20); gtk_container_set_border_width(GTK_CONTAINER(hbox), 6); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE, TRUE, 0); align = gtk_alignment_new(0.0, 0.0, 0.0, 0.0); gtk_box_pack_start(GTK_BOX(hbox), align, TRUE, TRUE, 0); vbox = gtk_vbox_new(TRUE, 0); gtk_container_add(GTK_CONTAINER(align), vbox); label = gtk_label_new(_("Data to load:")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0); radio = gwy_radio_buttons_create(choices, rhkfile->len, "data", G_CALLBACK(selection_changed), &controls, 0); for (i = 0, rl = radio; rl; i++, rl = g_slist_next(rl)) gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(rl->data), TRUE, TRUE, 0); /* preview */ align = gtk_alignment_new(1.0, 0.0, 0.0, 0.0); gtk_box_pack_start(GTK_BOX(hbox), align, TRUE, TRUE, 0); controls.data = GWY_CONTAINER(gwy_container_new()); dfield = rhk_sm3_page_to_data_field(rhkpage); gwy_container_set_object_by_name(controls.data, "/0/data", (GObject*)dfield); g_object_unref(dfield); controls.data_view = gwy_data_view_new(controls.data); g_object_unref(controls.data); gwy_data_view_set_zoom(GWY_DATA_VIEW(controls.data_view), 120.0/MAX(rhkpage->x_size, rhkpage->y_size)); layer = GWY_PIXMAP_LAYER(gwy_layer_basic_new()); gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.data_view), layer); gtk_container_add(GTK_CONTAINER(align), controls.data_view); gtk_widget_show_all(dialog); gtk_window_present(GTK_WINDOW(dialog)); switch (gtk_dialog_run(GTK_DIALOG(dialog))) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: gtk_widget_destroy(dialog); case GTK_RESPONSE_NONE: break; case GTK_RESPONSE_OK: b = GPOINTER_TO_UINT(gwy_radio_buttons_get_current(radio, "data")); gtk_widget_destroy(dialog); break; default: g_assert_not_reached(); break; } for (i = 0; i < rhkfile->len; i++) g_free((gpointer)choices[i].name); g_free(choices); return b; }
static void show_auth_dialog(WebKitAuthData* authData, const char* login, const char* password) { GtkWidget* toplevel; GtkWidget* widget; GtkDialog* dialog; GtkWindow* window; GtkWidget* entryContainer; GtkWidget* hbox; GtkWidget* mainVBox; GtkWidget* vbox; GtkWidget* icon; GtkWidget* table; GtkWidget* messageLabel; char* message; SoupURI* uri; GtkWidget* rememberBox; GtkWidget* checkButton; /* From GTK+ gtkmountoperation.c, modified and simplified. LGPL 2 license */ widget = gtk_dialog_new(); window = GTK_WINDOW(widget); dialog = GTK_DIALOG(widget); gtk_dialog_add_buttons(dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); /* Set the dialog up with HIG properties */ gtk_dialog_set_has_separator(dialog, FALSE); gtk_container_set_border_width(GTK_CONTAINER(dialog), 5); gtk_box_set_spacing(GTK_BOX(dialog->vbox), 2); /* 2 * 5 + 2 = 12 */ gtk_container_set_border_width(GTK_CONTAINER(dialog->action_area), 5); gtk_box_set_spacing(GTK_BOX(dialog->action_area), 6); gtk_window_set_resizable(window, FALSE); gtk_window_set_title(window, ""); gtk_window_set_icon_name(window, GTK_STOCK_DIALOG_AUTHENTICATION); gtk_dialog_set_default_response(dialog, GTK_RESPONSE_OK); /* Get the current toplevel */ g_signal_emit(authData->manager, signals[CURRENT_TOPLEVEL], 0, authData->msg, &toplevel); if (toplevel) gtk_window_set_transient_for(window, GTK_WINDOW(toplevel)); /* Build contents */ hbox = gtk_hbox_new(FALSE, 12); gtk_container_set_border_width(GTK_CONTAINER(hbox), 5); gtk_box_pack_start(GTK_BOX(dialog->vbox), hbox, TRUE, TRUE, 0); icon = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment(GTK_MISC(icon), 0.5, 0.0); gtk_box_pack_start(GTK_BOX(hbox), icon, FALSE, FALSE, 0); mainVBox = gtk_vbox_new(FALSE, 18); gtk_box_pack_start(GTK_BOX(hbox), mainVBox, TRUE, TRUE, 0); uri = soup_message_get_uri(authData->msg); message = g_strdup_printf(_("A username and password are being requested by the site %s"), uri->host); messageLabel = gtk_label_new(message); g_free(message); gtk_misc_set_alignment(GTK_MISC(messageLabel), 0.0, 0.5); gtk_label_set_line_wrap(GTK_LABEL(messageLabel), TRUE); gtk_box_pack_start(GTK_BOX(mainVBox), GTK_WIDGET(messageLabel), FALSE, FALSE, 0); vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainVBox), vbox, FALSE, FALSE, 0); /* The table that holds the entries */ entryContainer = gtk_alignment_new(0.0, 0.0, 1.0, 1.0); gtk_alignment_set_padding(GTK_ALIGNMENT(entryContainer), 0, 0, 0, 0); gtk_box_pack_start(GTK_BOX(vbox), entryContainer, FALSE, FALSE, 0); table = gtk_table_new(2, 2, FALSE); gtk_table_set_col_spacings(GTK_TABLE(table), 12); gtk_table_set_row_spacings(GTK_TABLE(table), 6); gtk_container_add(GTK_CONTAINER(entryContainer), table); authData->loginEntry = table_add_entry(table, 0, _("Username:"******"Password:"******"_Remember password")); if (login && password) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkButton), TRUE); gtk_label_set_line_wrap(GTK_LABEL(gtk_bin_get_child(GTK_BIN(checkButton))), TRUE); gtk_box_pack_start(GTK_BOX(rememberBox), checkButton, FALSE, FALSE, 0); authData->checkButton = checkButton; } g_signal_connect(dialog, "response", G_CALLBACK(response_callback), authData); gtk_widget_show_all(widget); }
static void create_find_dialog(GtkWidget *htmlwidget) { GtkWidget *dialog_vbox29; GtkWidget *vbox45; GtkWidget *label180; GtkWidget *hbox66; GtkWidget *dialog_action_area29; GtkWidget *hbuttonbox8; #ifndef HAVE_GTK_310 GtkWidget *alignment; #endif GtkWidget *hbox5; GtkWidget *image; GtkWidget *label12; //gchar title[80]; //sprintf(title, "%s - %s", settings.program_title, _("Find")); dialog = g_new(FIND_DIALOG, 1); /* must be freed */ dialog->regular = FALSE; dialog->htmlwidget = htmlwidget; dialog->dialog = gtk_dialog_new(); g_object_set_data(G_OBJECT(dialog->dialog), "dialog->dialog", dialog->dialog); gtk_window_set_title(GTK_WINDOW(dialog->dialog), _("Find")); //GTK_WINDOW(dialog->dialog)->type = GTK_WINDOW_TOPLEVEL; /*gtk_window_set_policy(GTK_WINDOW(dialog->dialog), TRUE, TRUE, FALSE); */ gtk_container_set_border_width(GTK_CONTAINER(dialog->dialog), 6); gtk_window_set_resizable(GTK_WINDOW(dialog->dialog), FALSE); #ifndef USE_GTK_3 gtk_dialog_set_has_separator(GTK_DIALOG(dialog->dialog), FALSE); #endif dialog_vbox29 = gtk_dialog_get_content_area(GTK_DIALOG(dialog->dialog)); g_object_set_data(G_OBJECT(dialog->dialog), "dialog_vbox29", dialog_vbox29); gtk_widget_show(dialog_vbox29); UI_VBOX(vbox45, FALSE, 12); gtk_widget_show(vbox45); gtk_box_pack_start(GTK_BOX(dialog_vbox29), vbox45, TRUE, TRUE, 0); label180 = gtk_label_new(_("Enter Word or Phrase")); gtk_widget_show(label180); gtk_box_pack_start(GTK_BOX(vbox45), label180, FALSE, FALSE, 0); dialog->entry = gtk_entry_new(); gtk_widget_show(dialog->entry); gtk_box_pack_start(GTK_BOX(vbox45), dialog->entry, FALSE, FALSE, 0); gtk_widget_set_size_request(dialog->entry, 291, -1); UI_HBOX(hbox66, FALSE, 0); gtk_widget_show(hbox66); gtk_box_pack_start(GTK_BOX(vbox45), hbox66, TRUE, TRUE, 0); dialog->backward = gtk_check_button_new_with_label(_("Search backwards")); gtk_widget_show(dialog->backward); gtk_box_pack_start(GTK_BOX(hbox66), dialog->backward, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->backward), FALSE); dialog_action_area29 = #ifdef HAVE_GTK_312 gtk_dialog_get_content_area(GTK_DIALOG(dialog->dialog)); #else gtk_dialog_get_action_area(GTK_DIALOG(dialog->dialog)); #endif g_object_set_data(G_OBJECT(dialog->dialog), "dialog_action_area29", dialog_action_area29); gtk_widget_show(dialog_action_area29); gtk_container_set_border_width(GTK_CONTAINER(dialog_action_area29), 10); #ifdef USE_GTK_3 hbuttonbox8 = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); #else hbuttonbox8 = gtk_hbutton_box_new(); #endif gtk_widget_show(hbuttonbox8); gtk_box_pack_start(GTK_BOX(dialog_action_area29), hbuttonbox8, TRUE, TRUE, 0); dialog->find = #ifdef HAVE_GTK_310 gtk_button_new_from_icon_name("edit-find", GTK_ICON_SIZE_BUTTON); #else gtk_button_new_from_stock(GTK_STOCK_FIND); //gtk_button_new_with_label(_("Find")); #endif gtk_widget_show(dialog->find); gtk_container_add(GTK_CONTAINER(hbuttonbox8), dialog->find); dialog->next = gtk_button_new(); gtk_widget_show(dialog->next); gtk_container_add(GTK_CONTAINER(hbuttonbox8), dialog->next); //GTK_WIDGET_SET_FLAGS(dialog->next, GTK_CAN_DEFAULT); #ifndef HAVE_GTK_310 alignment = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment); gtk_container_add(GTK_CONTAINER(dialog->next), alignment); #endif UI_HBOX(hbox5, FALSE, 2); gtk_widget_show(hbox5); #ifndef HAVE_GTK_310 gtk_container_add(GTK_CONTAINER(alignment), hbox5); #endif image = #ifdef HAVE_GTK_310 gtk_image_new_from_icon_name("edit-find", GTK_ICON_SIZE_BUTTON); #else gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_BUTTON); #endif gtk_widget_show(image); gtk_box_pack_start(GTK_BOX(hbox5), image, FALSE, FALSE, 0); label12 = gtk_label_new_with_mnemonic(_("Find Next")); gtk_widget_show(label12); gtk_box_pack_start(GTK_BOX(hbox5), label12, FALSE, FALSE, 0); gtk_label_set_justify(GTK_LABEL(label12), GTK_JUSTIFY_LEFT); dialog->close = #ifdef HAVE_GTK_310 // Don't use an icon with GTK3 gtk_button_new_with_label(_("Close")); #else gtk_button_new_from_stock(GTK_STOCK_CLOSE); #endif gtk_widget_show(dialog->close); gtk_container_add(GTK_CONTAINER(hbuttonbox8), dialog->close); //GTK_WIDGET_SET_FLAGS(dialog->close, GTK_CAN_DEFAULT); gtk_widget_set_can_default(dialog->find, 1); g_signal_connect(G_OBJECT(dialog->dialog), "destroy", G_CALLBACK(dialog_destroy), dialog); g_signal_connect(G_OBJECT(dialog->find), "clicked", G_CALLBACK(find_clicked), dialog); g_signal_connect(G_OBJECT(dialog->next), "clicked", G_CALLBACK(next_clicked), dialog); g_signal_connect(G_OBJECT(dialog->close), "clicked", G_CALLBACK(close_clicked), dialog); }
void xa_create_open_with_dialog(gchar *filename,gchar *filenames,int nr) { Open_with_data *data = NULL; GtkWidget *dialog_vbox1,*vbox1,*hbox1,*mime_icon,*open_text,*scrolledwindow1,*apps_treeview,*dialog_action_area1, *custom_command_expander,*hbox_expander,*browse,*cancelbutton1,*okbutton1; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeIter iter; GdkPixbuf *pixbuf; gchar *text = NULL; gchar *title; const gchar *icon_name = NULL; const gchar* const *desktop_dirs; gint x = 0; data = g_new0(Open_with_data,1); data->file_list = filenames; data->dialog1 = gtk_dialog_new (); if (nr == 1) title = _("Open With"); else title = _("Open the selected files with"); gtk_window_set_title (GTK_WINDOW (data->dialog1),title); gtk_window_set_position (GTK_WINDOW (data->dialog1), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_modal (GTK_WINDOW (data->dialog1), TRUE); gtk_window_set_type_hint (GTK_WINDOW (data->dialog1), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_transient_for(GTK_WINDOW(data->dialog1),GTK_WINDOW(xa_main_window)); gtk_dialog_set_has_separator (GTK_DIALOG (data->dialog1),FALSE); gtk_container_set_border_width (GTK_CONTAINER (data->dialog1),5); gtk_widget_set_size_request(data->dialog1,380,380); dialog_vbox1 = GTK_DIALOG (data->dialog1)->vbox; vbox1 = gtk_vbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (dialog_vbox1),vbox1,TRUE,TRUE,0); hbox1 = gtk_hbox_new (FALSE, 1); gtk_box_pack_start (GTK_BOX (vbox1),hbox1,FALSE,FALSE,0); if (nr == 1) { icon_name = xa_get_stock_mime_icon(filename); pixbuf = gtk_icon_theme_load_icon(icon_theme,icon_name,40,0,NULL); mime_icon = gtk_image_new_from_pixbuf(pixbuf); if (pixbuf) g_object_unref(pixbuf); gtk_box_pack_start (GTK_BOX (hbox1),mime_icon,FALSE,TRUE,0); gtk_misc_set_alignment (GTK_MISC (mime_icon),0,0); open_text = gtk_label_new(""); gtk_box_pack_start (GTK_BOX (hbox1),open_text,FALSE,FALSE,10); text = g_strdup_printf(_("Open <i>%s</i> with:"),filename); gtk_label_set_use_markup (GTK_LABEL (open_text),TRUE); gtk_label_set_markup (GTK_LABEL (open_text),text); g_free(text); } scrolledwindow1 = gtk_scrolled_window_new (NULL,NULL); gtk_box_pack_start (GTK_BOX (vbox1),scrolledwindow1,TRUE,TRUE,0); g_object_set (G_OBJECT (scrolledwindow1),"hscrollbar-policy",GTK_POLICY_AUTOMATIC,"shadow-type",GTK_SHADOW_IN,"vscrollbar-policy",GTK_POLICY_AUTOMATIC,NULL); data->apps_liststore = gtk_list_store_new (3,GDK_TYPE_PIXBUF,G_TYPE_STRING,G_TYPE_STRING); apps_treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(data->apps_liststore)); gtk_container_add (GTK_CONTAINER (scrolledwindow1),apps_treeview); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(apps_treeview),FALSE); GtkTreeSelection *sel = gtk_tree_view_get_selection( GTK_TREE_VIEW (apps_treeview)); g_signal_connect ((gpointer) sel,"changed",G_CALLBACK (xa_open_with_dialog_selection_changed),data); /* First column: icon + text */ column = gtk_tree_view_column_new(); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column,renderer, FALSE); gtk_tree_view_column_set_attributes(column,renderer,"pixbuf",0,NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start(column,renderer, TRUE); gtk_tree_view_column_set_attributes( column,renderer,"text",1,NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(data->apps_liststore),1,GTK_SORT_ASCENDING); gtk_tree_view_append_column (GTK_TREE_VIEW (apps_treeview), column); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); /* Hidden column with the application executable name */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_visible(column,FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (apps_treeview), column); custom_command_expander = gtk_expander_new_with_mnemonic(_("Use a custom command:")); gtk_box_pack_start (GTK_BOX (vbox1),custom_command_expander,FALSE,FALSE,0); hbox_expander = gtk_hbox_new(FALSE,5); data->custom_command_entry = gtk_entry_new(); g_signal_connect (G_OBJECT (data->custom_command_entry),"activate",G_CALLBACK (xa_open_with_dialog_custom_entry_activated),data); browse = gtk_button_new_with_label(_("Browse")); g_signal_connect (G_OBJECT (browse),"clicked",G_CALLBACK (xa_open_with_dialog_browse_custom_command),data); gtk_box_pack_start (GTK_BOX (hbox_expander),data->custom_command_entry,TRUE,TRUE,0); gtk_box_pack_start (GTK_BOX (hbox_expander),browse,FALSE,TRUE,0); gtk_container_add(GTK_CONTAINER(custom_command_expander),hbox_expander); dialog_action_area1 = GTK_DIALOG (data->dialog1)->action_area; gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1),GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (data->dialog1),cancelbutton1,GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); g_signal_connect_swapped (G_OBJECT (cancelbutton1),"clicked",G_CALLBACK (gtk_widget_destroy),G_OBJECT(data->dialog1)); okbutton1 = gtk_button_new_from_stock ("gtk-open"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (data->dialog1),okbutton1,GTK_RESPONSE_OK); g_signal_connect (G_OBJECT (okbutton1),"clicked",G_CALLBACK (xa_open_with_dialog_execute_command),data); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); gtk_widget_show_all(data->dialog1); /* Let's parse the desktop files in all the system data dirs */ desktop_dirs = g_get_system_data_dirs(); while (desktop_dirs[x]) { xa_read_desktop_directories(data->apps_liststore,desktop_dirs[x]); x++; } gtk_tree_model_get_iter_first(GTK_TREE_MODEL(data->apps_liststore),&iter); gtk_tree_selection_select_iter(gtk_tree_view_get_selection (GTK_TREE_VIEW (apps_treeview)),&iter); g_signal_connect (G_OBJECT (apps_treeview), "row-activated",G_CALLBACK(xa_open_with_dialog_row_selected),data); g_signal_connect (G_OBJECT (data->dialog1), "destroy", G_CALLBACK(xa_destroy_open_with_dialog),data); }
/* * inject form a file */ static void gtkui_connection_inject_file(void) { /* START */ GtkWidget *dialog, *label, *vbox, *hbox; GtkWidget *button1, *button2, *button, *entry; char tmp[MAX_ASCII_ADDR_LEN]; const char *filename = NULL; gint response = 0; DEBUG_MSG("gtk_connection_inject_file"); if(curr_conn == NULL) return; dialog = gtk_dialog_new_with_buttons("Character Injection", GTK_WINDOW (window), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_window_set_default_size(GTK_WINDOW (dialog), 400, 150); gtk_dialog_set_has_separator(GTK_DIALOG (dialog), FALSE); gtk_container_set_border_width(GTK_CONTAINER (dialog), 5); vbox = GTK_DIALOG (dialog)->vbox; label = gtk_label_new ("Packet destination:"); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show(label); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); button1 = gtk_radio_button_new_with_label(NULL, ip_addr_ntoa(&curr_conn->L3_addr2, tmp)); gtk_box_pack_start(GTK_BOX(hbox), button1, FALSE, FALSE, 0); gtk_widget_show(button1); button2 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (button1), ip_addr_ntoa(&curr_conn->L3_addr1, tmp)); gtk_box_pack_start(GTK_BOX(hbox), button2, FALSE, FALSE, 0); gtk_widget_show(button2); label = gtk_label_new ("File to inject:"); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show(label); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX (hbox), entry, TRUE, TRUE, 0); gtk_widget_show(entry); button = gtk_button_new_with_label("..."); gtk_box_pack_start(GTK_BOX (hbox), button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK (gtkui_filename_browse), entry); gtk_widget_show(button); response = gtk_dialog_run(GTK_DIALOG (dialog)); if(response == GTK_RESPONSE_OK) { gtk_widget_hide(dialog); filename = gtk_entry_get_text(GTK_ENTRY (entry)); if(filename && strlen(filename) > 0) { if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (button1))) gtkui_inject_file(filename, 1); else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (button2))) gtkui_inject_file(filename, 2); } } gtk_widget_destroy(dialog); }
static void thunar_uca_chooser_init (ThunarUcaChooser *uca_chooser) { GtkTreeViewColumn *column; GtkTreeSelection *selection; GtkCellRenderer *renderer; ThunarUcaModel *uca_model; GtkWidget *image; GtkWidget *label; GtkWidget *hbox; GtkWidget *swin; GtkWidget *vbox; /* configure the dialog window */ gtk_dialog_add_button (GTK_DIALOG (uca_chooser), GTK_STOCK_HELP, GTK_RESPONSE_HELP); gtk_dialog_add_button (GTK_DIALOG (uca_chooser), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_dialog_set_default_response (GTK_DIALOG (uca_chooser), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator (GTK_DIALOG (uca_chooser), FALSE); gtk_window_set_default_size (GTK_WINDOW (uca_chooser), 500, 350); gtk_window_set_destroy_with_parent (GTK_WINDOW (uca_chooser), TRUE); gtk_window_set_title (GTK_WINDOW (uca_chooser), _("Custom Actions")); hbox = gtk_hbox_new (FALSE, 3); gtk_container_set_border_width (GTK_CONTAINER (hbox), 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (uca_chooser)->vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DND); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); gtk_widget_show (image); label = gtk_label_new (_("You can configure custom actions that will appear in the\n" "file managers context menus for certain kinds of files.")); gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); hbox = gtk_hbox_new (FALSE, 3); gtk_container_set_border_width (GTK_CONTAINER (hbox), 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (uca_chooser)->vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); swin = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swin), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), swin, TRUE, TRUE, 0); gtk_widget_show (swin); uca_chooser->treeview = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (uca_chooser->treeview), FALSE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (uca_chooser->treeview), TRUE); gtk_container_add (GTK_CONTAINER (swin), uca_chooser->treeview); g_signal_connect_swapped (G_OBJECT (uca_chooser->treeview), "row-activated", G_CALLBACK (thunar_uca_chooser_edit_clicked), uca_chooser); gtk_widget_show (uca_chooser->treeview); uca_model = thunar_uca_model_get_default (); gtk_tree_view_set_model (GTK_TREE_VIEW (uca_chooser->treeview), GTK_TREE_MODEL (uca_model)); g_object_unref (G_OBJECT (uca_model)); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_column_set_resizable (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (uca_chooser->treeview), column); renderer = g_object_new (GTK_TYPE_CELL_RENDERER_PIXBUF, "stock-size", GTK_ICON_SIZE_DND, "xpad", 2, "ypad", 2, NULL); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "icon-name", THUNAR_UCA_MODEL_COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "markup", THUNAR_UCA_MODEL_COLUMN_STOCK_LABEL, NULL); vbox = gtk_vbox_new (FALSE, 3); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); uca_chooser->add_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->add_button, _("Add a new custom action.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->add_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->add_button), "clicked", G_CALLBACK (thunar_uca_chooser_add_clicked), uca_chooser); gtk_widget_show (uca_chooser->add_button); image = gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->add_button), image); gtk_widget_show (image); uca_chooser->edit_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->edit_button, _("Edit the currently selected action.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->edit_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->edit_button), "clicked", G_CALLBACK (thunar_uca_chooser_edit_clicked), uca_chooser); gtk_widget_show (uca_chooser->edit_button); image = gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->edit_button), image); gtk_widget_show (image); uca_chooser->delete_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->delete_button, _("Delete the currently selected action.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->delete_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->delete_button), "clicked", G_CALLBACK (thunar_uca_chooser_delete_clicked), uca_chooser); gtk_widget_show (uca_chooser->delete_button); image = gtk_image_new_from_stock (GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->delete_button), image); gtk_widget_show (image); uca_chooser->up_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->up_button, _("Move the currently selected action up by one row.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->up_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->up_button), "clicked", G_CALLBACK (thunar_uca_chooser_up_clicked), uca_chooser); gtk_widget_show (uca_chooser->up_button); image = gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->up_button), image); gtk_widget_show (image); uca_chooser->down_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->down_button, _("Move the currently selected action down by one row.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->down_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->down_button), "clicked", G_CALLBACK (thunar_uca_chooser_down_clicked), uca_chooser); gtk_widget_show (uca_chooser->down_button); image = gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->down_button), image); gtk_widget_show (image); /* configure the tree view selection after the buttons have been created */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (uca_chooser->treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect_swapped (G_OBJECT (selection), "changed", G_CALLBACK (thunar_uca_chooser_selection_changed), uca_chooser); thunar_uca_chooser_selection_changed (uca_chooser, selection); }
static gboolean median_dialog(MedianBgArgs *args) { enum { RESPONSE_RESET = 1 }; GtkWidget *dialog, *table, *spin; MedianBgControls controls; gint response, row; gdouble q; dialog = gtk_dialog_new_with_buttons(_("Median Level"), NULL, 0, _("_Reset"), RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); table = gtk_table_new(5, 4, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, FALSE, FALSE, 4); row = 0; controls.in_update = TRUE; q = args->pixelsize/args->valform->magnitude; gwy_debug("q = %f", q); controls.radius = gtk_adjustment_new(q*args->size, q, 16384*q, q, 10*q, 0); spin = gwy_table_attach_hscale(table, row, _("Real _radius:"), args->valform->units, controls.radius, GWY_HSCALE_SQRT); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), args->valform->precision); g_object_set_data(G_OBJECT(controls.radius), "controls", &controls); g_signal_connect(controls.radius, "value-changed", G_CALLBACK(radius_changed_cb), args); row++; controls.size = gtk_adjustment_new(args->size, 1, 16384, 1, 10, 0); spin = gwy_table_attach_hscale(table, row, _("_Pixel radius:"), "px", controls.size, GWY_HSCALE_SQRT); g_object_set_data(G_OBJECT(controls.size), "controls", &controls); g_signal_connect(controls.size, "value-changed", G_CALLBACK(size_changed_cb), args); row++; controls.do_extract = gtk_check_button_new_with_mnemonic(_("E_xtract background")); gtk_table_attach(GTK_TABLE(table), controls.do_extract, 0, 4, row, row+1, GTK_FILL, 0, 0, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.do_extract), args->do_extract); g_signal_connect(controls.do_extract, "toggled", G_CALLBACK(do_extract_changed_cb), args); row++; controls.in_update = FALSE; gtk_widget_show_all(dialog); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: gtk_widget_destroy(dialog); case GTK_RESPONSE_NONE: return FALSE; break; case GTK_RESPONSE_OK: break; case RESPONSE_RESET: args->size = median_defaults.size; args->do_extract = median_defaults.do_extract; median_dialog_update(&controls, args); break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); gtk_widget_destroy(dialog); return TRUE; }
GtkWidget* create_Calculator (void) { GtkWidget *Calculator; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *framebox; GtkWidget *alignment1; GtkWidget *table2; GtkWidget *hbox5; GtkWidget *heading; GtkWidget *labelDOO; GtkWidget *labelDuration; GtkWidget *hbox14; GtkWidget *label2; GtkWidget *hbox16; GtkWidget *label16; GtkWidget *entryCustom; GtkWidget *hbox21; GtkWidget *label14; GtkWidget *hbox18; GtkWidget *optionmenu2; GtkWidget *menu2; GtkWidget *avi1; GtkWidget *ogm1; GtkWidget *mpeg1; GtkWidget *hbox17; GtkWidget *optionmenu1; GtkWidget *menu1; GtkWidget *_1x80_cd1; GtkWidget *_2x80_cd1; GtkWidget *_1x74_cd1; GtkWidget *_2x74_cd1; GtkWidget *dvd1; GtkWidget *custom1; GtkWidget *hbox11; GtkWidget *hbox12; GtkWidget *hbox13; GtkWidget *label6; GtkWidget *entry3; GtkWidget *label7; GtkWidget *entry4; GtkWidget *hbox20; GtkWidget *table3; GtkWidget *label9; GtkWidget *labelAudio; GtkWidget *label11; GtkWidget *labelVideo; GtkWidget *label17; GtkWidget *labelTotal; GtkWidget *table4; GtkWidget *label12; GtkWidget *label15; GtkWidget *labelBitrate; GtkWidget *labelBPP; GtkWidget *dialog_action_area1; GtkWidget *doit; GtkWidget *button1; GtkTooltips *tooltips; tooltips = gtk_tooltips_new (); Calculator = gtk_dialog_new (); gtk_container_set_border_width (GTK_CONTAINER (Calculator), 6); gtk_window_set_title (GTK_WINDOW (Calculator), QT_TR_NOOP("Calculator")); gtk_window_set_resizable (GTK_WINDOW (Calculator), FALSE); gtk_dialog_set_has_separator (GTK_DIALOG (Calculator), FALSE); dialog_vbox1 = GTK_DIALOG (Calculator)->vbox; gtk_box_set_spacing (GTK_BOX(dialog_vbox1), 12); gtk_widget_show (dialog_vbox1); vbox1 = gtk_vbox_new (FALSE, 18); gtk_container_set_border_width (GTK_CONTAINER (vbox1), 6); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0); heading = gtk_label_new (QT_TR_NOOP("<b>Target</b>")); gtk_misc_set_alignment (GTK_MISC (heading), 0, 1); gtk_label_set_use_markup (GTK_LABEL (heading), TRUE); gtk_widget_show (heading); table2 = gtk_table_new (3, 4, FALSE); gtk_widget_show (table2); gtk_table_set_row_spacings (GTK_TABLE (table2), 6); gtk_table_set_col_spacings (GTK_TABLE (table2), 12); alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment1), 6, 0, 18, 0); gtk_container_add (GTK_CONTAINER (alignment1), table2); framebox = gtk_vbox_new (0, 0); gtk_box_pack_start (GTK_BOX(vbox1), framebox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(framebox), heading, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(framebox), alignment1, FALSE, FALSE, 0); gtk_widget_show(framebox); hbox5 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox5); gtk_table_attach (GTK_TABLE (table2), hbox5, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); labelDOO = gtk_label_new (QT_TR_NOOP("Duration:")); gtk_widget_show (labelDOO); gtk_box_pack_start (GTK_BOX (hbox5), labelDOO, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (labelDOO), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelDOO), 0, 0.5); labelDuration = gtk_label_new (QT_TR_NOOP("00:00:00")); gtk_widget_show (labelDuration); gtk_table_attach (GTK_TABLE (table2), labelDuration, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelDuration), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelDuration), 0, 0.5); hbox14 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox14); gtk_table_attach (GTK_TABLE (table2), hbox14, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); label2 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Medium:")); gtk_widget_show (label2); gtk_box_pack_start (GTK_BOX (hbox14), label2, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); hbox16 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox16); gtk_table_attach (GTK_TABLE (table2), hbox16, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); label16 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Format:")); gtk_widget_show (label16); gtk_box_pack_start (GTK_BOX (hbox16), label16, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label16), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label16), 0, 0.5); entryCustom = gtk_entry_new (); gtk_widget_show (entryCustom); gtk_table_attach (GTK_TABLE (table2), entryCustom, 3, 4, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_tooltips_set_tip (tooltips, entryCustom, QT_TR_NOOP("Total size (custom)"), NULL); gtk_entry_set_max_length (GTK_ENTRY (entryCustom), 10); gtk_entry_set_width_chars (GTK_ENTRY (entryCustom), 6); hbox21 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox21); gtk_table_attach (GTK_TABLE (table2), hbox21, 2, 3, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); label14 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Custom size (MB):")); gtk_widget_show (label14); gtk_box_pack_start (GTK_BOX (hbox21), label14, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label14), GTK_JUSTIFY_LEFT); hbox18 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox18); gtk_table_attach (GTK_TABLE (table2), hbox18, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); optionmenu2 = gtk_option_menu_new (); gtk_widget_show (optionmenu2); gtk_box_pack_start (GTK_BOX (hbox18), optionmenu2, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, optionmenu2, QT_TR_NOOP("Output container format"), NULL); menu2 = gtk_menu_new (); avi1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("AVI")); gtk_widget_show (avi1); gtk_container_add (GTK_CONTAINER (menu2), avi1); ogm1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("OGM")); gtk_widget_show (ogm1); gtk_container_add (GTK_CONTAINER (menu2), ogm1); mpeg1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("MPEG")); gtk_widget_show (mpeg1); gtk_container_add (GTK_CONTAINER (menu2), mpeg1); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu2), menu2); hbox17 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox17); gtk_table_attach (GTK_TABLE (table2), hbox17, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); optionmenu1 = gtk_option_menu_new (); gtk_widget_show (optionmenu1); gtk_box_pack_start (GTK_BOX (hbox17), optionmenu1, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, optionmenu1, QT_TR_NOOP("Total size"), NULL); menu1 = gtk_menu_new (); _1x80_cd1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("1x 80 min. CD")); gtk_widget_show (_1x80_cd1); gtk_container_add (GTK_CONTAINER (menu1), _1x80_cd1); gtk_tooltips_set_tip (tooltips, _1x80_cd1, QT_TR_NOOP("Total size (custom)"), NULL); _2x80_cd1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("2x 80 min. CD")); gtk_widget_show (_2x80_cd1); gtk_container_add (GTK_CONTAINER (menu1), _2x80_cd1); _1x74_cd1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("1x 74 min. CD")); gtk_widget_show (_1x74_cd1); gtk_container_add (GTK_CONTAINER (menu1), _1x74_cd1); _2x74_cd1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("2x 74 min. CD")); gtk_widget_show (_2x74_cd1); gtk_container_add (GTK_CONTAINER (menu1), _2x74_cd1); dvd1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("DVD5")); gtk_widget_show (dvd1); gtk_container_add (GTK_CONTAINER (menu1), dvd1); custom1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("Custom")); gtk_widget_show (custom1); gtk_container_add (GTK_CONTAINER (menu1), custom1); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1), menu1); hbox11 = gtk_hbox_new (TRUE, 12); gtk_widget_show (hbox11); hbox12 = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (hbox11), hbox12, TRUE, TRUE, 0); gtk_widget_show (hbox12); label6 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Track _1:")); gtk_widget_show (label6); gtk_box_pack_start (GTK_BOX (hbox12), label6, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT); entry3 = gtk_entry_new (); gtk_widget_show (entry3); gtk_box_pack_start (GTK_BOX (hbox12), entry3, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, entry3, QT_TR_NOOP("Audio bitrate in kb/s for track 1 (0 for no audio)"), NULL); gtk_entry_set_max_length (GTK_ENTRY (entry3), 10); gtk_entry_set_width_chars (GTK_ENTRY (entry3), 6); hbox13 = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (hbox11), hbox13, TRUE, TRUE, 0); gtk_widget_show (hbox13); label7 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Track _2: ")); gtk_widget_show (label7); gtk_box_pack_start (GTK_BOX (hbox13), label7, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_LEFT); entry4 = gtk_entry_new (); gtk_widget_show (entry4); gtk_box_pack_start (GTK_BOX (hbox13), entry4, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, entry4, QT_TR_NOOP("Audio bitrate in kb/s for track 2 (optional)"), NULL); gtk_entry_set_max_length (GTK_ENTRY (entry4), 10); gtk_entry_set_width_chars (GTK_ENTRY (entry4), 6); heading = gtk_label_new (QT_TR_NOOP("<b>Audio Bitrate</b>")); gtk_label_set_use_markup (GTK_LABEL (heading), TRUE); gtk_misc_set_alignment (GTK_MISC (heading), 0, 1); gtk_widget_show (heading); alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment1), 6, 0, 18, 0); gtk_container_add (GTK_CONTAINER (alignment1), hbox11); framebox = gtk_vbox_new (0, 0); gtk_box_pack_start (GTK_BOX(vbox1), framebox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(framebox), heading, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(framebox), alignment1, FALSE, FALSE, 0); gtk_widget_show(framebox); hbox20 = gtk_hbox_new (TRUE, 12); gtk_widget_show (hbox20); table3 = gtk_table_new (3, 2, FALSE); gtk_widget_show (table3); gtk_box_pack_start (GTK_BOX (hbox20), table3, TRUE, TRUE, 0); gtk_table_set_row_spacings (GTK_TABLE (table3), 6); gtk_table_set_col_spacings (GTK_TABLE (table3), 12); label9 = gtk_label_new (QT_TR_NOOP("Audio size (MB):")); gtk_widget_show (label9); gtk_table_attach (GTK_TABLE (table3), label9, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label9), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5); labelAudio = gtk_label_new (QT_TR_NOOP("0")); gtk_widget_show (labelAudio); gtk_table_attach (GTK_TABLE (table3), labelAudio, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelAudio), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelAudio), 0, 0.5); label11 = gtk_label_new (QT_TR_NOOP("Video size (MB):")); gtk_widget_show (label11); gtk_table_attach (GTK_TABLE (table3), label11, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label11), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label11), 0, 0.5); labelVideo = gtk_label_new (QT_TR_NOOP("0")); gtk_widget_show (labelVideo); gtk_table_attach (GTK_TABLE (table3), labelVideo, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelVideo), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelVideo), 0, 0.5); label17 = gtk_label_new (QT_TR_NOOP("Total size (MB):")); gtk_widget_show (label17); gtk_table_attach (GTK_TABLE (table3), label17, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label17), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label17), 0, 0.5); labelTotal = gtk_label_new (QT_TR_NOOP("0")); gtk_widget_show (labelTotal); gtk_table_attach (GTK_TABLE (table3), labelTotal, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelTotal), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelTotal), 0, 0.5); table4 = gtk_table_new (2, 2, FALSE); gtk_widget_show (table4); gtk_box_pack_start (GTK_BOX (hbox20), table4, TRUE, TRUE, 0); gtk_table_set_row_spacings (GTK_TABLE (table4), 6); gtk_table_set_col_spacings (GTK_TABLE (table4), 6); label12 = gtk_label_new (QT_TR_NOOP("Video bitrate:")); gtk_widget_show (label12); gtk_table_attach (GTK_TABLE (table4), label12, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label12), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label12), 0, 0.5); label15 = gtk_label_new (QT_TR_NOOP("Bits per pixel:")); gtk_widget_show (label15); gtk_table_attach (GTK_TABLE (table4), label15, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label15), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label15), 0, 0.5); labelBitrate = gtk_label_new (QT_TR_NOOP("0")); gtk_widget_show (labelBitrate); gtk_table_attach (GTK_TABLE (table4), labelBitrate, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelBitrate), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelBitrate), 0, 0.5); labelBPP = gtk_label_new (QT_TR_NOOP("0.0")); gtk_widget_show (labelBPP); gtk_table_attach (GTK_TABLE (table4), labelBPP, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelBPP), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelBPP), 0, 0.5); heading = gtk_label_new (QT_TR_NOOP("<b>Result</b>")); gtk_misc_set_alignment (GTK_MISC (heading), 0, 1); gtk_label_set_use_markup (GTK_LABEL (heading), TRUE); gtk_widget_show (heading); alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment1), 6, 0, 18, 0); gtk_container_add (GTK_CONTAINER (alignment1), hbox20); framebox = gtk_vbox_new (0, 0); gtk_box_pack_start (GTK_BOX(vbox1), framebox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(framebox), heading, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(framebox), alignment1, FALSE, FALSE, 0); gtk_widget_show(framebox); dialog_action_area1 = GTK_DIALOG (Calculator)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); doit = gtk_button_new_from_stock ("gtk-apply"); gtk_widget_show (doit); gtk_dialog_add_action_widget (GTK_DIALOG (Calculator), doit, GTK_RESPONSE_APPLY); GTK_WIDGET_SET_FLAGS (doit, GTK_CAN_DEFAULT); button1 = gtk_button_new_from_stock ("gtk-close"); gtk_widget_show (button1); gtk_dialog_add_action_widget (GTK_DIALOG (Calculator), button1, GTK_RESPONSE_CLOSE); GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT); gtk_label_set_mnemonic_widget (GTK_LABEL (label2), optionmenu1); gtk_label_set_mnemonic_widget (GTK_LABEL (label16), optionmenu2); gtk_label_set_mnemonic_widget (GTK_LABEL (label14), entryCustom); gtk_label_set_mnemonic_widget (GTK_LABEL (label6), entry3); gtk_label_set_mnemonic_widget (GTK_LABEL (label7), entry4); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (Calculator, Calculator, "Calculator"); GLADE_HOOKUP_OBJECT_NO_REF (Calculator, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (Calculator, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (Calculator, framebox, "framebox"); GLADE_HOOKUP_OBJECT (Calculator, alignment1, "alignment1"); GLADE_HOOKUP_OBJECT (Calculator, table2, "table2"); GLADE_HOOKUP_OBJECT (Calculator, hbox5, "hbox5"); GLADE_HOOKUP_OBJECT (Calculator, heading, "heading"); GLADE_HOOKUP_OBJECT (Calculator, labelDOO, "labelDOO"); GLADE_HOOKUP_OBJECT (Calculator, labelDuration, "labelDuration"); GLADE_HOOKUP_OBJECT (Calculator, hbox14, "hbox14"); GLADE_HOOKUP_OBJECT (Calculator, label2, "label2"); GLADE_HOOKUP_OBJECT (Calculator, hbox16, "hbox16"); GLADE_HOOKUP_OBJECT (Calculator, label16, "label16"); GLADE_HOOKUP_OBJECT (Calculator, entryCustom, "entryCustom"); GLADE_HOOKUP_OBJECT (Calculator, hbox21, "hbox21"); GLADE_HOOKUP_OBJECT (Calculator, label14, "label14"); GLADE_HOOKUP_OBJECT (Calculator, hbox18, "hbox18"); GLADE_HOOKUP_OBJECT (Calculator, optionmenu2, "optionmenu2"); GLADE_HOOKUP_OBJECT (Calculator, menu2, "menu2"); GLADE_HOOKUP_OBJECT (Calculator, avi1, "avi1"); GLADE_HOOKUP_OBJECT (Calculator, ogm1, "ogm1"); GLADE_HOOKUP_OBJECT (Calculator, mpeg1, "mpeg1"); GLADE_HOOKUP_OBJECT (Calculator, hbox17, "hbox17"); GLADE_HOOKUP_OBJECT (Calculator, optionmenu1, "optionmenu1"); GLADE_HOOKUP_OBJECT (Calculator, menu1, "menu1"); GLADE_HOOKUP_OBJECT (Calculator, _1x80_cd1, "_1x80_cd1"); GLADE_HOOKUP_OBJECT (Calculator, _2x80_cd1, "_2x80_cd1"); GLADE_HOOKUP_OBJECT (Calculator, _1x74_cd1, "_1x74_cd1"); GLADE_HOOKUP_OBJECT (Calculator, _2x74_cd1, "_2x74_cd1"); GLADE_HOOKUP_OBJECT (Calculator, dvd1, "dvd1"); GLADE_HOOKUP_OBJECT (Calculator, custom1, "custom1"); GLADE_HOOKUP_OBJECT (Calculator, hbox11, "hbox11"); GLADE_HOOKUP_OBJECT (Calculator, hbox12, "hbox12"); GLADE_HOOKUP_OBJECT (Calculator, hbox13, "hbox13"); GLADE_HOOKUP_OBJECT (Calculator, label6, "label6"); GLADE_HOOKUP_OBJECT (Calculator, entry3, "entry3"); GLADE_HOOKUP_OBJECT (Calculator, label7, "label7"); GLADE_HOOKUP_OBJECT (Calculator, entry4, "entry4"); GLADE_HOOKUP_OBJECT (Calculator, hbox20, "hbox20"); GLADE_HOOKUP_OBJECT (Calculator, table3, "table3"); GLADE_HOOKUP_OBJECT (Calculator, label9, "label9"); GLADE_HOOKUP_OBJECT (Calculator, labelAudio, "labelAudio"); GLADE_HOOKUP_OBJECT (Calculator, label11, "label11"); GLADE_HOOKUP_OBJECT (Calculator, labelVideo, "labelVideo"); GLADE_HOOKUP_OBJECT (Calculator, label17, "label17"); GLADE_HOOKUP_OBJECT (Calculator, labelTotal, "labelTotal"); GLADE_HOOKUP_OBJECT (Calculator, table4, "table4"); GLADE_HOOKUP_OBJECT (Calculator, label12, "label12"); GLADE_HOOKUP_OBJECT (Calculator, label15, "label15"); GLADE_HOOKUP_OBJECT (Calculator, labelBitrate, "labelBitrate"); GLADE_HOOKUP_OBJECT (Calculator, labelBPP, "labelBPP"); GLADE_HOOKUP_OBJECT_NO_REF (Calculator, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (Calculator, doit, "doit"); GLADE_HOOKUP_OBJECT (Calculator, button1, "button1"); GLADE_HOOKUP_OBJECT_NO_REF (Calculator, tooltips, "tooltips"); gtk_widget_grab_focus (entry3); return Calculator; }
static void gdict_pref_dialog_init (GdictPrefDialog *dialog) { gchar *font; GError *error = NULL; gtk_window_set_default_size (GTK_WINDOW (dialog), DEFAULT_MIN_WIDTH, DEFAULT_MIN_HEIGHT); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), 2); gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE); /* add buttons */ gtk_dialog_add_button (GTK_DIALOG (dialog), "gtk-help", GTK_RESPONSE_HELP); gtk_dialog_add_button (GTK_DIALOG (dialog), "gtk-close", GTK_RESPONSE_ACCEPT); dialog->gconf_client = gconf_client_get_default (); gconf_client_add_dir (dialog->gconf_client, GDICT_GCONF_DIR, GCONF_CLIENT_PRELOAD_ONELEVEL, NULL); dialog->notify_id = gconf_client_notify_add (dialog->gconf_client, GDICT_GCONF_DIR, gdict_pref_dialog_gconf_notify_cb, dialog, NULL, NULL); /* get the UI from the GtkBuilder file */ dialog->builder = gtk_builder_new (); gtk_builder_add_from_file (dialog->builder, GDICT_PREFERENCES_UI, &error); if (error) { g_critical ("Unable to load the preferences user interface: %s", error->message); g_error_free (error); g_assert_not_reached (); } /* the main widget */ gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), GTK_WIDGET (gtk_builder_get_object (dialog->builder, "preferences_root"))); /* keep all the interesting widgets around */ dialog->notebook = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "preferences_notebook")); dialog->sources_view = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "sources_treeview")); build_sources_view (dialog); dialog->active_source = gdict_gconf_get_string_with_default (dialog->gconf_client, GDICT_GCONF_SOURCE_KEY, GDICT_DEFAULT_SOURCE_NAME); dialog->sources_add = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "add_button")); gtk_widget_set_tooltip_text (dialog->sources_add, _("Add a new dictionary source")); g_signal_connect (dialog->sources_add, "clicked", G_CALLBACK (source_add_clicked_cb), dialog); dialog->sources_remove = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "remove_button")); gtk_widget_set_tooltip_text (dialog->sources_remove, _("Remove the currently selected dictionary source")); g_signal_connect (dialog->sources_remove, "clicked", G_CALLBACK (source_remove_clicked_cb), dialog); font = gconf_client_get_string (dialog->gconf_client, GDICT_GCONF_PRINT_FONT_KEY, NULL); if (!font) font = g_strdup (GDICT_DEFAULT_PRINT_FONT); dialog->font_button = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "print_font_button")); gtk_font_button_set_font_name (GTK_FONT_BUTTON (dialog->font_button), font); gtk_widget_set_tooltip_text (dialog->font_button, _("Set the font used for printing the definitions")); g_signal_connect (dialog->font_button, "font-set", G_CALLBACK (font_button_font_set_cb), dialog); g_free (font); gtk_widget_show_all (dialog->notebook); /* we want to intercept the response signal before any other * callbacks might be attached by the users of the * GdictPrefDialog widget. */ g_signal_connect (dialog, "response", G_CALLBACK (response_cb), NULL); }
static void xfsm_chooser_init (XfsmChooser *chooser) { GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkListStore *model; GtkWidget *button; GtkWidget *swin; GtkWidget *dbox; dbox = GTK_DIALOG (chooser)->vbox; gtk_dialog_set_has_separator (GTK_DIALOG (chooser), FALSE); g_signal_connect_after (G_OBJECT (chooser), "realize", G_CALLBACK (xfsm_chooser_realized), chooser); /* scrolled window */ swin = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swin), GTK_SHADOW_ETCHED_IN); gtk_box_pack_start (GTK_BOX (dbox), swin, TRUE, TRUE, 0); gtk_widget_show (swin); /* tree view */ model = gtk_list_store_new (N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); chooser->tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(model)); g_object_unref (G_OBJECT (model)); gtk_widget_set_tooltip_text (chooser->tree, _("Choose the session you want to restore. " "You can simply double-click the session " "name to restore it.")); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (chooser->tree), FALSE); column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", PREVIEW_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "markup", TITLE_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (chooser->tree), column); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (chooser->tree)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (chooser->tree), "row-activated", G_CALLBACK (xfsm_chooser_row_activated), chooser); gtk_container_add (GTK_CONTAINER (swin), chooser->tree); gtk_widget_set_size_request (chooser->tree, -1, 150); gtk_widget_show (chooser->tree); /* "Logout" button */ button = xfce_gtk_button_new_mixed (GTK_STOCK_QUIT, _("Log out")); gtk_widget_set_tooltip_text (button, _("Cancel the login attempt and return to " "the login screen.")); gtk_dialog_add_action_widget (GTK_DIALOG (chooser), button, GTK_RESPONSE_CANCEL); gtk_widget_show (button); /* "New" button */ button = xfce_gtk_button_new_mixed (GTK_STOCK_NEW, _("New session")); gtk_widget_set_tooltip_text (button, _("Create a new session.")); gtk_dialog_add_action_widget (GTK_DIALOG (chooser), button, XFSM_RESPONSE_NEW); gtk_widget_show (button); }
int main (int argc, char *argv[]) { GtkWidget *dialog; char *ret; const char *message; GOptionContext *ctx; bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); /* Option parsing */ ctx = g_option_context_new ("- New mdm login"); g_option_context_add_main_entries (ctx, options, _("main options")); g_option_context_parse (ctx, &argc, &argv, NULL); g_option_context_free (ctx); mdm_log_init (); mdm_log_set_debug (debug_in); if (send_command != NULL) { if ( ! mdmcomm_is_daemon_running (FALSE)) { mdm_common_error (_("Error: MDM (MDM Display Manager) is not running.")); mdm_common_error (_("You might be using a different display manager.")); return 1; } } else { /* * The --command argument does not display anything, so avoid * running gtk_init until it finishes. Sometimes the * --command argument is used when there is no display so it * will fail and cause the program to exit, complaining about * "no display". */ gtk_init (&argc, &argv); if ( ! mdmcomm_is_daemon_running (TRUE)) { return 1; } } mdmcomm_open_connection_to_daemon (); /* Process --command option */ g_type_init (); if (send_command != NULL) { /* gdk_init is needed for cookie code to get display */ gdk_init (&argc, &argv); if (authenticate) auth_cookie = mdmcomm_get_auth_cookie (); /* * If asking for a translatable config value, then try to get * the translated value first. If this fails, then go ahead * and call the normal sockets command. */ if (strncmp (send_command, MDM_SUP_GET_CONFIG " ", strlen (MDM_SUP_GET_CONFIG " ")) == 0) { gchar *value = NULL; const char *key = &send_command[strlen (MDM_SUP_GET_CONFIG " ")]; if (is_key (MDM_KEY_WELCOME, key)) { value = mdm_config_get_translated_string ((gchar *)key); if (value != NULL) { ret = g_strdup_printf ("OK %s", value); } } /* * If the above didn't return a value, then must be a * different key, so call the daemon. */ if (value == NULL) ret = mdmcomm_send_cmd_to_daemon_with_args (send_command, auth_cookie, 5); } else { ret = mdmcomm_send_cmd_to_daemon_with_args (send_command, auth_cookie, 5); } /* At this point we are done using the socket, so close it */ mdmcomm_close_connection_to_daemon (); if (ret != NULL) { g_print ("%s\n", ret); return 0; } else { dialog = hig_dialog_new (NULL /* parent */, GTK_DIALOG_MODAL /* flags */, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Cannot communicate with MDM " "(The MDM Display Manager)"), _("Perhaps you have an old version " "of MDM running.")); gtk_widget_show_all (dialog); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); return 1; } } /* * Always attempt to get cookie and authenticate. On remote * servers */ auth_cookie = mdmcomm_get_auth_cookie (); /* check for other displays/logged in users */ check_for_users (); if (auth_cookie == NULL) { /* At this point we are done using the socket, so close it */ mdmcomm_close_connection_to_daemon (); dialog = hig_dialog_new (NULL /* parent */, GTK_DIALOG_MODAL /* flags */, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("You do not seem to be logged in on the " "console"), _("Starting a new login only " "works correctly on the console.")); gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE); gtk_widget_show_all (dialog); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); return 1; } ret = mdmcomm_send_cmd_to_daemon_with_args (MDM_SUP_FLEXI_XSERVER, auth_cookie, 5); g_free (auth_cookie); g_strfreev (args_remaining); /* At this point we are done using the socket, so close it */ mdmcomm_close_connection_to_daemon (); if (ret != NULL && strncmp (ret, "OK ", 3) == 0) { /* if we switched to a different screen as a result of this, * lock the current screen */ if ( ! no_lock ) { maybe_lock_screen (); } /* all fine and dandy */ g_free (ret); return 0; } message = mdmcomm_get_error_message (ret); dialog = hig_dialog_new (NULL /* parent */, GTK_DIALOG_MODAL /* flags */, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Cannot start new display"), message); gtk_widget_show_all (dialog); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); g_free (ret); return 1; }
void gtkui_port_stealing(void) { GtkWidget *dialog, *vbox, *hbox, *image, *button1, *button2, *frame, *content_area; gint response = 0; gboolean remote = FALSE; DEBUG_MSG("gtk_port_stealing"); dialog = gtk_dialog_new_with_buttons("MITM Attack: Port Stealing", 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); #if !GTK_CHECK_VERSION(2, 22, 0) gtk_dialog_set_has_separator(GTK_DIALOG (dialog), FALSE); #endif #if GTK_CHECK_VERSION(3, 0, 0) hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); #else hbox = gtk_hbox_new (FALSE, 5); #endif content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); gtk_container_add(GTK_CONTAINER(content_area), hbox); gtk_widget_show(hbox); 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), image, FALSE, FALSE, 5); gtk_widget_show(image); frame = gtk_frame_new("Optional parameters"); gtk_container_set_border_width(GTK_CONTAINER (frame), 5); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show(frame); #if GTK_CHECK_VERSION(3, 0, 0) vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2); #else vbox = gtk_vbox_new (FALSE, 2); #endif gtk_container_set_border_width(GTK_CONTAINER (vbox), 5); gtk_container_add(GTK_CONTAINER (frame), vbox); gtk_widget_show(vbox); button1 = gtk_check_button_new_with_label("Sniff remote connections."); gtk_box_pack_start(GTK_BOX (vbox), button1, FALSE, FALSE, 0); gtk_widget_show(button1); button2 = gtk_check_button_new_with_label("Propagate to other switches."); gtk_box_pack_start(GTK_BOX (vbox), button2, FALSE, FALSE, 0); gtk_widget_show(button2); response = gtk_dialog_run(GTK_DIALOG(dialog)); if(response == GTK_RESPONSE_OK) { gtk_widget_hide(dialog); const char *s_remote= "", *tree = "", *comma = ""; if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (button1))) { s_remote="remote"; remote = TRUE; } if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (button2))) { if(remote) comma = ","; tree = "tree"; } snprintf(params, PARAMS_LEN+1, "port:%s%s%s", s_remote, comma, tree); gtkui_start_mitm(); } gtk_widget_destroy(dialog); /* a simpler method: gtkui_input_call("Parameters :", params + strlen("port:"), PARAMS_LEN - strlen("port:"), gtkui_start_mitm); */ }
static void alertpanel_create(const gchar *title, const gchar *message, AlertType type, AlertValue default_value, gboolean can_disable, const gchar *button1_label, const gchar *button2_label, const gchar *button3_label) { static PangoFontDescription *font_desc; GtkWidget *image; GtkWidget *label; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *disable_chkbtn; GtkWidget *confirm_area; GtkWidget *button1; GtkWidget *button2; GtkWidget *button3; const gchar *label2; const gchar *label3; gint spacing; debug_print(_("Creating alert panel dialog...\n")); dialog = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW(dialog), title); gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_modal(GTK_WINDOW(dialog), TRUE); manage_window_set_transient(GTK_WINDOW(dialog)); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_widget_realize(dialog); g_signal_connect(G_OBJECT(dialog), "delete_event", G_CALLBACK(alertpanel_deleted), (gpointer)G_ALERTCANCEL); g_signal_connect(G_OBJECT(dialog), "key_press_event", G_CALLBACK(alertpanel_close), (gpointer)G_ALERTCANCEL); g_signal_connect(G_OBJECT(dialog), "focus_out_event", G_CALLBACK(alertpanel_focus_out), NULL); /* for title icon, label and message */ spacing = 12 * gtkut_get_dpi_multiplier(); hbox = gtk_hbox_new(FALSE, spacing); gtk_container_set_border_width(GTK_CONTAINER(hbox), spacing); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 0); /* title icon */ switch (type) { case ALERT_QUESTION: image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); break; case ALERT_WARNING: image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG); break; case ALERT_ERROR: image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_DIALOG); break; case ALERT_NOTICE: default: image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG); break; } gtk_misc_set_alignment(GTK_MISC(image), 0.5, 0.0); gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0); /* for title and message */ vbox = gtk_vbox_new(FALSE, spacing); gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0); label = gtk_label_new(title); gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); if (!font_desc) { gint size; size = pango_font_description_get_size (label->style->font_desc); font_desc = pango_font_description_new(); pango_font_description_set_weight (font_desc, PANGO_WEIGHT_BOLD); pango_font_description_set_size (font_desc, size * PANGO_SCALE_LARGE); } if (font_desc) gtk_widget_modify_font(label, font_desc); /* message label */ label = gtk_label_new(message); gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_label_set_selectable(GTK_LABEL(label), TRUE); GTK_WIDGET_UNSET_FLAGS(label, GTK_CAN_FOCUS); #ifdef G_OS_WIN32 { GtkStyle *style; style = gtk_widget_get_style(dialog); gtk_widget_modify_base(label, GTK_STATE_ACTIVE, &style->base[GTK_STATE_SELECTED]); gtk_widget_modify_text(label, GTK_STATE_ACTIVE, &style->text[GTK_STATE_SELECTED]); } #endif if (can_disable) { hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 0); disable_chkbtn = gtk_check_button_new_with_label (_("Show this message next time")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(disable_chkbtn), TRUE); gtk_box_pack_start(GTK_BOX(hbox), disable_chkbtn, FALSE, FALSE, spacing); g_signal_connect(G_OBJECT(disable_chkbtn), "toggled", G_CALLBACK(alertpanel_button_toggled), GUINT_TO_POINTER(G_ALERTDISABLE)); } /* for button(s) */ if (!button1_label) button1_label = GTK_STOCK_OK; label2 = button2_label; label3 = button3_label; if (label2 && *label2 == '+') label2++; if (label3 && *label3 == '+') label3++; gtkut_stock_button_set_create(&confirm_area, &button1, button1_label, button2_label ? &button2 : NULL, label2, button3_label ? &button3 : NULL, label3); gtk_box_pack_end(GTK_BOX(GTK_DIALOG(dialog)->action_area), confirm_area, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(confirm_area), 5 * gtkut_get_dpi_multiplier()); gtk_widget_grab_default(button1); gtk_widget_grab_focus(button1); if (button2_label && (default_value == G_ALERTALTERNATE || *button2_label == '+')) { gtk_widget_grab_default(button2); gtk_widget_grab_focus(button2); } if (button3_label && (default_value == G_ALERTOTHER || *button3_label == '+')) { gtk_widget_grab_default(button3); gtk_widget_grab_focus(button3); } g_signal_connect(G_OBJECT(button1), "clicked", G_CALLBACK(alertpanel_button_clicked), GUINT_TO_POINTER(G_ALERTDEFAULT)); if (button2_label) g_signal_connect(G_OBJECT(button2), "clicked", G_CALLBACK(alertpanel_button_clicked), GUINT_TO_POINTER(G_ALERTALTERNATE)); if (button3_label) g_signal_connect(G_OBJECT(button3), "clicked", G_CALLBACK(alertpanel_button_clicked), GUINT_TO_POINTER(G_ALERTOTHER)); gtk_widget_show_all(dialog); }
GtkWidget* create_dialog1 (const char *msg) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *hbox1; GtkWidget *image1; GtkWidget *label1; GtkWidget *dialog_action_area1; GtkWidget *button2; GtkWidget *alignment1; GtkWidget *hbox2; GtkWidget *image2; GtkWidget *label2; GtkWidget *button1; GtkWidget *alignment2; GtkWidget *hbox3; GtkWidget *image3; GtkWidget *label3; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Filesystem full / quota exceeded")); gtk_window_set_resizable (GTK_WINDOW (dialog1), FALSE); gtk_dialog_set_has_separator (GTK_DIALOG (dialog1), FALSE); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); hbox1 = gtk_hbox_new (FALSE, 12); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox1, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox1), 12); image1 = gtk_image_new_from_stock ("gtk-dialog-warning", GTK_ICON_SIZE_DIALOG); gtk_widget_show (image1); gtk_box_pack_start (GTK_BOX (hbox1), image1, FALSE, TRUE, 0); label1 = gtk_label_new (msg); gtk_widget_show (label1); gtk_box_pack_start (GTK_BOX (hbox1), label1, TRUE, FALSE, 0); gtk_label_set_use_markup (GTK_LABEL (label1), TRUE); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); button2 = gtk_button_new (); gtk_widget_show (button2); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), button2, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT); alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (alignment1); gtk_container_add (GTK_CONTAINER (button2), alignment1); hbox2 = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox2); gtk_container_add (GTK_CONTAINER (alignment1), hbox2); image2 = gtk_image_new_from_stock ("gtk-cancel", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image2); gtk_box_pack_start (GTK_BOX (hbox2), image2, FALSE, FALSE, 0); label2 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Ignore")); gtk_widget_show (label2); gtk_box_pack_start (GTK_BOX (hbox2), label2, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); button1 = gtk_button_new (); gtk_widget_show (button1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), button1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT); alignment2 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (alignment2); gtk_container_add (GTK_CONTAINER (button1), alignment2); hbox3 = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox3); gtk_container_add (GTK_CONTAINER (alignment2), hbox3); image3 = gtk_image_new_from_stock ("gtk-redo", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image3); gtk_box_pack_start (GTK_BOX (hbox3), image3, FALSE, FALSE, 0); label3 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Retry")); gtk_widget_show (label3); gtk_box_pack_start (GTK_BOX (hbox3), label3, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1"); GLADE_HOOKUP_OBJECT (dialog1, image1, "image1"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, button2, "button2"); GLADE_HOOKUP_OBJECT (dialog1, alignment1, "alignment1"); GLADE_HOOKUP_OBJECT (dialog1, hbox2, "hbox2"); GLADE_HOOKUP_OBJECT (dialog1, image2, "image2"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, button1, "button1"); GLADE_HOOKUP_OBJECT (dialog1, alignment2, "alignment2"); GLADE_HOOKUP_OBJECT (dialog1, hbox3, "hbox3"); GLADE_HOOKUP_OBJECT (dialog1, image3, "image3"); GLADE_HOOKUP_OBJECT (dialog1, label3, "label3"); gtk_widget_grab_focus (button1); gtk_widget_grab_default (button1); return dialog1; }
/* Public GnomeTwoPasswordDialog methods */ GtkWidget * gnome_two_password_dialog_new (const char *dialog_title, const char *message, const char *username, const char *password, gboolean readonly_username) { GnomeTwoPasswordDialog *password_dialog; GtkDialog *dialog; GtkWidget *table; GtkLabel *message_label; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *main_vbox; GtkWidget *dialog_icon; GSList *group; password_dialog = GNOME_TWO_PASSWORD_DIALOG (gtk_widget_new (gnome_two_password_dialog_get_type (), NULL)); dialog = GTK_DIALOG (password_dialog); gtk_window_set_title (GTK_WINDOW (password_dialog), dialog_title); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_dialog_add_buttons (dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (password_dialog), GTK_RESPONSE_OK); /* Setup the dialog */ gtk_dialog_set_has_separator (dialog, FALSE); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_box_set_spacing (GTK_BOX (dialog->vbox), 2); /* 2 * 5 + 2 = 12 */ gtk_container_set_border_width (GTK_CONTAINER (dialog->action_area), 5); gtk_box_set_spacing (GTK_BOX (dialog->action_area), 6); gtk_window_set_position (GTK_WINDOW (password_dialog), GTK_WIN_POS_CENTER); gtk_window_set_modal (GTK_WINDOW (password_dialog), TRUE); g_signal_connect (password_dialog, "show", G_CALLBACK (dialog_show_callback), password_dialog); g_signal_connect (password_dialog, "close", G_CALLBACK (dialog_close_callback), password_dialog); /* the radio buttons for anonymous login */ password_dialog->details->connect_with_no_userpass_button = gtk_radio_button_new_with_mnemonic (NULL, _("Connect _anonymously")); group = gtk_radio_button_get_group ( GTK_RADIO_BUTTON (password_dialog->details->connect_with_no_userpass_button)); password_dialog->details->connect_with_userpass_button = gtk_radio_button_new_with_mnemonic ( group, _("Connect as _user:"******"clicked", G_CALLBACK (userpass_radio_button_clicked), password_dialog); g_signal_connect (password_dialog->details->connect_with_userpass_button, "clicked", G_CALLBACK (userpass_radio_button_clicked), password_dialog); /* The table that holds the captions */ password_dialog->details->table_alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); password_dialog->details->table = table = gtk_table_new (3, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 12); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (password_dialog->details->table_alignment), table); password_dialog->details->username_entry = gtk_entry_new (); password_dialog->details->domain_entry = gtk_entry_new (); password_dialog->details->password_entry = gtk_entry_new (); password_dialog->details->password_entry_secondary = gtk_entry_new (); /* We want to hold on to these during the table rearrangement */ #if GLIB_CHECK_VERSION (2, 10, 0) g_object_ref_sink (password_dialog->details->username_entry); g_object_ref_sink (password_dialog->details->domain_entry); g_object_ref_sink (password_dialog->details->password_entry); g_object_ref_sink (password_dialog->details->password_entry_secondary); #else g_object_ref (password_dialog->details->username_entry); gtk_object_sink (GTK_OBJECT (password_dialog->details->username_entry)); g_object_ref (password_dialog->details->domain_entry); gtk_object_sink (GTK_OBJECT (password_dialog->details->domain_entry)); g_object_ref (password_dialog->details->password_entry); gtk_object_sink (GTK_OBJECT (password_dialog->details->password_entry)); g_object_ref (password_dialog->details->password_entry_secondary); gtk_object_sink (GTK_OBJECT (password_dialog->details->password_entry_secondary)); #endif gtk_entry_set_visibility (GTK_ENTRY (password_dialog->details->password_entry), FALSE); gtk_entry_set_visibility (GTK_ENTRY (password_dialog->details->password_entry_secondary), FALSE); g_signal_connect (password_dialog->details->username_entry, "activate", G_CALLBACK (username_entry_activate), password_dialog); g_signal_connect (password_dialog->details->domain_entry, "activate", G_CALLBACK (domain_entry_activate), password_dialog); g_signal_connect_swapped (password_dialog->details->password_entry, "activate", G_CALLBACK (gtk_window_activate_default), password_dialog); g_signal_connect_swapped (password_dialog->details->password_entry_secondary, "activate", G_CALLBACK (gtk_window_activate_default), password_dialog); add_table_rows (password_dialog); /* Adds some eye-candy to the dialog */ hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); dialog_icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (dialog_icon), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), dialog_icon, FALSE, FALSE, 0); /* Fills the vbox */ main_vbox = gtk_vbox_new (FALSE, 18); if (message) { message_label = GTK_LABEL (gtk_label_new (message)); gtk_label_set_justify (message_label, GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap (message_label, TRUE); gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (message_label), FALSE, FALSE, 0); } vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), password_dialog->details->radio_vbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), password_dialog->details->table_alignment, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), main_vbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (password_dialog)->vbox), hbox, TRUE, /* expand */ TRUE, /* fill */ 0); /* padding */ gtk_widget_show_all (GTK_DIALOG (password_dialog)->vbox); password_dialog->details->remember_session_button = gtk_check_button_new_with_mnemonic (_("_Remember passwords for this session")); password_dialog->details->remember_forever_button = gtk_check_button_new_with_mnemonic (_("_Save passwords in keyring")); gtk_box_pack_start (GTK_BOX (vbox), password_dialog->details->remember_session_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), password_dialog->details->remember_forever_button, FALSE, FALSE, 0); gnome_two_password_dialog_set_username (password_dialog, username); gnome_two_password_dialog_set_password (password_dialog, password); gnome_two_password_dialog_set_readonly_domain (password_dialog, readonly_username); return GTK_WIDGET (password_dialog); }
static GtkWidget *my_gtk_about_new( const gchar *name, const gchar *version, const gchar *copyright, const gchar *comments, const gchar **authors, const gchar **documenters, const gchar *translator_credits, GdkPixbuf *logo_pixbuf) { GtkWidget *dialog; GtkWidget *vbox; GtkWidget *button; GtkWidget *logo_image; GtkWidget *name_label; GtkWidget *comments_label; GtkWidget *copyright_label; gchar *title; gchar *str; static Credits *credits = NULL; if (credits == NULL) { credits = g_malloc(sizeof(Credits)); credits->dialog = NULL; credits->authors = g_strdupv((gchar **)authors); credits->documenters = g_strdupv((gchar **)documenters); credits->translator_credits = g_strdup(translator_credits); } dialog = gtk_dialog_new(); # if GTK_CHECK_VERSION(2, 4, 0) gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_container_set_border_width(GTK_CONTAINER(dialog), 5); gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(dialog)->vbox), 5); # endif gtk_dialog_add_button(GTK_DIALOG(dialog), # if GTK_CHECK_VERSION(2, 4, 0) GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); # else GTK_STOCK_OK, GTK_RESPONSE_CLOSE); # endif gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), dialog); # if GTK_CHECK_VERSION(2, 4, 0) button = gtk_button_new_with_mnemonic(_("C_redits")); # else button = gtk_button_new_with_mnemonic(_("_Credits")); # endif gtk_box_pack_end(GTK_BOX(GTK_DIALOG(dialog)->action_area), button, FALSE, TRUE, 0); gtk_button_box_set_child_secondary( GTK_BUTTON_BOX(GTK_DIALOG(dialog)->action_area), button, TRUE); g_signal_connect(button, "clicked", G_CALLBACK(display_credits_dialog), credits); gtk_widget_show(button); title = g_strdup_printf(_("About %s"), name); gtk_window_set_title(GTK_WINDOW(dialog), title); g_free(title); vbox = gtk_vbox_new(FALSE, 8); # if GTK_CHECK_VERSION(2, 4, 0) gtk_container_set_border_width(GTK_CONTAINER(vbox), 5); # else gtk_container_set_border_width(GTK_CONTAINER(vbox), 8); # endif gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox, TRUE, TRUE, 0); logo_image = gtk_image_new(); gtk_image_set_from_pixbuf(GTK_IMAGE(logo_image), logo_pixbuf); gtk_box_pack_start(GTK_BOX(vbox), logo_image, FALSE, FALSE, 0); name_label = gtk_label_new(NULL); gtk_label_set_selectable(GTK_LABEL(name_label), TRUE); gtk_label_set_justify(GTK_LABEL(name_label), GTK_JUSTIFY_CENTER); gtk_box_pack_start(GTK_BOX(vbox), name_label, FALSE, FALSE, 0); comments_label = gtk_label_new(NULL); gtk_label_set_selectable(GTK_LABEL(comments_label), TRUE); gtk_label_set_justify(GTK_LABEL(comments_label), GTK_JUSTIFY_CENTER); gtk_label_set_line_wrap(GTK_LABEL(comments_label), TRUE); gtk_box_pack_start(GTK_BOX(vbox), comments_label, FALSE, FALSE, 0); copyright_label = gtk_label_new(NULL); gtk_label_set_selectable(GTK_LABEL(copyright_label), TRUE); gtk_label_set_justify(GTK_LABEL(comments_label), GTK_JUSTIFY_CENTER); gtk_box_pack_start(GTK_BOX(vbox), copyright_label, FALSE, FALSE, 0); str = g_strdup_printf( "<span size=\"xx-large\" weight=\"bold\">%s %s</span>", name, version); gtk_label_set_markup(GTK_LABEL(name_label), str); g_free(str); gtk_label_set_markup(GTK_LABEL(comments_label), comments); str = g_strdup_printf("<span size=\"small\">%s</span>", copyright); gtk_label_set_markup(GTK_LABEL(copyright_label), str); g_free(str); gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE); gtk_widget_show_all(vbox); return dialog; }
static gboolean confirm_delete_immediately (GtkWidget *parent_view, gint num_files, gboolean all) { GdkScreen *screen; GtkWidget *dialog, *hbox, *vbox, *image, *label; gchar *str, *prompt, *detail; int response; screen = gtk_widget_get_screen (parent_view); dialog = gtk_dialog_new (); gtk_window_set_screen (GTK_WINDOW (dialog), screen); atk_object_set_role (gtk_widget_get_accessible (dialog), ATK_ROLE_ALERT); gtk_window_set_title (GTK_WINDOW (dialog), _("Delete Immediately?")); gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_widget_realize (dialog); gdk_window_set_transient_for (gtk_widget_get_window (GTK_WIDGET (dialog)), gdk_screen_get_root_window (screen)); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), 14); hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_widget_show (hbox); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox, FALSE, FALSE, 0); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); gtk_widget_show (image); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); vbox = gtk_vbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); if (all) { prompt = _("Cannot move items to trash, do you want to delete them immediately?"); detail = g_strdup_printf ("None of the %d selected items can be moved to the Trash", num_files); } else { prompt = _("Cannot move some items to trash, do you want to delete these immediately?"); detail = g_strdup_printf ("%d of the selected items cannot be moved to the Trash", num_files); } str = g_strconcat ("<span weight=\"bold\" size=\"larger\">", prompt, "</span>", NULL); label = gtk_label_new (str); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (str); label = gtk_label_new (detail); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (detail); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_DELETE, GTK_RESPONSE_YES); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES); response = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_object_destroy (GTK_OBJECT (dialog)); return response == GTK_RESPONSE_YES; }
void gtkui_dhcp_spoofing(void) { GtkWidget *dialog, *table, *hbox, *image, *label, *entry1, *entry2, *entry3, *frame; gint response = 0; DEBUG_MSG("gtk_dhcp_spoofing"); dialog = gtk_dialog_new_with_buttons("MITM Attack: DHCP Spoofing", 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 = gtk_hbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); 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), image, FALSE, FALSE, 5); gtk_widget_show(image); frame = gtk_frame_new("Server Information"); gtk_container_set_border_width(GTK_CONTAINER (frame), 5); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show(frame); table = gtk_table_new(3, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE (table), 5); gtk_table_set_col_spacings(GTK_TABLE (table), 5); gtk_container_set_border_width(GTK_CONTAINER (table), 8); gtk_container_add(GTK_CONTAINER (frame), table); gtk_widget_show(table); label = gtk_label_new("IP Pool (optional)"); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach(GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show(label); entry1 = gtk_entry_new(); gtk_table_attach_defaults(GTK_TABLE (table), entry1, 1, 2, 0, 1); gtk_widget_show(entry1); label = gtk_label_new("Netmask"); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach(GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show(label); entry2 = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY (entry2), IP6_ASCII_ADDR_LEN); gtk_table_attach_defaults(GTK_TABLE (table), entry2, 1, 2, 1, 2); gtk_widget_show(entry2); label = gtk_label_new("DNS Server IP"); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach(GTK_TABLE (table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show(label); entry3 = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY (entry3), IP6_ASCII_ADDR_LEN); gtk_table_attach_defaults(GTK_TABLE (table), entry3, 1, 2, 2, 3); gtk_widget_show(entry3); response = gtk_dialog_run(GTK_DIALOG(dialog)); if(response == GTK_RESPONSE_OK) { gtk_widget_hide(dialog); sprintf(params, "dhcp:"); strncat(params, gtk_entry_get_text(GTK_ENTRY(entry1)), PARAMS_LEN); strncat(params, "/", PARAMS_LEN); strncat(params, gtk_entry_get_text(GTK_ENTRY(entry2)), PARAMS_LEN); strncat(params, "/", PARAMS_LEN); strncat(params, gtk_entry_get_text(GTK_ENTRY(entry3)), PARAMS_LEN); gtkui_start_mitm(); } gtk_widget_destroy(dialog); /* a simpler method: gtkui_input_call("Parameters :", params + strlen("dhcp:"), PARAMS_LEN - strlen("dhcp:"), gtkui_start_mitm); */ }
static PidginLogViewer *display_log_viewer(struct log_viewer_hash_t *ht, GList *logs, const char *title, GtkWidget *icon, int log_size) { PidginLogViewer *lv; GtkWidget *title_box; char *text; GtkWidget *pane; GtkWidget *sw; GtkCellRenderer *rend; GtkTreeViewColumn *col; GtkTreeSelection *sel; GtkWidget *vbox; GtkWidget *frame; GtkWidget *hbox; GtkWidget *find_button; GtkWidget *size_label; if (logs == NULL) { /* No logs were found. */ const char *log_preferences = NULL; if (ht == NULL) { if (!purple_prefs_get_bool("/purple/logging/log_system")) log_preferences = _("System events will only be logged if the \"Log all status changes to system log\" preference is enabled."); } else { if (ht->type == PURPLE_LOG_IM) { if (!purple_prefs_get_bool("/purple/logging/log_ims")) log_preferences = _("Instant messages will only be logged if the \"Log all instant messages\" preference is enabled."); } else if (ht->type == PURPLE_LOG_CHAT) { if (!purple_prefs_get_bool("/purple/logging/log_chats")) log_preferences = _("Chats will only be logged if the \"Log all chats\" preference is enabled."); } g_free(ht->buddyname); g_free(ht); } if(icon != NULL) gtk_widget_destroy(icon); purple_notify_info(NULL, title, _("No logs were found"), log_preferences); return NULL; } lv = g_new0(PidginLogViewer, 1); lv->logs = logs; if (ht != NULL) g_hash_table_insert(log_viewers, ht, lv); /* Window ***********/ lv->window = gtk_dialog_new_with_buttons(title, NULL, 0, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); #ifdef _WIN32 /* Steal the "HELP" response and use it to trigger browsing to the logs folder */ gtk_dialog_add_button(GTK_DIALOG(lv->window), _("_Browse logs folder"), GTK_RESPONSE_HELP); #endif gtk_container_set_border_width (GTK_CONTAINER(lv->window), PIDGIN_HIG_BOX_SPACE); gtk_dialog_set_has_separator(GTK_DIALOG(lv->window), FALSE); gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(lv->window)->vbox), 0); g_signal_connect(G_OBJECT(lv->window), "response", G_CALLBACK(destroy_cb), ht); gtk_window_set_role(GTK_WINDOW(lv->window), "log_viewer"); /* Icon *************/ if (icon != NULL) { title_box = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_container_set_border_width(GTK_CONTAINER(title_box), PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(lv->window)->vbox), title_box, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(title_box), icon, FALSE, FALSE, 0); } else title_box = GTK_DIALOG(lv->window)->vbox; /* Label ************/ lv->label = gtk_label_new(NULL); text = g_strdup_printf("<span size='larger' weight='bold'>%s</span>", title); gtk_label_set_markup(GTK_LABEL(lv->label), text); gtk_misc_set_alignment(GTK_MISC(lv->label), 0, 0); gtk_box_pack_start(GTK_BOX(title_box), lv->label, FALSE, FALSE, 0); g_free(text); /* Pane *************/ pane = gtk_hpaned_new(); gtk_container_set_border_width(GTK_CONTAINER(pane), PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(lv->window)->vbox), pane, TRUE, TRUE, 0); /* List *************/ sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_paned_add1(GTK_PANED(pane), sw); lv->treestore = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); lv->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (lv->treestore)); g_object_unref(G_OBJECT(lv->treestore)); rend = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes ("time", rend, "markup", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(lv->treeview), col); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (lv->treeview), FALSE); gtk_container_add (GTK_CONTAINER (sw), lv->treeview); populate_log_tree(lv); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (lv->treeview)); g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (log_select_cb), lv); g_signal_connect (G_OBJECT(lv->treeview), "row-activated", G_CALLBACK(log_row_activated_cb), lv); pidgin_set_accessible_label(lv->treeview, lv->label); g_signal_connect(lv->treeview, "button-press-event", G_CALLBACK(log_button_press_cb), lv); g_signal_connect(lv->treeview, "popup-menu", G_CALLBACK(log_popup_menu_cb), lv); /* Log size ************/ if(log_size) { char *sz_txt = purple_str_size_to_units(log_size); text = g_strdup_printf("<span weight='bold'>%s</span> %s", _("Total log size:"), sz_txt); size_label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(size_label), text); /* gtk_paned_add1(GTK_PANED(pane), size_label); */ gtk_misc_set_alignment(GTK_MISC(size_label), 0, 0); gtk_box_pack_end(GTK_BOX(GTK_DIALOG(lv->window)->vbox), size_label, FALSE, FALSE, 0); g_free(sz_txt); g_free(text); } /* A fancy little box ************/ vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_paned_add2(GTK_PANED(pane), vbox); /* Viewer ************/ frame = pidgin_create_imhtml(FALSE, &lv->imhtml, NULL, NULL); gtk_widget_set_name(lv->imhtml, "pidgin_log_imhtml"); gtk_widget_set_size_request(lv->imhtml, 320, 200); gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0); gtk_widget_show(frame); /* Search box **********/ hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); lv->entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(hbox), lv->entry, TRUE, TRUE, 0); find_button = gtk_button_new_from_stock(GTK_STOCK_FIND); gtk_box_pack_start(GTK_BOX(hbox), find_button, FALSE, FALSE, 0); g_signal_connect(GTK_ENTRY(lv->entry), "activate", G_CALLBACK(search_cb), lv); g_signal_connect(GTK_BUTTON(find_button), "clicked", G_CALLBACK(search_cb), lv); select_first_log(lv); gtk_widget_show_all(lv->window); return lv; }