void gui_init(dt_lib_module_t *self) { GtkBox *hbox; GtkWidget *button; GtkWidget *label; GtkEntryCompletion *completion; dt_lib_metadata_t *d = (dt_lib_metadata_t *)calloc(1, sizeof(dt_lib_metadata_t)); self->data = (void *)d; d->imgsel = -1; self->widget = gtk_table_new(6, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE(self->widget), 5); g_signal_connect(self->widget, "expose-event", G_CALLBACK(expose), self); label = gtk_label_new(_("title")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 0, 1, GTK_EXPAND|GTK_FILL, 0, 0, 0); d->title = GTK_COMBO_BOX(gtk_combo_box_text_new_with_entry()); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->title)))); completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(d->title))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(d->title))), completion); g_signal_connect (GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->title))), "key-press-event", G_CALLBACK (key_pressed), self); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->title), 1, 2, 0, 1, GTK_EXPAND|GTK_FILL, 0, 0, 0); label = gtk_label_new(_("description")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 1, 2, GTK_EXPAND|GTK_FILL, 0, 0, 0); d->description = GTK_COMBO_BOX(gtk_combo_box_text_new_with_entry()); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->description)))); completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(d->description))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(d->description))), completion); g_signal_connect (GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->description))), "key-press-event", G_CALLBACK (key_pressed), self); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->description), 1, 2, 1, 2, GTK_EXPAND|GTK_FILL, 0, 0, 0); label = gtk_label_new(_("creator")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 2, 3, GTK_EXPAND|GTK_FILL, 0, 0, 0); d->creator = GTK_COMBO_BOX(gtk_combo_box_text_new_with_entry()); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->creator)))); completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(d->creator))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(d->creator))), completion); g_signal_connect (GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->creator))), "key-press-event", G_CALLBACK (key_pressed), self); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->creator), 1, 2, 2, 3, GTK_EXPAND|GTK_FILL, 0, 0, 0); label = gtk_label_new(_("publisher")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 3, 4, GTK_EXPAND|GTK_FILL, 0, 0, 0); d->publisher = GTK_COMBO_BOX(gtk_combo_box_text_new_with_entry()); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->publisher)))); completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(d->publisher))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(d->publisher))), completion); g_signal_connect (GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->publisher))), "key-press-event", G_CALLBACK (key_pressed), self); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->publisher), 1, 2, 3, 4, GTK_EXPAND|GTK_FILL, 0, 0, 0); label = gtk_label_new(_("rights")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 4, 5, GTK_EXPAND|GTK_FILL, 0, 0, 0); d->rights = GTK_COMBO_BOX(gtk_combo_box_text_new_with_entry()); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->rights)))); completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(d->rights))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(d->rights))), completion); g_signal_connect (GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->rights))), "key-press-event", G_CALLBACK (key_pressed), self); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->rights), 1, 2, 4, 5, GTK_EXPAND|GTK_FILL, 0, 0, 0); g_object_unref(completion); // reset/apply buttons hbox = GTK_BOX(gtk_hbox_new(TRUE, 5)); button = gtk_button_new_with_label(_("clear")); d->clear_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("remove metadata from selected images"), (char *)NULL); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK (clear_button_clicked), (gpointer)self); button = gtk_button_new_with_label(_("apply")); d->apply_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("write metadata for selected images"), (char *)NULL); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK (apply_button_clicked), (gpointer)self); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(hbox), 0, 2, 5, 6, GTK_EXPAND|GTK_FILL, 0, 0, 0); /* lets signup for mouse over image change signals */ dt_control_signal_connect(darktable.signals,DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE, G_CALLBACK(_mouse_over_image_callback), self); }
static GtkWidget * gimp_proc_view_create_params (GimpParamDef *params, gint n_params, GtkSizeGroup *name_group, GtkSizeGroup *type_group, GtkSizeGroup *desc_group) { GtkWidget *table; gint i; table = gtk_table_new (n_params, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 4); for (i = 0; i < n_params; i++) { GtkWidget *label; const gchar *type; gchar *upper; /* name */ label = gtk_label_new (params[i].name); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_size_group_add_widget (name_group, label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, i, i + 1, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (label); /* type */ if (! gimp_enum_get_value (GIMP_TYPE_PDB_ARG_TYPE, params[i].type, NULL, &type, NULL, NULL)) upper = g_strdup ("UNKNOWN"); else upper = g_ascii_strup (type, -1); label = gtk_label_new (upper); g_free (upper); gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_FAMILY, "monospace", PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, -1); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_size_group_add_widget (type_group, label); gtk_table_attach (GTK_TABLE (table), label, 1, 2, i, i + 1, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (label); /* description */ label = gtk_label_new (params[i].description); gtk_label_set_selectable (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_size_group_add_widget (desc_group, label); gtk_table_attach (GTK_TABLE (table), label, 2, 3, i, i + 1, GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (label); } return table; }
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; }
gint gprj_project_add_properties_tab(GtkWidget *notebook) { GtkWidget *vbox, *hbox, *hbox1; GtkWidget *table; GtkWidget *label; gchar *str; gint page_index; e = g_new0(PropertyDialogElements, 1); vbox = gtk_vbox_new(FALSE, 0); table = gtk_table_new(3, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 5); gtk_table_set_col_spacings(GTK_TABLE(table), 10); label = gtk_label_new(_("Source patterns:")); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); e->source_patterns = gtk_entry_new(); ui_table_add_row(GTK_TABLE(table), 0, label, e->source_patterns, NULL); ui_entry_add_clear_icon(GTK_ENTRY(e->source_patterns)); ui_widget_set_tooltip_text(e->source_patterns, _("Space separated list of patterns that are used to identify source files.")); str = g_strjoinv(" ", g_prj->source_patterns); gtk_entry_set_text(GTK_ENTRY(e->source_patterns), str); g_free(str); label = gtk_label_new(_("Header patterns:")); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); e->header_patterns = gtk_entry_new(); ui_entry_add_clear_icon(GTK_ENTRY(e->header_patterns)); ui_table_add_row(GTK_TABLE(table), 1, label, e->header_patterns, NULL); ui_widget_set_tooltip_text(e->header_patterns, _("Space separated list of patterns that are used to identify headers. " "Used mainly for header/source swapping.")); str = g_strjoinv(" ", g_prj->header_patterns); gtk_entry_set_text(GTK_ENTRY(e->header_patterns), str); g_free(str); label = gtk_label_new(_("Ignored dirs patterns:")); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); e->ignored_dirs_patterns = gtk_entry_new(); ui_entry_add_clear_icon(GTK_ENTRY(e->ignored_dirs_patterns)); ui_table_add_row(GTK_TABLE(table), 2, label, e->ignored_dirs_patterns, NULL); ui_widget_set_tooltip_text(e->ignored_dirs_patterns, _("Space separated list of patterns that are used to identify directories " "that are not scanned for source files.")); str = g_strjoinv(" ", g_prj->ignored_dirs_patterns); gtk_entry_set_text(GTK_ENTRY(e->ignored_dirs_patterns), str); g_free(str); gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 6); e->generate_tags = gtk_check_button_new_with_label(_("Generate tags for all project files")); ui_widget_set_tooltip_text(e->generate_tags, _("Generate tag list for all project files instead of only for the currently opened files. " "Too slow for big projects (>1000 files) and should be disabled in this case.")); gtk_box_pack_start(GTK_BOX(vbox), e->generate_tags, FALSE, FALSE, 6); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(e->generate_tags), g_prj->generate_tags); hbox1 = gtk_hbox_new(FALSE, 0); label = gtk_label_new(_("Note: set the patterns of files belonging to the project under the Project tab.")); gtk_box_pack_start(GTK_BOX(hbox1), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox1, FALSE, FALSE, 6); label = gtk_label_new(_("GProject")); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 6); page_index = gtk_notebook_append_page(GTK_NOTEBOOK(notebook), hbox, label); gtk_widget_show_all(notebook); return page_index; }
/** * @param ddisp The diagram display object that a window is created for * @param title */ static void use_integrated_ui_for_display_shell(DDisplay *ddisp, char *title) { GtkWidget *table; GtkWidget *label; /* Text label for the notebook page */ GtkWidget *tab_label_container; /* Container to hold text label & close button */ int width, height; /* Width/Heigth of the diagram */ GtkWidget *image; GtkWidget *close_button; /* Close button for the notebook page */ GtkRcStyle *rcstyle; gint notebook_page_index; ddisp->is_standalone_window = FALSE; ddisp->shell = GTK_WIDGET (ui.main_window); ddisp->modified_status = GTK_WIDGET (ui.statusbar); tab_label_container = gtk_hbox_new(FALSE,3); label = gtk_label_new( title ); gtk_box_pack_start( GTK_BOX(tab_label_container), label, FALSE, FALSE, 0 ); gtk_widget_show (label); /* Create a new tab page */ ddisp->container = gtk_vbox_new(FALSE, 0); /* <from GEdit> */ /* don't allow focus on the close button */ close_button = gtk_button_new(); gtk_button_set_relief (GTK_BUTTON (close_button), GTK_RELIEF_NONE); gtk_button_set_focus_on_click (GTK_BUTTON (close_button), FALSE); /* make it as small as possible */ rcstyle = gtk_rc_style_new (); rcstyle->xthickness = rcstyle->ythickness = 0; gtk_widget_modify_style (close_button, rcstyle); g_object_unref (rcstyle), image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU); gtk_container_add (GTK_CONTAINER(close_button), image); g_signal_connect (G_OBJECT (close_button), "clicked", G_CALLBACK (close_notebook_page_callback), ddisp->container); /* </from GEdit> */ gtk_box_pack_start( GTK_BOX(tab_label_container), close_button, FALSE, FALSE, 0 ); gtk_widget_show (close_button); gtk_widget_show (image); /* Set events for new tab page */ _ddisplay_setup_events (ddisp, ddisp->container); notebook_page_index = gtk_notebook_append_page (GTK_NOTEBOOK(ui.diagram_notebook), ddisp->container, tab_label_container); g_object_set_data (G_OBJECT (ddisp->container), "DDisplay", ddisp); g_object_set_data (G_OBJECT (ddisp->container), "tab-label", label); g_object_set_data (G_OBJECT (ddisp->container), "window", ui.main_window); /* the table containing all widgets */ table = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table), 0, 1); gtk_table_set_col_spacing (GTK_TABLE (table), 1, 2); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 1); gtk_table_set_row_spacing (GTK_TABLE (table), 1, 2); gtk_container_set_border_width (GTK_CONTAINER (table), 2); gtk_box_pack_start( GTK_BOX(ddisp->container), table, TRUE, TRUE, 0 ); /* scrollbars, rulers, canvas, menu popup button */ ddisp->origin = NULL; _ddisplay_setup_rulers (ddisp, ddisp->container, table); /* Get the width/height of the Notebook child area */ /* TODO: Fix width/height hardcoded values */ width = 100; height = 100; _ddisplay_setup_scrollbars (ddisp, table, width, height); _ddisplay_setup_navigation (ddisp, table, TRUE); ddisp->canvas = create_canvas (ddisp); /* place all remaining widgets (no 'origin' anymore, since navigation is top-left */ gtk_table_attach (GTK_TABLE (table), ddisp->canvas, 1, 2, 1, 2, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); ddisp->common_toolbar = ui.toolbar; /* Stand-alone window menubar */ ddisp->menu_bar = NULL; /* Stand-alone window Zoom status/menu */ ddisp->zoom_status = NULL; /* Stand-alone window Grid on/off button */ ddisp->grid_status = NULL; /* Stand-alone window Object Snapping button */ ddisp->mainpoint_status = NULL; gtk_widget_show (ddisp->container); gtk_widget_show (table); display_rulers_show (ddisp); gtk_widget_show (ddisp->canvas); /* Show new page */ gtk_notebook_set_current_page (ui.diagram_notebook, notebook_page_index); integrated_ui_toolbar_grid_snap_synchronize_to_display (ddisp); integrated_ui_toolbar_object_snap_synchronize_to_display (ddisp); /* set the focus to the canvas area */ gtk_widget_grab_focus (ddisp->canvas); }
GtkWidget* ghack_init_status_window () { GtkWidget *horizSep0, *horizSep1, *horizSep2, *horizSep3; GtkWidget *statsHBox, *strVBox, *dexVBox, *intVBox, *statHBox; GtkWidget *wisVBox, *conVBox, *chaVBox; GtkWidget *alignVBox, *hungerVBox, *sickVBox, *blindVBox; GtkWidget *stunVBox, *halluVBox, *confuVBox, *encumbVBox; /* Set up a (ridiculous) initial state */ lastDepth = 9999; lastStr = 9999; lastInt = 9999; lastWis = 9999; lastDex = 9999; lastCon = 9999; lastCha = 9999; lastAu = 9999; lastHP = 9999; lastMHP = 9999; lastLevel = 9999; lastPOW = 9999; lastMPOW = 9999; lastAC = 9999; lastExp = 9999; lastAlignment = A_NEUTRAL; /* start off guessing neutral */ lastHungr = 9999; lastConf = 9999; lastBlind = 9999; lastStun = 9999; lastHalu = 9999; lastSick = 9999; lastEncumb = 9999; statTable = gtk_table_new( 10, 8, FALSE); gtk_table_set_row_spacings( GTK_TABLE( statTable), 1); gtk_table_set_col_spacings( GTK_TABLE( statTable), 1); /* Begin the first row of the table -- the title */ titleLabel = gtk_label_new( _("GnomeHack!")); gtk_table_attach( GTK_TABLE( statTable), titleLabel, 0, 8, 0, 1, GTK_FILL, 0, 0, 0); if (!normalStyle) normalStyle = gtk_style_copy ( gtk_widget_get_style (GTK_WIDGET (titleLabel))); /* Set up some styles to draw stuff with */ if (!redStyle) { g_assert (greenStyle == NULL); g_assert (bigStyle == NULL); g_assert (bigRedStyle == NULL); g_assert (bigGreenStyle == NULL); greenStyle = gtk_style_copy (normalStyle); redStyle = gtk_style_copy (normalStyle); bigRedStyle = gtk_style_copy (normalStyle); bigGreenStyle = gtk_style_copy (normalStyle); bigStyle = gtk_style_copy (normalStyle); greenStyle->fg[GTK_STATE_NORMAL] = color_green; redStyle->fg[GTK_STATE_NORMAL] = color_red; bigRedStyle->fg[GTK_STATE_NORMAL] = color_red; bigGreenStyle->fg[GTK_STATE_NORMAL] = color_green; gdk_font_unref (bigRedStyle->font); gdk_font_unref (bigGreenStyle->font); bigRedStyle->font = gdk_font_load("-misc-fixed-*-*-*-*-20-*-*-*-*-*-*-*"); bigGreenStyle->font = gdk_font_load("-misc-fixed-*-*-*-*-20-*-*-*-*-*-*-*"); gdk_font_unref (bigStyle->font); bigStyle->font = gdk_font_load ("-misc-fixed-*-*-*-*-20-*-*-*-*-*-*-*"); } gtk_widget_set_style (GTK_WIDGET (titleLabel), bigStyle); /* Begin the second row */ dgnLevelLabel = gtk_label_new (_ ("Nethack for Gnome")); gtk_table_attach (GTK_TABLE (statTable), dgnLevelLabel, 0, 8, 1, 2, GTK_FILL, 0, 0, 0); gtk_widget_set_style (GTK_WIDGET (dgnLevelLabel), bigStyle); /* Begin the third row */ horizSep0 = gtk_hseparator_new (); gtk_table_attach (GTK_TABLE (statTable), horizSep0, 0, 8, 2, 3, GTK_FILL, GTK_FILL, 0, 0); /* Begin the fourth row */ statsHBox = gtk_hbox_new (TRUE, 0); strVBox = gtk_vbox_new (FALSE, 0); strPix = gnome_pixmap_new_from_xpm_d( str_xpm); strLabel = gtk_label_new( "STR: "); gtk_box_pack_start (GTK_BOX (strVBox), strPix, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (strVBox), strLabel, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX(statsHBox), GTK_WIDGET(strVBox), TRUE, TRUE, 2); dexVBox = gtk_vbox_new (FALSE, 0); dexPix = gnome_pixmap_new_from_xpm_d( dex_xpm); dexLabel = gtk_label_new( "DEX: "); gtk_box_pack_start (GTK_BOX (dexVBox), dexPix, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (dexVBox), dexLabel, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX(statsHBox), GTK_WIDGET(dexVBox), TRUE, TRUE, 2); conVBox = gtk_vbox_new (FALSE, 0); conPix = gnome_pixmap_new_from_xpm_d( cns_xpm); conLabel = gtk_label_new( "CON: "); gtk_box_pack_start (GTK_BOX (conVBox), conPix, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (conVBox), conLabel, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX(statsHBox), GTK_WIDGET(conVBox), TRUE, TRUE, 2); intVBox = gtk_vbox_new (FALSE, 0); intPix = gnome_pixmap_new_from_xpm_d( int_xpm); intLabel = gtk_label_new( "INT: "); gtk_box_pack_start (GTK_BOX (intVBox), intPix, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (intVBox), intLabel, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX(statsHBox), GTK_WIDGET(intVBox), TRUE, TRUE, 2); wisVBox = gtk_vbox_new (FALSE, 0); wisPix = gnome_pixmap_new_from_xpm_d( wis_xpm); wisLabel = gtk_label_new( "WIS: "); gtk_box_pack_start (GTK_BOX (wisVBox), wisPix, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (wisVBox), wisLabel, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX(statsHBox), GTK_WIDGET(wisVBox), TRUE, TRUE, 2); chaVBox = gtk_vbox_new (FALSE, 0); chaPix = gnome_pixmap_new_from_xpm_d( cha_xpm); chaLabel = gtk_label_new( "CHA: "); gtk_box_pack_start (GTK_BOX (chaVBox), chaPix, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (chaVBox), chaLabel, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX(statsHBox), GTK_WIDGET(chaVBox), TRUE, TRUE, 2); gtk_table_attach( GTK_TABLE( statTable), GTK_WIDGET(statsHBox), 0, 8, 3, 4, GTK_FILL, 0, 0, 0); /* Begin the fifth row */ horizSep1 = gtk_hseparator_new(); gtk_table_attach( GTK_TABLE( statTable), horizSep1, 0, 8, 4, 5, GTK_FILL, GTK_FILL, 0, 0); /* Begin the sixth row */ hpLabel = gtk_label_new( "HP: "); gtk_table_attach( GTK_TABLE( statTable), hpLabel, 0, 1, 5, 6, GTK_FILL, 0, 0, 0); acLabel = gtk_label_new( "AC: "); gtk_table_attach( GTK_TABLE( statTable), acLabel, 2, 3, 5, 6, GTK_FILL, 0, 0, 0); powLabel = gtk_label_new( "Power: "); gtk_table_attach( GTK_TABLE( statTable), powLabel, 4, 5, 5, 6, GTK_FILL, 0, 0, 0); goldLabel = gtk_label_new( "Au: "); gtk_table_attach( GTK_TABLE( statTable), goldLabel, 6, 7, 5, 6, GTK_FILL, 0, 0, 0); /* Begin the seventh row */ horizSep2 = gtk_hseparator_new(); gtk_table_attach( GTK_TABLE( statTable), horizSep2, 0, 8, 6, 7, GTK_FILL, GTK_FILL, 0, 0); /* Begin the eigth row */ levlLabel = gtk_label_new( "Level: "); gtk_table_attach( GTK_TABLE( statTable), levlLabel, 0, 1, 7, 8, GTK_FILL, 0, 0, 0); expLabel = gtk_label_new( "Exp: "); gtk_table_attach( GTK_TABLE( statTable), expLabel, 2, 3, 7, 8, GTK_FILL, 0, 0, 0); timeLabel = gtk_label_new( "Time: "); gtk_table_attach( GTK_TABLE( statTable), timeLabel, 4, 5, 7, 8, GTK_FILL, 0, 0, 0); scoreLabel = gtk_label_new( "Score: "); gtk_table_attach( GTK_TABLE( statTable), scoreLabel, 6, 7, 7, 8, GTK_FILL, 0, 0, 0); /* Begin the ninth row */ horizSep3 = gtk_hseparator_new(); gtk_table_attach( GTK_TABLE( statTable), horizSep3, 0, 8, 8, 9, GTK_FILL, GTK_FILL, 0, 0); /* Begin the tenth and last row */ statHBox = gtk_hbox_new (FALSE, 0); alignVBox = gtk_vbox_new (FALSE, 0); alignPix = gnome_pixmap_new_from_xpm_d( neutral_xpm); alignLabel = gtk_label_new( "Neutral"); gtk_box_pack_start (GTK_BOX (alignVBox), alignPix, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (alignVBox), alignLabel, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX(statHBox), GTK_WIDGET(alignVBox), TRUE, FALSE, 2); hungerVBox = gtk_vbox_new (FALSE, 0); hungerPix = gnome_pixmap_new_from_xpm_d( hungry_xpm); hungerLabel = gtk_label_new( "Hungry"); gtk_box_pack_start (GTK_BOX (hungerVBox), hungerPix, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (hungerVBox), hungerLabel, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX(statHBox), GTK_WIDGET(hungerVBox), TRUE, FALSE, 2); sickVBox = gtk_vbox_new (FALSE, 0); sickPix = gnome_pixmap_new_from_xpm_d( sick_fp_xpm); sickLabel = gtk_label_new( "FoodPois"); gtk_box_pack_start (GTK_BOX (sickVBox), sickPix, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (sickVBox), sickLabel, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX(statHBox), GTK_WIDGET(sickVBox), TRUE, FALSE, 2); blindVBox = gtk_vbox_new (FALSE, 0); blindPix = gnome_pixmap_new_from_xpm_d( blind_xpm); blindLabel = gtk_label_new( "Blind"); gtk_box_pack_start (GTK_BOX (blindVBox), blindPix, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (blindVBox), blindLabel, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX(statHBox), GTK_WIDGET(blindVBox), TRUE, FALSE, 2); stunVBox = gtk_vbox_new (FALSE, 0); stunPix = gnome_pixmap_new_from_xpm_d( stunned_xpm); stunLabel = gtk_label_new( "Stun"); gtk_box_pack_start (GTK_BOX (stunVBox), stunPix, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (stunVBox), stunLabel, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX(statHBox), GTK_WIDGET(stunVBox), TRUE, FALSE, 2); confuVBox = gtk_vbox_new (FALSE, 0); confuPix = gnome_pixmap_new_from_xpm_d( confused_xpm); confuLabel = gtk_label_new( "Confused"); gtk_box_pack_start (GTK_BOX (confuVBox), confuPix, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (confuVBox), confuLabel, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX(statHBox), GTK_WIDGET(confuVBox), TRUE, FALSE, 2); halluVBox = gtk_vbox_new (FALSE, 0); halluPix = gnome_pixmap_new_from_xpm_d( hallu_xpm); halluLabel = gtk_label_new( "Hallu"); gtk_box_pack_start (GTK_BOX (halluVBox), halluPix, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (halluVBox), halluLabel, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX(statHBox), GTK_WIDGET(halluVBox), TRUE, FALSE, 2); encumbVBox = gtk_vbox_new (FALSE, 0); encumbPix = gnome_pixmap_new_from_xpm_d( slt_enc_xpm); encumbLabel = gtk_label_new( "Burdened"); gtk_box_pack_start (GTK_BOX (encumbVBox), encumbPix, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (encumbVBox), encumbLabel, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX(statHBox), GTK_WIDGET(encumbVBox), TRUE, FALSE, 2); gtk_table_attach( GTK_TABLE( statTable), GTK_WIDGET(statHBox), 0, 8, 9, 10, GTK_FILL, GTK_FILL, 0, 0); /* Set up the necessary signals */ gtk_signal_connect (GTK_OBJECT (statTable), "ghack_fade_highlight", GTK_SIGNAL_FUNC (ghack_fade_highlighting), NULL); gtk_signal_connect (GTK_OBJECT (statTable), "ghack_putstr", GTK_SIGNAL_FUNC (ghack_status_window_put_string), NULL); gtk_signal_connect (GTK_OBJECT (statTable), "ghack_clear", GTK_SIGNAL_FUNC (ghack_status_window_clear), NULL); gtk_signal_connect (GTK_OBJECT (statTable), "ghack_curs", GTK_SIGNAL_FUNC (ghack_status_window_cursor_to), NULL); gtk_signal_connect(GTK_OBJECT (statTable), "gnome_delay_output", GTK_SIGNAL_FUNC(ghack_delay), NULL); /* Lastly, show the status window and everything in it */ gtk_widget_show_all( statTable); return GTK_WIDGET(statTable); }
int destination_address(struct navit *nav) { GtkWidget *window2, *keyboard, *vbox, *table; GtkWidget *label_country; GtkWidget *label_postal, *label_city, *label_district; GtkWidget *label_street, *label_number; GtkWidget *hseparator1,*hseparator2; GtkWidget *button1,*button2,*button3; int i; struct search_param *search=&search_param; struct attr search_attr, country_name, *country_attr; struct tracking *tracking; struct country_search *cs; struct item *item; search->nav=nav; search->ms=navit_get_mapset(nav); search->sl=search_list_new(search->ms); window2 = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window2),_("Enter Destination")); gtk_window_set_wmclass (GTK_WINDOW (window2), "navit", "Navit"); gtk_window_set_default_size (GTK_WINDOW (window2),0,300); vbox = gtk_vbox_new(FALSE, 0); table = gtk_table_new(3, 8, FALSE); search->entry_country = gtk_entry_new(); label_country = gtk_label_new(_("Country")); search->entry_postal = gtk_entry_new(); gtk_widget_set_sensitive(GTK_WIDGET(search->entry_postal), FALSE); label_postal = gtk_label_new(_("Zip Code")); search->entry_city = gtk_entry_new(); gtk_widget_set_sensitive(GTK_WIDGET(search->entry_city), FALSE); label_city = gtk_label_new(_("City")); search->entry_district = gtk_entry_new(); gtk_widget_set_sensitive(GTK_WIDGET(search->entry_district), FALSE); label_district = gtk_label_new(_("District/Township")); hseparator1 = gtk_vseparator_new(); search->entry_street = gtk_entry_new(); gtk_widget_set_sensitive(GTK_WIDGET(search->entry_street), FALSE); label_street = gtk_label_new(_("Street")); search->entry_number = gtk_entry_new(); gtk_widget_set_sensitive(GTK_WIDGET(search->entry_number), FALSE); label_number = gtk_label_new(_("Number")); search->treeview=gtk_tree_view_new(); search->listbox = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (search->listbox), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_tree_view_set_model (GTK_TREE_VIEW (search->treeview), NULL); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(search->listbox),search->treeview); { GType types[COL_COUNT+1]; for(i=0;i<COL_COUNT;i++) types[i]=G_TYPE_STRING; types[i]=G_TYPE_POINTER; search->liststore=gtk_list_store_newv(COL_COUNT+1,types); search->liststore2=gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(search->liststore)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (search->liststore2), 3, GTK_SORT_ASCENDING); gtk_tree_view_set_model (GTK_TREE_VIEW (search->treeview), GTK_TREE_MODEL(search->liststore2)); } hseparator2 = gtk_vseparator_new(); button1 = gtk_button_new_with_label(_("Map")); button2 = gtk_button_new_with_label(_("Bookmark")); button3 = gtk_button_new_with_label(_("Destination")); gtk_table_attach(GTK_TABLE(table), label_country, 0, 1, 0, 1, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), label_postal, 1, 2, 0, 1, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), label_city, 2, 3, 0, 1, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), search->entry_country, 0, 1, 1, 2, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), search->entry_postal, 1, 2, 1, 2, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), search->entry_city, 2, 3, 1, 2, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), label_district, 0, 1, 2, 3, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), label_street, 1, 2, 2, 3, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), label_number, 2, 3, 2, 3, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), search->entry_district, 0, 1, 3, 4, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), search->entry_street, 1, 2, 3, 4, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), search->entry_number, 2, 3, 3, 4, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), search->listbox, 0, 3, 4, 5, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0); gtk_table_attach(GTK_TABLE(table), button1, 0, 1, 5, 6, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), button2, 1, 2, 5, 6, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), button3, 2, 3, 5, 6, GTK_FILL, GTK_FILL, 0, 0); g_signal_connect(G_OBJECT(search->entry_country), "changed", G_CALLBACK(changed), search); g_signal_connect(G_OBJECT(search->entry_postal), "changed", G_CALLBACK(changed), search); g_signal_connect(G_OBJECT(search->entry_city), "changed", G_CALLBACK(changed), search); g_signal_connect(G_OBJECT(search->entry_district), "changed", G_CALLBACK(changed), search); g_signal_connect(G_OBJECT(search->entry_street), "changed", G_CALLBACK(changed), search); g_signal_connect(G_OBJECT(search->entry_number), "changed", G_CALLBACK(changed), search); g_signal_connect(G_OBJECT(button1), "clicked", G_CALLBACK(button_map), search); g_signal_connect(G_OBJECT(button2), "clicked", G_CALLBACK(button_bookmark), search); g_signal_connect(G_OBJECT(button3), "clicked", G_CALLBACK(button_destination), search); g_signal_connect(G_OBJECT(search->treeview), "button-release-event", G_CALLBACK(tree_view_button_release), search); g_signal_connect(G_OBJECT(search->treeview), "row_activated", G_CALLBACK(row_activated), search); gtk_widget_grab_focus(search->entry_city); gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0); keyboard=gtk_socket_new(); gtk_box_pack_end(GTK_BOX(vbox), keyboard, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(window2), vbox); #if 0 g_signal_connect(G_OBJECT(listbox), "select-row", G_CALLBACK(select_row), NULL); #endif gtk_widget_show_all(window2); #ifndef _WIN32 gtk_socket_steal(GTK_SOCKET(keyboard), spawn_xkbd("xkbd","-geometry 200x100")); #endif country_attr=country_default(); tracking=navit_get_tracking(nav); if (tracking && tracking_get_attr(tracking, attr_country_id, &search_attr, NULL)) country_attr=&search_attr; if (country_attr) { cs=country_search_new(country_attr, 0); item=country_search_get_item(cs); if (item && item_attr_get(item, attr_country_name, &country_name)) gtk_entry_set_text(GTK_ENTRY(search->entry_country), country_name.u.str); country_search_destroy(cs); } else { dbg(0,"warning: no default country found\n"); } search->partial=1; return 0; }
GtkWidget *create_sensor_page(GtkWidget * config_window) { GtkWidget *main_widget = NULL, *use_sensor = NULL, *table = NULL, *display_at_station_name = NULL, *display_at_new_icon = NULL, *sensor_update_time = NULL, *apply_button = NULL; GSList *display_group = NULL; #ifdef DEBUGFUNCTIONCALL START_FUNCTION; #endif app->sensor_tab_start_state = 0; apply_button = lookup_widget(config_window, "apply_button"); main_widget = gtk_vbox_new(FALSE, 0); use_sensor = gtk_check_button_new_with_label(_ ("Use device temperature sensor")); GLADE_HOOKUP_OBJECT(config_window, use_sensor, "use_sensor"); gtk_widget_set_name(use_sensor, "use_sensor"); table = gtk_table_new(2, 3, FALSE); /* check if sensor is enable */ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(use_sensor), app->config->use_sensor); if (app->config->use_sensor) { gtk_widget_set_sensitive(table, TRUE); app->sensor_tab_start_state |= STATE_USE_SENSOR; } else gtk_widget_set_sensitive(table, FALSE); g_signal_connect(GTK_TOGGLE_BUTTON(use_sensor), "toggled", G_CALLBACK(use_sensor_button_toggled_handler), table); if (apply_button) g_signal_connect(use_sensor, "toggled", G_CALLBACK(check_buttons_changed_handler), config_window); /* display sensor at */ gtk_table_attach_defaults(GTK_TABLE(table), gtk_label_new(_ ("Show temperature at:")), 0, 1, 0, 1); gtk_table_attach_defaults(GTK_TABLE(table), display_at_station_name = gtk_radio_button_new_with_label(NULL, _ ("station name")), 1, 2, 0, 1); GLADE_HOOKUP_OBJECT(config_window, display_at_station_name, "display_at"); gtk_widget_set_name(display_at_station_name, "display_at_name"); if (apply_button) g_signal_connect(display_at_station_name, "toggled", G_CALLBACK(check_buttons_changed_handler), config_window); gtk_button_set_focus_on_click(GTK_BUTTON(display_at_station_name), FALSE); display_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (display_at_station_name)); gtk_table_attach_defaults(GTK_TABLE(table), display_at_new_icon = gtk_radio_button_new_with_label (display_group, _("new icon")), 2, 3, 0, 1); gtk_widget_set_name(display_at_new_icon, "display_at_icon"); gtk_button_set_focus_on_click(GTK_BUTTON(display_at_new_icon), FALSE); if (apply_button) g_signal_connect(display_at_new_icon, "toggled", G_CALLBACK(check_buttons_changed_handler), config_window); if (app->config->display_at == STATION_NAME) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (display_at_station_name), TRUE); app->sensor_tab_start_state |= STATE_SHOW_AT_NAME; } else { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (display_at_new_icon), TRUE); app->sensor_tab_start_state |= STATE_SHOW_AT_ICON; } /* update time label */ gtk_table_attach_defaults(GTK_TABLE(table), gtk_label_new(_("Read sensor every:")), 0, 1, 1, 2); /* update time entry */ gtk_table_attach_defaults(GTK_TABLE(table), sensor_update_time = gtk_combo_box_new_text(), 1, 2, 1, 2); GLADE_HOOKUP_OBJECT(config_window, sensor_update_time, "sensor_update_time"); gtk_widget_set_name(sensor_update_time, "sensor_update_time"); g_signal_connect(G_OBJECT(sensor_update_time), "changed", G_CALLBACK(combo_boxs_changed_handler), (gpointer) apply_button); gtk_combo_box_append_text(GTK_COMBO_BOX(sensor_update_time), _("Never")); gtk_combo_box_append_text(GTK_COMBO_BOX(sensor_update_time), _("1 minute")); gtk_combo_box_append_text(GTK_COMBO_BOX(sensor_update_time), _("3 minutes")); gtk_combo_box_append_text(GTK_COMBO_BOX(sensor_update_time), _("5 minutes")); gtk_combo_box_append_text(GTK_COMBO_BOX(sensor_update_time), _("10 minutes")); gtk_combo_box_append_text(GTK_COMBO_BOX(sensor_update_time), _("15 minutes")); gtk_combo_box_append_text(GTK_COMBO_BOX(sensor_update_time), _("30 minutes")); switch (get_index_from_time(app->config->sensor_update_time)) { default: case 0: gtk_combo_box_set_active(GTK_COMBO_BOX(sensor_update_time), 0); break; case 1: gtk_combo_box_set_active(GTK_COMBO_BOX(sensor_update_time), 1); break; case 2: gtk_combo_box_set_active(GTK_COMBO_BOX(sensor_update_time), 2); break; case 3: gtk_combo_box_set_active(GTK_COMBO_BOX(sensor_update_time), 3); break; case 4: gtk_combo_box_set_active(GTK_COMBO_BOX(sensor_update_time), 4); break; case 5: gtk_combo_box_set_active(GTK_COMBO_BOX(sensor_update_time), 5); break; case 6: gtk_combo_box_set_active(GTK_COMBO_BOX(sensor_update_time), 6); break; } /* pack items to the main widget */ gtk_box_pack_start(GTK_BOX(main_widget), use_sensor, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(main_widget), table, TRUE, TRUE, 0); gtk_widget_show_all(main_widget); app->sensor_tab_current_state = app->sensor_tab_start_state; return main_widget; }
static int align_layers_dialog (void) { GtkWidget *dialog; GtkWidget *table; GtkWidget *combo; GtkWidget *toggle; GtkObject *adj; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Align Visible Layers"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); table = gtk_table_new (7, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_set_border_width (GTK_CONTAINER (table), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), table, FALSE, FALSE, 0); gtk_widget_show (table); combo = gimp_int_combo_box_new (C_("align-style", "None"), H_NONE, _("Collect"), H_COLLECT, _("Fill (left to right)"), LEFT2RIGHT, _("Fill (right to left)"), RIGHT2LEFT, _("Snap to grid"), SNAP2HGRID, NULL); gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), VALS.h_style); g_signal_connect (combo, "changed", G_CALLBACK (gimp_int_combo_box_get_active), &VALS.h_style); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("_Horizontal style:"), 0.0, 0.5, combo, 2, FALSE); combo = gimp_int_combo_box_new (_("Left edge"), H_BASE_LEFT, _("Center"), H_BASE_CENTER, _("Right edge"), H_BASE_RIGHT, NULL); gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), VALS.h_base); g_signal_connect (combo, "changed", G_CALLBACK (gimp_int_combo_box_get_active), &VALS.h_base); gimp_table_attach_aligned (GTK_TABLE (table), 0, 1, _("Ho_rizontal base:"), 0.0, 0.5, combo, 2, FALSE); combo = gimp_int_combo_box_new (C_("align-style", "None"), V_NONE, _("Collect"), V_COLLECT, _("Fill (top to bottom)"), TOP2BOTTOM, _("Fill (bottom to top)"), BOTTOM2TOP, _("Snap to grid"), SNAP2VGRID, NULL); gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), VALS.v_style); g_signal_connect (combo, "changed", G_CALLBACK (gimp_int_combo_box_get_active), &VALS.v_style); gimp_table_attach_aligned (GTK_TABLE (table), 0, 2, _("_Vertical style:"), 0.0, 0.5, combo, 2, FALSE); combo = gimp_int_combo_box_new (_("Top edge"), V_BASE_TOP, _("Center"), V_BASE_CENTER, _("Bottom edge"), V_BASE_BOTTOM, NULL); gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), VALS.v_base); g_signal_connect (combo, "changed", G_CALLBACK (gimp_int_combo_box_get_active), &VALS.v_base); gimp_table_attach_aligned (GTK_TABLE (table), 0, 3, _("Ver_tical base:"), 0.0, 0.5, combo, 2, FALSE); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 4, _("_Grid size:"), SCALE_WIDTH, 0, VALS.grid_size, 1, 200, 1, 10, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &VALS.grid_size); toggle = gtk_check_button_new_with_mnemonic (_("_Ignore the bottom layer even if visible")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), VALS.ignore_bottom); gtk_table_attach_defaults (GTK_TABLE (table), toggle, 0, 3, 5, 6); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &VALS.ignore_bottom); toggle = gtk_check_button_new_with_mnemonic (_("_Use the (invisible) bottom layer as the base")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), VALS.base_is_bottom_layer); gtk_table_attach_defaults (GTK_TABLE (table), toggle, 0, 3, 6, 7); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &VALS.base_is_bottom_layer); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
GtkWidget* capture_prefs_show(void) { GtkWidget *main_tb, *main_vb; GtkWidget *if_cbxe, *if_lb, *promisc_cb, *pcap_ng_cb, *sync_cb, *auto_scroll_cb, *show_info_cb; GtkWidget *ifopts_lb, *ifopts_bt; GList *if_list, *combo_list; int err; int row = 0; const gchar *tooltips_text; /* Main vertical box */ main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 7, FALSE); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5); /* Main table */ main_tb = gtk_table_new(CAPTURE_TABLE_ROWS, 2, FALSE); gtk_box_pack_start(GTK_BOX(main_vb), main_tb, FALSE, FALSE, 0); gtk_table_set_row_spacings(GTK_TABLE(main_tb), 10); gtk_table_set_col_spacings(GTK_TABLE(main_tb), 15); gtk_widget_show(main_tb); /* Default device */ if_lb = gtk_label_new("Default interface:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_lb), 1.0f, 0.5f); gtk_widget_show(if_lb); if_cbxe = gtk_combo_box_text_new_with_entry(); /* * XXX - what if we can't get the list? */ if_list = capture_interface_list(&err, NULL); combo_list = build_capture_combo_list(if_list, FALSE); free_interface_list(if_list); if (combo_list != NULL) { GList *combo_entry; for (combo_entry = combo_list; combo_entry != NULL; combo_entry = g_list_next(combo_entry)) { gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(if_cbxe), combo_entry->data); } } if (prefs.capture_device) { gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(if_cbxe))), prefs.capture_device); } else if (combo_list != NULL) { gtk_combo_box_set_active(GTK_COMBO_BOX(if_cbxe), 0); } free_capture_combo_list(combo_list); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_cbxe, 1, 2, row, row+1); tooltips_text = "The default interface to be captured from."; gtk_widget_set_tooltip_text(if_lb, tooltips_text); gtk_widget_set_tooltip_text(gtk_bin_get_child(GTK_BIN(if_cbxe)), tooltips_text); gtk_widget_show(if_cbxe); g_object_set_data(G_OBJECT(main_vb), DEVICE_KEY, if_cbxe); row++; /* Interface properties */ ifopts_lb = gtk_label_new("Interfaces:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), ifopts_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(ifopts_lb), 1.0f, 0.5f); gtk_widget_show(ifopts_lb); ifopts_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_EDIT); tooltips_text = "Open a dialog box to set various interface options."; gtk_widget_set_tooltip_text(ifopts_lb, tooltips_text); gtk_widget_set_tooltip_text(ifopts_bt, tooltips_text); g_signal_connect(ifopts_bt, "clicked", G_CALLBACK(ifopts_edit_cb), NULL); gtk_table_attach_defaults(GTK_TABLE(main_tb), ifopts_bt, 1, 2, row, row+1); row++; /* Promiscuous mode */ promisc_cb = create_preference_check_button(main_tb, row++, "Capture packets in promiscuous mode:", "Usually a network card will only capture the traffic sent to its own network address. " "If you want to capture all traffic that the network card can \"see\", mark this option. " "See the FAQ for some more details of capturing packets from a switched network. ", prefs.capture_prom_mode); g_object_set_data(G_OBJECT(main_vb), PROM_MODE_KEY, promisc_cb); /* Pcap-NG format */ pcap_ng_cb = create_preference_check_button(main_tb, row++, "Capture packets in pcap-ng format:", "Capture packets in the next-generation capture file format.", prefs.capture_pcap_ng); g_object_set_data(G_OBJECT(main_vb), PCAP_NG_KEY, pcap_ng_cb); /* Real-time capture */ sync_cb = create_preference_check_button(main_tb, row++, "Update list of packets in real time:", "Update the list of packets while capture is in progress. " "Don't use this option if you notice packet drops.", prefs.capture_real_time); g_object_set_data(G_OBJECT(main_vb), CAPTURE_REAL_TIME_KEY, sync_cb); /* Auto-scroll real-time capture */ auto_scroll_cb = create_preference_check_button(main_tb, row++, "Automatic scrolling in live capture:", "Automatic scrolling of the packet list while live capture is in progress. ", prefs.capture_auto_scroll); g_object_set_data(G_OBJECT(main_vb), AUTO_SCROLL_KEY, auto_scroll_cb); /* Show capture info dialog */ show_info_cb = create_preference_check_button(main_tb, row++, "Hide capture info dialog:", "Hide the capture info dialog while capturing. ", !prefs.capture_show_info); g_object_set_data(G_OBJECT(main_vb), SHOW_INFO_KEY, show_info_cb); /* Show 'em what we got */ gtk_widget_show_all(main_vb); return(main_vb); }
void finestra(struttura *str) { GtkWidget *frame, *framet9, *winbox, *box,*cbox, *tbox, *table, *scrolled_window;//nuovo x lista GtkWidget **buttonArray; int i, x, y; char s_i[3]; /*Definiamo vettore che contiene gli indici delle posizioni possibili dell'interfaccia*/ char s[NUM_OF_BUTTONS][10]={"1","2 abc","3 def","4 ghi","5 jkl","6 mno","7 pqrs","8 tuv","9 wxyz","⇧ shift","0 +","alt gr","del","] [","↵","txt pr","→|",".","←","↓","→"}; /* GDK_GRAVITY_SOUTH_WEST is the reference point corresponding at the lower left corner -> position 1 GDK_GRAVITY_SOUTH is the reference point corresponding at the middle of the lower edge -> position 2 GDK_GRAVITY_SOUTH_EAST is the reference point corresponding at the lower right corner -> position 3 */ gtk_init (NULL,NULL); str->window = gtk_window_new (GTK_WINDOW_POPUP); gtk_window_set_default_size (GTK_WINDOW(str->window), WINDOW_WIDTH, WINDOW_HEIGHT); winbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (str->window), winbox); gtk_widget_show (winbox); /* Crea una Frame */ frame = gtk_frame_new(NULL); gtk_container_add(GTK_CONTAINER(winbox), frame); /* Setta l'etichetta della frame */ gtk_frame_set_label( GTK_FRAME(frame), "Tastiera" ); gtk_widget_show (frame); box = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (frame), box); gtk_widget_show (box); buttonArray = (GtkWidget**)g_malloc((NUM_OF_BUTTONS)*sizeof(GtkButton**)); table = gtk_table_new(NUM_OF_ROWS, NUM_OF_COLUMNS, TRUE); gtk_table_set_row_spacings(GTK_TABLE(table), 1); gtk_table_set_col_spacings(GTK_TABLE(table), 1); x=y=0; for(i=0; i<NUM_OF_BUTTONS;i++) { buttonArray[i] = gtk_button_new_with_label(s[i]); gtk_widget_set_size_request(buttonArray[i],60,50); gtk_table_attach_defaults(GTK_TABLE(table), buttonArray[i], x, x+1, y, y+1); sprintf(s_i,"%i",i); gtk_widget_set_name(buttonArray[i],s_i); g_signal_connect(G_OBJECT(buttonArray[i]), "clicked", G_CALLBACK(button_clicked),str); if(++x==NUM_OF_COLUMNS) { x=0; y++; } } gtk_box_pack_start(GTK_BOX(box), table, FALSE, FALSE, 0); /* Crea una Label per i tasti Shift e Ctrl */ str->mylabel = gtk_label_new (NULL); gtk_container_add(GTK_CONTAINER(box), str->mylabel); gtk_widget_show (str->mylabel); /* Crea una FrameT9 */ framet9 = gtk_frame_new(NULL); gtk_container_add(GTK_CONTAINER(winbox), framet9); /* Setta l'etichetta della frame */ gtk_frame_set_label( GTK_FRAME(framet9), "txt prediction" ); gtk_widget_show (framet9); tbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (framet9), tbox); gtk_widget_show (tbox); /* Crea una Lista per il T9 */ str->tp.gtklist=gtk_list_new(); gtk_list_set_selection_mode((GtkList *)str->tp.gtklist, GTK_SELECTION_SINGLE); gtk_widget_set_usize(str->tp.gtklist, 0, 100); gtk_container_add(GTK_CONTAINER(tbox), str->tp.gtklist); gtk_widget_show(str->tp.gtklist); gtk_signal_connect(GTK_OBJECT(str->tp.gtklist),"selection_changed",GTK_SIGNAL_FUNC(sigh_print_selection),str);//nuovo x lista /* Crea una Label per il T9 */ str->mylabel2 = gtk_label_new (NULL); gtk_label_set_text (GTK_LABEL (str->mylabel2),"txt pr disattivato"); gtk_widget_set_usize(str->mylabel2, 0, 1); gtk_container_add(GTK_CONTAINER(tbox),str->mylabel2); gtk_widget_show (str->mylabel2); /* Crea uno status icon per la minimizzazione */ str->tray_icon = gtk_status_icon_new(); g_signal_connect(G_OBJECT(str->tray_icon), "activate",G_CALLBACK(tray_icon_on_click), str); gtk_status_icon_set_from_icon_name(str->tray_icon,GTK_STOCK_MEDIA_STOP); gtk_status_icon_set_from_file(str->tray_icon,"keyboard_icon.gif"); gtk_status_icon_set_tooltip(str->tray_icon,"Keyboard Tray Icon"); gtk_status_icon_set_visible(str->tray_icon, FALSE); gtk_widget_show_all(str->window); /*salviamo le dim massime dello schermo corrente*/ getMaxScreen(str); gtk_main (); }
static void ifopts_edit_cb(GtkWidget *w, gpointer data _U_) { GtkWidget *ifopts_edit_dlg, *cur_scr_win, *main_hb, *main_tb, *cur_opts_fr, *ed_opts_fr, *main_vb, *if_descr_lb, *if_hide_lb, *bbox, *ok_bt, *cancel_bt, *help_bt; GtkListStore *list_store; GtkWidget *list; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeView *list_view; GtkTreeSelection *selection; int row = 0; GtkWidget *caller = gtk_widget_get_toplevel(w); /* Has an edit dialog box already been opened for that top-level widget? */ ifopts_edit_dlg = g_object_get_data(G_OBJECT(caller), IFOPTS_DIALOG_PTR_KEY); if (ifopts_edit_dlg != NULL) { /* Yes. Just re-activate that dialog box. */ reactivate_window(ifopts_edit_dlg); return; } /* create a new dialog */ ifopts_edit_dlg = dlg_conf_window_new("Wireshark: Preferences: Interface Options"); gtk_window_set_default_size(GTK_WINDOW(ifopts_edit_dlg), 1000, 440); main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 1, FALSE); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5); gtk_container_add(GTK_CONTAINER(ifopts_edit_dlg), main_vb); gtk_widget_show(main_vb); /* create current options frame */ cur_opts_fr = gtk_frame_new("Interfaces"); gtk_container_add(GTK_CONTAINER(main_vb), cur_opts_fr); gtk_widget_show(cur_opts_fr); /* create a scrolled window to pack the current options TreeView widget into */ cur_scr_win = scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(cur_scr_win), 3); gtk_container_add(GTK_CONTAINER(cur_opts_fr), cur_scr_win); gtk_widget_show(cur_scr_win); /* * Create current options TreeView. */ list_store = gtk_list_store_new(N_COLUMN, /* Total number of columns XXX */ G_TYPE_STRING, /* Device */ G_TYPE_STRING, /* Description */ #ifdef HAVE_PCAP_CREATE G_TYPE_BOOLEAN, /* Monitor mode */ #endif G_TYPE_STRING, /* Default link-layer */ G_TYPE_STRING, /* Comment */ G_TYPE_BOOLEAN, /* Hide? */ G_TYPE_INT); /* Dlt */ list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store)); list_view = GTK_TREE_VIEW(list); /* The view now holds a reference. We can get rid of our own reference */ g_object_unref (G_OBJECT (list_store)); /* * Create the first column packet, associating the "text" attribute of the * cell_renderer to the first column of the model */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Device", renderer, "text", DEVICE_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); #ifdef _WIN32 gtk_tree_view_column_set_min_width(column, 230); #else gtk_tree_view_column_set_min_width(column, 70); #endif /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Description", renderer, "text", DESC_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 260); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); #ifdef HAVE_PCAP_CREATE /* * XXX - for some reason, this doesn't show up. */ renderer = gtk_cell_renderer_toggle_new (); column = gtk_tree_view_column_new_with_attributes ("Default to monitor mode", renderer, "active", DEF_MONITOR_MODE_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); #endif renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Default link-layer", renderer, "text", DEF_LINK_LAYER_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 230); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Comment", renderer, "text", COMMENT_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 100); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); renderer = gtk_cell_renderer_toggle_new (); column = gtk_tree_view_column_new_with_attributes ("Hide?", renderer, "active", HIDE_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); #if 0 /* Don't show the DLT column */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("DLT", renderer, "text", DLT_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 40); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); #endif /* Setup the selection handler */ selection = gtk_tree_view_get_selection(list_view); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); cur_list = list; gtk_container_add(GTK_CONTAINER(cur_scr_win), cur_list); if_selection = selection; g_signal_connect (G_OBJECT (selection), "changed", /* select_row */ G_CALLBACK (ifopts_edit_ifsel_cb), NULL); gtk_widget_show(cur_list); /* add interface names to cell */ ifopts_if_liststore_add(); /* create edit options frame */ ed_opts_fr = gtk_frame_new("Properties"); gtk_box_pack_start(GTK_BOX(main_vb), ed_opts_fr, FALSE, FALSE, 0); gtk_widget_show(ed_opts_fr); main_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5, TRUE); gtk_container_set_border_width(GTK_CONTAINER(main_hb), 3); gtk_container_add(GTK_CONTAINER(ed_opts_fr), main_hb); gtk_widget_show(main_hb); /* table to hold description text entry and hide button */ main_tb = gtk_table_new(IFOPTS_TABLE_ROWS, 4, FALSE); gtk_box_pack_start(GTK_BOX(main_hb), main_tb, TRUE, FALSE, 10); gtk_table_set_row_spacings(GTK_TABLE(main_tb), 10); gtk_table_set_col_spacings(GTK_TABLE(main_tb), 10); gtk_widget_show(main_tb); if_dev_lb = gtk_label_new("Device:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_dev_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_dev_lb), 1.0f, 0.5f); gtk_widget_show(if_dev_lb); if_dev_lb = gtk_label_new(""); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_dev_lb, 1, 2, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_dev_lb), 0.0f, 0.5f); gtk_widget_show(if_dev_lb); row++; if_name_lb = gtk_label_new("Description:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_name_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_name_lb), 1.0f, 0.5f); gtk_widget_show(if_name_lb); if_name_lb = gtk_label_new(""); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_name_lb, 1, 2, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_name_lb), 0.0f, 0.5f); gtk_widget_show(if_name_lb); row++; #ifdef HAVE_PCAP_CREATE /* create "monitor mode" label and button */ if_monitor_lb = gtk_label_new("Monitor mode:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_monitor_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_monitor_lb), 1.0f, 0.5f); gtk_widget_show(if_monitor_lb); if_monitor_cb = gtk_check_button_new(); g_signal_connect(if_monitor_cb, "toggled", G_CALLBACK(ifopts_edit_monitor_changed_cb), cur_list); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_monitor_cb, 1, 2, row, row+1); gtk_widget_show(if_monitor_cb); row++; #endif if_linktype_lb = gtk_label_new("Default link-layer header type:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_linktype_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_linktype_lb), 1.0f, 0.5f); gtk_widget_show(if_linktype_lb); if_linktype_cb = gtk_combo_box_text_new(); num_linktypes = 0; interfaces_info_nochange = FALSE; g_signal_connect(if_linktype_cb, "changed", G_CALLBACK(ifopts_edit_linktype_changed_cb), cur_list); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_linktype_cb, 1, 2, row, row+1); gtk_widget_show(if_linktype_cb); row++; /* create interface description label and text entry */ if_descr_lb = gtk_label_new("Comment:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_descr_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_descr_lb), 1.0f, 0.5f); gtk_widget_show(if_descr_lb); if_descr_te = gtk_entry_new(); g_signal_connect(if_descr_te, "changed", G_CALLBACK(ifopts_edit_descr_changed_cb), cur_list); gtk_entry_set_max_length(GTK_ENTRY(if_descr_te), IFOPTS_MAX_DESCR_LEN); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_descr_te, 1, 2, row, row+1); gtk_widget_show(if_descr_te); row++; /* create "hide interface" label and button */ if_hide_lb = gtk_label_new("Hide interface?:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_hide_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_hide_lb), 1.0f, 0.5f); gtk_widget_show(if_hide_lb); if_hide_cb = gtk_check_button_new(); g_signal_connect(if_hide_cb, "toggled", G_CALLBACK(ifopts_edit_hide_changed_cb), cur_list); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_hide_cb, 1, 2, row, row+1); gtk_widget_show(if_hide_cb); row++; /* button row: OK and Cancel buttons */ bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, GTK_STOCK_HELP, NULL); gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 0); gtk_widget_show(bbox); ok_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK); gtk_widget_set_tooltip_text(ok_bt, "Save changes and exit dialog"); g_signal_connect(ok_bt, "clicked", G_CALLBACK(ifopts_edit_ok_cb), ifopts_edit_dlg); cancel_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL); gtk_widget_set_tooltip_text(cancel_bt, "Cancel and exit dialog"); window_set_cancel_button(ifopts_edit_dlg, cancel_bt, window_cancel_button_cb); help_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP); g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb), (gpointer)HELP_CAPTURE_INTERFACE_OPTIONS_DIALOG); gtk_widget_set_tooltip_text (help_bt, "Show topic specific help"); gtk_widget_grab_default(ok_bt); g_signal_connect(ifopts_edit_dlg, "delete_event", G_CALLBACK(window_delete_event_cb), NULL); /* Call a handler when we're destroyed, so we can inform our caller, if any, that we've been destroyed. */ g_signal_connect(ifopts_edit_dlg, "destroy", G_CALLBACK(ifopts_edit_destroy_cb), NULL); /* Set the key for the new dialog to point to our caller. */ g_object_set_data(G_OBJECT(ifopts_edit_dlg), IFOPTS_CALLER_PTR_KEY, caller); /* Set the key for the caller to point to us */ g_object_set_data(G_OBJECT(caller), IFOPTS_DIALOG_PTR_KEY, ifopts_edit_dlg); gtk_widget_show(ifopts_edit_dlg); /* triggers ifopts_edit_ifsel_cb() with the */ /* "interfaces" TreeView first row selected */ window_present(ifopts_edit_dlg); }
/* 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 * window_create (test_case_t *cases, cairo_perf_report_t *reports, int num_reports) { GtkWidget *window, *table, *w; GtkWidget *tv, *sw; GtkTreeStore *store; GtkTreeViewColumn *column; GtkCellRenderer *renderer; struct _app_data *data; data = g_new0 (struct _app_data, 1); data->cases = cases; data->reports = reports; data->num_reports = num_reports; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Cairo Performance Graph"); g_object_set_data_full (G_OBJECT (window), "app-data", data, (GDestroyNotify)g_free); data->window = window; table = gtk_table_new (2, 2, FALSE); /* legend & show/hide lines (categorised) */ tv = gtk_tree_view_new (); store = cases_to_store (cases); data->case_store = store; gtk_tree_view_set_model (GTK_TREE_VIEW (tv), GTK_TREE_MODEL (store)); renderer = gtk_cell_renderer_toggle_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "active", CASE_SHOWN, "inconsistent", CASE_INCONSISTENT, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column); g_signal_connect (renderer, "toggled", G_CALLBACK (show_case_toggled), data); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Backend", renderer, "text", CASE_BACKEND, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Content", renderer, "text", CASE_CONTENT, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Test", renderer, "text", CASE_NAME, "foreground-gdk", CASE_FG_COLOR, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Size", renderer, "text", CASE_SIZE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tv), TRUE); g_object_unref (store); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (sw), tv); gtk_widget_show (tv); gtk_table_attach (GTK_TABLE (table), sw, 0, 1, 0, 2, GTK_FILL, GTK_FILL, 4, 4); gtk_widget_show (sw); /* the performance chart */ w = graph_view_new (); data->gv = w; g_signal_connect (w, "report-selected", G_CALLBACK (gv_report_selected), data); graph_view_set_reports ((GraphView *)w, cases, reports, num_reports); gtk_table_attach (GTK_TABLE (table), w, 1, 2, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 4, 4); gtk_widget_show (w); /* interesting information - presumably the commit log */ w = gtk_text_view_new (); data->git_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (w)); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (sw), w); gtk_widget_show (w); gtk_table_attach (GTK_TABLE (table), sw, 1, 2, 1, 2, GTK_FILL, GTK_FILL | GTK_EXPAND, 4, 4); gtk_widget_show (sw); gtk_container_add (GTK_CONTAINER (window), table); gtk_widget_show (table); return window; }
static void saa_solid_display_init (SaaSolidDisplay * dsp) { GtkWidget * frs, * frar, * frai, * fro; GtkWidget * ts, * tar, * to, * hai; GtkWidget * bg_label; GtkObject * adjs = gtk_adjustment_new (.02, .02, .5, .001, .01, 0); GtkObject * adjar = gtk_adjustment_new (.01, .01, .2, .001, .01, 0); gtk_table_resize(GTK_TABLE(dsp), 4, 1); gtk_table_set_homogeneous(GTK_TABLE(dsp), TRUE); frs = gtk_frame_new(_("Vertices")); gtk_widget_show(frs); gtk_table_attach_defaults (GTK_TABLE (dsp), frs, 0, 1, 0, 1); ts = gtk_table_new(3, 2, TRUE); gtk_widget_show(ts); gtk_container_set_border_width (GTK_CONTAINER (ts), 5); gtk_container_add(GTK_CONTAINER(frs), ts); dsp->rads1 = gtk_radio_button_new_with_label(NULL, _("Do not display")); gtk_widget_show(dsp->rads1); gtk_table_attach_defaults (GTK_TABLE (ts), dsp->rads1, 0, 2, 0, 1); dsp->rads2 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(dsp->rads1), _("Molecular")); gtk_widget_show(dsp->rads2); gtk_table_attach_defaults (GTK_TABLE (ts), dsp->rads2, 0, 1, 1, 2); dsp->rads3 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(dsp->rads2), _("Point")); gtk_widget_show(dsp->rads3); gtk_table_attach_defaults (GTK_TABLE (ts), dsp->rads3, 0, 1, 2, 3); dsp->spins = gtk_spin_button_new(GTK_ADJUSTMENT(adjs), 0.001, 3); gtk_widget_show(dsp->spins); gtk_table_attach (GTK_TABLE (ts), dsp->spins, 1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0); dsp->bts = gtk_color_button_new(); gtk_widget_show(dsp->bts); gtk_table_attach (GTK_TABLE (ts), dsp->bts, 1, 2, 2, 3, GTK_SHRINK, GTK_SHRINK, 0, 0); frar = gtk_frame_new(_("Edges")); gtk_widget_show(frar); gtk_table_attach (GTK_TABLE (dsp), frar, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); tar = gtk_table_new(3, 2, TRUE); gtk_widget_show(tar); gtk_container_set_border_width (GTK_CONTAINER (tar), 5); gtk_container_add(GTK_CONTAINER(frar), tar); dsp->radar1 = gtk_radio_button_new_with_label(NULL, _("Do not display")); gtk_widget_show(dsp->radar1); gtk_table_attach_defaults (GTK_TABLE (tar), dsp->radar1, 0, 2, 0, 1); dsp->radar2 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(dsp->radar1), _("Molecular")); gtk_widget_show(dsp->radar2); gtk_table_attach_defaults (GTK_TABLE (tar), dsp->radar2, 0, 1, 1, 2); dsp->radar3 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(dsp->radar2), _("Line")); gtk_widget_show(dsp->radar3); gtk_table_attach_defaults (GTK_TABLE (tar), dsp->radar3, 0, 1, 2, 3); dsp->spinar = gtk_spin_button_new(GTK_ADJUSTMENT(adjar), 0.001, 3); gtk_widget_show(dsp->spinar); gtk_table_attach (GTK_TABLE (tar), dsp->spinar, 1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0); dsp->btar = gtk_color_button_new(); gtk_widget_show(dsp->btar); gtk_table_attach (GTK_TABLE (tar), dsp->btar, 1, 2, 2, 3, GTK_SHRINK, GTK_SHRINK, 0, 0); frai = gtk_frame_new(_("Wings")); gtk_widget_show(frai); gtk_table_attach (GTK_TABLE (dsp), frai, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0); hai = gtk_vbox_new(TRUE, 5); gtk_widget_show(hai); gtk_container_set_border_width (GTK_CONTAINER (hai), 5); gtk_container_add(GTK_CONTAINER(frai), hai); dsp->radai1 = gtk_radio_button_new_with_label(NULL, _("Do not display")); gtk_widget_show(dsp->radai1); gtk_box_pack_start_defaults(GTK_BOX(hai), dsp->radai1); dsp->radai2 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(dsp->radai1), _("Triangulation")); gtk_widget_show(dsp->radai2); gtk_box_pack_start_defaults(GTK_BOX(hai), dsp->radai2); dsp->radai3 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(dsp->radai2), _("Colour")); gtk_widget_show(dsp->radai3); gtk_box_pack_start_defaults(GTK_BOX(hai), dsp->radai3); fro = gtk_frame_new("Autres"); gtk_widget_show(fro); gtk_table_attach_defaults (GTK_TABLE (dsp), fro, 0, 1, 3, 4); to = gtk_table_new(4, 2, TRUE); gtk_widget_show(to); gtk_container_set_border_width (GTK_CONTAINER (to), 5); gtk_container_add(GTK_CONTAINER(fro), to); dsp->chlight = gtk_check_button_new_with_label(_("Lighting")); gtk_widget_show(dsp->chlight); gtk_table_attach (GTK_TABLE (to), dsp->chlight, 0, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0); dsp->chtrans = gtk_check_button_new_with_label(_("Transparency")); gtk_widget_show(dsp->chtrans); gtk_table_attach (GTK_TABLE (to), dsp->chtrans, 0, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0); dsp->chaxes = gtk_check_button_new_with_label(_("Axes")); gtk_widget_show(dsp->chaxes); gtk_table_attach (GTK_TABLE (to), dsp->chaxes, 0, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0); bg_label = gtk_label_new(_("Background")); gtk_widget_show(bg_label); gtk_table_attach_defaults (GTK_TABLE (to), bg_label, 0, 1, 3, 4); dsp->btbg = gtk_color_button_new(); gtk_widget_show(dsp->btbg); gtk_table_attach (GTK_TABLE (to), dsp->btbg, 1, 2, 3, 4, GTK_SHRINK, GTK_SHRINK, 0, 0); g_signal_connect_swapped ((gpointer) dsp->rads1, "toggled", G_CALLBACK (saa_solid_display_s1), dsp); g_signal_connect_swapped ((gpointer) dsp->rads2, "toggled", G_CALLBACK (saa_solid_display_s2), dsp); g_signal_connect_swapped ((gpointer) dsp->rads3, "toggled", G_CALLBACK (saa_solid_display_s3), dsp); g_signal_connect_swapped ((gpointer) dsp->radar1, "toggled", G_CALLBACK (saa_solid_display_ar1), dsp); g_signal_connect_swapped ((gpointer) dsp->radar2, "toggled", G_CALLBACK (saa_solid_display_ar2), dsp); g_signal_connect_swapped ((gpointer) dsp->radar3, "toggled", G_CALLBACK (saa_solid_display_ar3), dsp); g_signal_connect_swapped ((gpointer) dsp->radai1, "toggled", G_CALLBACK (saa_solid_display_ai1), dsp); g_signal_connect_swapped ((gpointer) dsp->radai2, "toggled", G_CALLBACK (saa_solid_display_ai2), dsp); g_signal_connect_swapped ((gpointer) dsp->radai3, "toggled", G_CALLBACK (saa_solid_display_ai3), dsp); g_signal_connect_swapped ((gpointer) dsp->chlight, "toggled", G_CALLBACK (saa_solid_display_light), dsp); g_signal_connect_swapped ((gpointer) dsp->chtrans, "toggled", G_CALLBACK (saa_solid_display_trans), dsp); g_signal_connect_swapped ((gpointer) dsp->chaxes, "toggled", G_CALLBACK (saa_solid_display_axes), dsp); g_signal_connect_swapped ((gpointer) dsp->btbg, "color-set", G_CALLBACK (saa_solid_display_bgcolor), dsp); g_signal_connect_swapped ((gpointer) dsp->bts, "color-set", G_CALLBACK (saa_solid_display_scolor), dsp); g_signal_connect_swapped ((gpointer) dsp->btar, "color-set", G_CALLBACK (saa_solid_display_arcolor), dsp); g_signal_connect_swapped ((gpointer) dsp->spins, "value-changed", G_CALLBACK (saa_solid_display_ssize), dsp); g_signal_connect_swapped ((gpointer) dsp->spinar, "value-changed", G_CALLBACK (saa_solid_display_arsize), dsp); }
void gui_animate_dialog(void) { gpointer dialog; GtkWidget *window, *main_vbox, *table, *vbox, *hbox; GtkWidget *notebook, *page, *label, *entry, *scale; GList *list; /* prevent recording whilst in animation */ gui_mode_switch(FREE); /* dialog setup */ dialog = dialog_request(ANIM, "Animation and Rendering", NULL, NULL, NULL); if (!dialog) return; window = dialog_window(dialog); gtk_widget_set_size_request(window, 350, -1); /* notebook frame */ main_vbox = gtk_vbox_new(FALSE, PANEL_SPACING); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(window)->vbox), main_vbox); /* create notebook */ vbox = gui_frame_vbox(NULL, FALSE, FALSE, main_vbox); notebook = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(vbox),notebook,FALSE,TRUE,0); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP); gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), TRUE); /* page */ page = gtk_vbox_new(FALSE, PANEL_SPACING); label = gtk_label_new("Control"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label); vbox = gtk_vbox_new(FALSE, PANEL_SPACING); gtk_box_pack_start(GTK_BOX(page),vbox,FALSE,FALSE,0); /* format pulldown */ animate_phonons=FALSE; list = NULL; list = g_list_append(list, "Frames"); list = g_list_append(list, "Phonons"); hbox = gtk_hbox_new(FALSE, 0); label = gtk_label_new("Display "); gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0); entry = gui_pulldown_new(NULL, list, 0, hbox); g_list_free(list); g_signal_connect(GTK_OBJECT(entry), "changed", GTK_SIGNAL_FUNC(gui_animate_type_change), (gpointer) entry); gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0); /* phonon options */ box_phonon_options = gtk_vbox_new(FALSE, PANEL_SPACING); gtk_box_pack_start(GTK_BOX(vbox),box_phonon_options,FALSE,FALSE,0); gui_direct_spin("Phonon scaling ", &sysenv.render.phonon_scaling, 0.1, 9.9, 0.1, NULL, NULL, box_phonon_options); gui_direct_spin("Phonon resolution ", &sysenv.render.phonon_resolution, 10.0, 100.0, 1.0, NULL, NULL, box_phonon_options); gtk_box_pack_start(GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 0); /* CURRENT - FPS */ gui_direct_spin("Apparent FPS for animation ", &gui_animate_fps, 1, 50, 1, NULL, NULL, vbox); /* connectivity options */ gui_direct_check("Recalculate connectivity", &sysenv.render.connect_redo, NULL, NULL, vbox); /* gui_checkbox("Don't recalculate scale", NULL, vbox); gui_checkbox("Loop", NULL, vbox); */ /* actions at start of each cycle */ /* new_radio_group(0, vbox, FF); button = add_radio_button("Confine atoms to PBC", (gpointer) atom_pbc, data); if (data->anim_confine == PBC_CONFINE_ATOMS) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); button = add_radio_button("Confine mols to PBC", (gpointer) mol_pbc, data); if (data->anim_confine == PBC_CONFINE_MOLS) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); button = add_radio_button("Cell confinement off", (gpointer) no_pbc, data); if (data->anim_confine == PBC_CONFINE_NONE) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); */ /* page */ page = gtk_vbox_new(FALSE, PANEL_SPACING); label = gtk_label_new("Render"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label); vbox = gtk_vbox_new(FALSE, PANEL_SPACING); gtk_box_pack_start(GTK_BOX(page),vbox,FALSE,FALSE,0); gui_direct_spin("Width", &sysenv.render.width, 100, 2000, 100, NULL, NULL, vbox); gui_direct_spin("Height", &sysenv.render.height, 100, 2000, 100, NULL, NULL, vbox); gtk_box_pack_start(GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 0); gui_direct_check("Shadowless", &sysenv.render.shadowless, NULL, NULL, vbox); gui_direct_check("Create povray input then stop", &sysenv.render.no_povray_exec, NULL, NULL, vbox); gui_direct_check("Cleanup temporary files", &sysenv.render.no_keep_tempfiles, NULL, NULL, vbox); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0); gui_button(" Render ", gui_animate_render, NULL, hbox, TF); /* page */ page = gtk_vbox_new(FALSE, PANEL_SPACING); label = gtk_label_new("Movie"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label); vbox = gtk_vbox_new(FALSE, PANEL_SPACING); gtk_box_pack_start(GTK_BOX(page),vbox,FALSE,FALSE,0); table = gtk_table_new(4, 4, FALSE); gtk_box_pack_start(GTK_BOX(vbox),table,FALSE,FALSE,0); /* name label */ label = gtk_label_new("Filename"); gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,0,1); /* name entry */ /* entry = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(entry), sysenv.render.animate_file); */ entry = gui_text_entry(NULL, &sysenv.render.animate_file, TRUE, FALSE, NULL); gtk_table_attach_defaults(GTK_TABLE(table),entry,1,2,0,1); /* format label */ label = gtk_label_new("Format"); gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,1,2); /* format pulldown */ list=NULL; list = g_list_append(list, "mpg"); list = g_list_append(list, "mp4"); list = g_list_append(list, "flv"); list = g_list_append(list, "avi"); hbox = gtk_hbox_new(FALSE, 0); entry_movie_type = gui_pulldown_new(NULL, list, 0, hbox); g_list_free(list); g_signal_connect(GTK_OBJECT(entry_movie_type), "changed", GTK_SIGNAL_FUNC(gui_animate_movie_type_change), (gpointer) entry); gtk_table_attach_defaults(GTK_TABLE(table),hbox,1,2,1,2); /* update hook */ g_signal_connect(GTK_OBJECT(entry), "changed", GTK_SIGNAL_FUNC(event_render_modify), (gpointer) entry); g_object_set_data(G_OBJECT(entry), "id", (gpointer) ANIM_NAME); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0); gui_button(" Create ", gui_animate_movie, NULL, hbox, TF); /* slider for current frame */ vbox = gui_frame_vbox(NULL, FALSE, FALSE, main_vbox); scale = gtk_hscale_new_with_range(1.0, 100.0, 1.0); gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_CONTINUOUS); gtk_box_pack_start(GTK_BOX(vbox), scale, TRUE, TRUE, 0); g_signal_connect(GTK_OBJECT(scale), "value_changed", GTK_SIGNAL_FUNC(gui_animate_frame_select), NULL); gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE); /* animation limits */ vbox = gui_frame_vbox(NULL, FALSE, FALSE, main_vbox); gui_text_entry("First ", &entry_frame_start, TRUE, FALSE, vbox); gui_text_entry("Last ", &entry_frame_stop, TRUE, FALSE, vbox); gui_text_entry("Step ", &entry_frame_step, TRUE, FALSE, vbox); /* control buttons */ hbox = gtk_hbox_new(TRUE, PANEL_SPACING); gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, FALSE, 0); gui_icon_button("GDIS_REWIND", NULL, gui_animate_first, NULL, hbox); gui_icon_button("GDIS_STEP_BACKWARD", NULL, gui_animate_back, NULL, hbox); gui_icon_button("GDIS_PLAY", NULL, gui_animate_play, NULL, hbox); gui_icon_button("GDIS_PAUSE", NULL, gui_animate_stop, NULL, hbox); gui_icon_button("GDIS_STEP_FORWARD", NULL, gui_animate_next, NULL, hbox); gui_icon_button("GDIS_FASTFORWARD", NULL, gui_animate_last, NULL, hbox); gui_stock_button(GTK_STOCK_HELP, gui_help_show, "Animation and Rendering", GTK_DIALOG(window)->action_area); /* terminating button */ gui_stock_button(GTK_STOCK_CLOSE, dialog_destroy, dialog, GTK_DIALOG(window)->action_area); /* display the dialog */ gtk_widget_show_all(window); gtk_widget_hide(box_phonon_options); }
gtk_widget_modify_base(p->entry_timing,GTK_STATE_NORMAL,&yellow); break; case S_KILLED: gtk_entry_set_text(GTK_ENTRY(p->entry_timing),"Killed"); change_button(p,GTK_STOCK_CLOSE,(GCallback)delete_hbox_event); gtk_widget_modify_base(p->entry_timing,GTK_STATE_NORMAL,&red); notify_user(p); break; default: warning("Unknown info\n"); } update_prog(p); return 0; } GtkWidget *new_page(int ihost){ if(!tables){ tables=mycalloc(nhost,GtkWidget*); nrows=mycalloc(nhost,gint); } nrows[ihost]=0; tables[ihost]=gtk_table_new(nrows[ihost],ncol,0); #if GTK_MAJOR_VERSION <3 || GTK_MINOR_VERSION < 4 gtk_table_set_row_spacings(GTK_TABLE(tables[ihost]), 2); gtk_table_set_col_spacings(GTK_TABLE(tables[ihost]), 2); #endif return tables[ihost]; } void kill_selected_jobs(GtkAction *btn){ (void)btn; }
gint main (gint argc, gchar *argv[]) { gtk_init (&argc, &argv); gst_init (&argc, &argv); GstElement* pipeline = gst_pipeline_new ("pipeline"); //window that contains an area where the video is drawn GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_size_request (window, 640, 480); gtk_window_move (GTK_WINDOW (window), 300, 10); gtk_window_set_title (GTK_WINDOW (window), "glimagesink implement the gstxoverlay interface"); GdkGeometry geometry; geometry.min_width = 1; geometry.min_height = 1; geometry.max_width = -1; geometry.max_height = -1; gtk_window_set_geometry_hints (GTK_WINDOW (window), window, &geometry, GDK_HINT_MIN_SIZE); //window to control the states GtkWidget* window_control = gtk_window_new (GTK_WINDOW_TOPLEVEL); geometry.min_width = 1; geometry.min_height = 1; geometry.max_width = -1; geometry.max_height = -1; gtk_window_set_geometry_hints (GTK_WINDOW (window_control), window_control, &geometry, GDK_HINT_MIN_SIZE); gtk_window_set_resizable (GTK_WINDOW (window_control), FALSE); gtk_window_move (GTK_WINDOW (window_control), 10, 10); GtkWidget* table = gtk_table_new (2, 1, TRUE); gtk_container_add (GTK_CONTAINER (window_control), table); //control state null GtkWidget* button_state_null = gtk_button_new_with_label ("GST_STATE_NULL"); g_signal_connect (G_OBJECT (button_state_null), "clicked", G_CALLBACK (button_state_null_cb), pipeline); gtk_table_attach_defaults (GTK_TABLE (table), button_state_null, 0, 1, 0, 1); gtk_widget_show (button_state_null); //control state ready GtkWidget* button_state_ready = gtk_button_new_with_label ("GST_STATE_READY"); g_signal_connect (G_OBJECT (button_state_ready), "clicked", G_CALLBACK (button_state_ready_cb), pipeline); gtk_table_attach_defaults (GTK_TABLE (table), button_state_ready, 0, 1, 1, 2); gtk_widget_show (button_state_ready); //control state paused GtkWidget* button_state_paused = gtk_button_new_with_label ("GST_STATE_PAUSED"); g_signal_connect (G_OBJECT (button_state_paused), "clicked", G_CALLBACK (button_state_paused_cb), pipeline); gtk_table_attach_defaults (GTK_TABLE (table), button_state_paused, 0, 1, 2, 3); gtk_widget_show (button_state_paused); //control state playing GtkWidget* button_state_playing = gtk_button_new_with_label ("GST_STATE_PLAYING"); g_signal_connect (G_OBJECT (button_state_playing), "clicked", G_CALLBACK (button_state_playing_cb), pipeline); gtk_table_attach_defaults (GTK_TABLE (table), button_state_playing, 0, 1, 3, 4); gtk_widget_show (button_state_playing); //change framerate GtkWidget* slider_fps = gtk_vscale_new_with_range (1, 30, 2); g_signal_connect (G_OBJECT (slider_fps), "format-value", G_CALLBACK (slider_fps_cb), pipeline); gtk_table_attach_defaults (GTK_TABLE (table), slider_fps, 1, 2, 0, 4); gtk_widget_show (slider_fps); gtk_widget_show (table); gtk_widget_show (window_control); //configure the pipeline g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(destroy_cb), pipeline); GstElement* videosrc = gst_element_factory_make ("videotestsrc", "videotestsrc"); GstElement* glupload = gst_element_factory_make ("glupload", "glupload"); GstElement* glfiltercube = gst_element_factory_make ("glfiltercube", "glfiltercube"); GstElement* glfilterlaplacian = gst_element_factory_make ("glfilterlaplacian", "glfilterlaplacian"); GstElement* videosink = gst_element_factory_make ("glimagesink", "glimagesink"); GstCaps *caps = gst_caps_new_simple("video/x-raw-yuv", "width", G_TYPE_INT, 640, "height", G_TYPE_INT, 480, "framerate", GST_TYPE_FRACTION, 25, 1, "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('A', 'Y', 'U', 'V'), NULL) ; gst_bin_add_many (GST_BIN (pipeline), videosrc, glupload, glfiltercube, glfilterlaplacian, videosink, NULL); gboolean link_ok = gst_element_link_filtered(videosrc, glupload, caps) ; gst_caps_unref(caps) ; if(!link_ok) { g_warning("Failed to link videosrc to glupload!\n") ; return -1; } if(!gst_element_link_many(glupload, glfiltercube, glfilterlaplacian, videosink, NULL)) { g_warning("Failed to link glupload to videosink!\n") ; return -1; } //area where the video is drawn GtkWidget* area = gtk_drawing_area_new(); gtk_container_add (GTK_CONTAINER (window), area); //set window id on this event GstBus* bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline)); gst_bus_set_sync_handler (bus, (GstBusSyncHandler) create_window, area); gst_bus_add_signal_watch (bus); g_signal_connect(bus, "message::error", G_CALLBACK(end_stream_cb), pipeline); g_signal_connect(bus, "message::warning", G_CALLBACK(end_stream_cb), pipeline); g_signal_connect(bus, "message::eos", G_CALLBACK(end_stream_cb), pipeline); gst_object_unref (bus); //needed when being in GST_STATE_READY, GST_STATE_PAUSED //or resizing/obscuring the window g_signal_connect(area, "expose-event", G_CALLBACK(expose_cb), videosink); g_signal_connect (area, "realize", G_CALLBACK (area_realize_cb), pipeline); //start GstStateChangeReturn ret = gst_element_set_state (pipeline, GST_STATE_PLAYING); if (ret == GST_STATE_CHANGE_FAILURE) { g_print ("Failed to start up pipeline!\n"); return -1; } gtk_widget_show_all (window); gtk_main(); return 0; }
void whiteb_show(struct Question *data) { /* Reset question picture stored in whiteb_image */ whiteb_image = NULL; /* Layout */ GtkWidget *window; GtkWidget *table, *tool_table, *viewport; /* UI */ GtkWidget *clear_board = NULL, *freeh_tool = NULL, *line_tool = NULL, *rect_tool = NULL, *circ_tool = NULL, *erase_tool = NULL, *exit_but = NULL; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window),"Powermaths Whiteboard"); gtk_window_fullscreen(GTK_WINDOW(window)); viewport = gtk_viewport_new(NULL,NULL); table = gtk_table_new(3,8,0); white_board = gtk_drawing_area_new(); gtk_widget_set_size_request(white_board,768,576); draw_init_canvas(white_board); gtk_widget_modify_bg(white_board,GTK_STATE_NORMAL,misc_create_color(65535,65535,65535)); gtk_widget_add_events(white_board,GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_BUTTON_MOTION_MASK); gtk_container_add(GTK_CONTAINER(viewport),white_board); tool_table = gtk_table_new(1,8,1); clear_board = gtk_button_new(); gtk_container_add(GTK_CONTAINER(clear_board),gtk_image_new_from_file("pixmaps/clear.png")); freeh_tool = gtk_button_new(); gtk_container_add(GTK_CONTAINER(freeh_tool),gtk_image_new_from_file("pixmaps/freeh.png")); line_tool = gtk_button_new(); gtk_container_add(GTK_CONTAINER(line_tool),gtk_image_new_from_file("pixmaps/line.png")); rect_tool = gtk_button_new(); gtk_container_add(GTK_CONTAINER(rect_tool),gtk_image_new_from_file("pixmaps/square.png")); circ_tool = gtk_button_new(); gtk_container_add(GTK_CONTAINER(circ_tool),gtk_image_new_from_file("pixmaps/circle.png")); erase_tool = gtk_button_new(); gtk_container_add(GTK_CONTAINER(erase_tool),gtk_image_new_from_file("pixmaps/eraser.png")); exit_but = gtk_button_new_with_label("Exit"); /* Pack */ gtk_container_add(GTK_CONTAINER(window),table); gtk_table_attach(GTK_TABLE(table),misc_create_banner(data->caption,16000),0,3,0,1,GTK_FILL|GTK_EXPAND,0,0,0); gtk_table_attach(GTK_TABLE(table),viewport,0,1,1,8,0,0,0,0); gtk_table_attach(GTK_TABLE(table),tool_table,1,2,1,8,0,GTK_FILL,0,0); gtk_table_attach(GTK_TABLE(tool_table),clear_board,0,1,1,2,GTK_FILL,0,0,0); gtk_table_attach(GTK_TABLE(tool_table),freeh_tool,0,1,2,3,GTK_FILL,0,0,0); gtk_table_attach(GTK_TABLE(tool_table),line_tool,0,1,3,4,GTK_FILL,0,0,0); gtk_table_attach(GTK_TABLE(tool_table),rect_tool,0,1,4,5,GTK_FILL,0,0,0); gtk_table_attach(GTK_TABLE(tool_table),circ_tool,0,1,5,6,GTK_FILL,0,0,0); gtk_table_attach(GTK_TABLE(tool_table),erase_tool,0,1,6,7,GTK_FILL,0,0,0); gtk_table_attach(GTK_TABLE(tool_table),exit_but,0,1,7,8,GTK_FILL,0,0,0); /* Hook up callbacks */ g_signal_connect(G_OBJECT(window),"delete-event",G_CALLBACK(whiteb_window_delete),NULL); g_signal_connect(G_OBJECT(white_board),"button-press-event",G_CALLBACK(whiteb_board_press),NULL); g_signal_connect(G_OBJECT(white_board),"motion-notify-event",G_CALLBACK(whiteb_board_motion),NULL); g_signal_connect(G_OBJECT(white_board),"button-release-event",G_CALLBACK(whiteb_board_release),NULL); g_signal_connect(G_OBJECT(white_board),"expose-event",G_CALLBACK(whiteb_expose_event),data); g_signal_connect(G_OBJECT(clear_board),"clicked",G_CALLBACK(whiteb_clear),NULL); g_signal_connect(G_OBJECT(freeh_tool),"clicked",G_CALLBACK(whiteb_change_tool),(void*)WHITEB_FREEHAND); g_signal_connect(G_OBJECT(line_tool),"clicked",G_CALLBACK(whiteb_change_tool),(void*)WHITEB_LINE); g_signal_connect(G_OBJECT(rect_tool),"clicked",G_CALLBACK(whiteb_change_tool),(void*)WHITEB_RECT); g_signal_connect(G_OBJECT(circ_tool),"clicked",G_CALLBACK(whiteb_change_tool),(void*)WHITEB_CIRCLE); g_signal_connect(G_OBJECT(erase_tool),"clicked",G_CALLBACK(whiteb_change_tool),(void*)WHITEB_ERASER); g_signal_connect_swapped(G_OBJECT(exit_but),"clicked",G_CALLBACK(whiteb_window_delete),window); gtk_widget_show_all(window); }
static void thunar_sbr_replace_renamer_init (ThunarSbrReplaceRenamer *replace_renamer) { AtkRelationSet *relations; AtkRelation *relation; AtkObject *object; GtkWidget *table; GtkWidget *label; GtkWidget *entry; GtkWidget *button; #ifdef HAVE_PCRE /* check if PCRE supports UTF-8 */ if (pcre_config (PCRE_CONFIG_UTF8, &replace_renamer->regexp_supported) != 0) replace_renamer->regexp_supported = FALSE; #endif /* allocate the shared tooltips */ replace_renamer->tooltips = gtk_tooltips_new (); exo_gtk_object_ref_sink (GTK_OBJECT (replace_renamer->tooltips)); table = gtk_table_new (2, 3, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 12); gtk_box_pack_start (GTK_BOX (replace_renamer), table, FALSE, FALSE, 0); gtk_widget_show (table); label = gtk_label_new_with_mnemonic (_("_Search For:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, 0, 0, 0); gtk_widget_show (label); replace_renamer->pattern_entry = gtk_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (replace_renamer->pattern_entry), TRUE); exo_mutual_binding_new (G_OBJECT (replace_renamer->pattern_entry), "text", G_OBJECT (replace_renamer), "pattern"); gtk_tooltips_set_tip (replace_renamer->tooltips, replace_renamer->pattern_entry, _("Enter the text to search for in the file names."), NULL); gtk_table_attach (GTK_TABLE (table), replace_renamer->pattern_entry, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), replace_renamer->pattern_entry); gtk_widget_show (replace_renamer->pattern_entry); /* set Atk label relation for the entry */ object = gtk_widget_get_accessible (replace_renamer->pattern_entry); relations = atk_object_ref_relation_set (gtk_widget_get_accessible (label)); relation = atk_relation_new (&object, 1, ATK_RELATION_LABEL_FOR); atk_relation_set_add (relations, relation); g_object_unref (G_OBJECT (relation)); button = gtk_check_button_new_with_mnemonic (_("Regular _Expression")); exo_mutual_binding_new (G_OBJECT (button), "active", G_OBJECT (replace_renamer), "regexp"); gtk_tooltips_set_tip (replace_renamer->tooltips, button, _("If you enable this option, the pattern will be treated as a regular expression and " "matched using the Perl-compatible regular expressions (PCRE). Check the documentation " "for details about the regular expression syntax."), NULL); gtk_table_attach (GTK_TABLE (table), button, 2, 3, 0, 1, GTK_FILL, 0, 0, 0); gtk_widget_set_sensitive (button, replace_renamer->regexp_supported); gtk_widget_show (button); label = gtk_label_new_with_mnemonic (_("Replace _With:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, 0, 0, 0); gtk_widget_show (label); entry = gtk_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); exo_mutual_binding_new (G_OBJECT (entry), "text", G_OBJECT (replace_renamer), "replacement"); gtk_tooltips_set_tip (replace_renamer->tooltips, entry, _("Enter the text that should be used as replacement for the pattern above."), NULL); gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry); gtk_widget_show (entry); /* set Atk label relation for the entry */ object = gtk_widget_get_accessible (entry); relations = atk_object_ref_relation_set (gtk_widget_get_accessible (label)); relation = atk_relation_new (&object, 1, ATK_RELATION_LABEL_FOR); atk_relation_set_add (relations, relation); g_object_unref (G_OBJECT (relation)); button = gtk_check_button_new_with_mnemonic (_("C_ase Sensitive Search")); exo_mutual_binding_new (G_OBJECT (button), "active", G_OBJECT (replace_renamer), "case-sensitive"); gtk_tooltips_set_tip (replace_renamer->tooltips, button, _("If you enable this option, the pattern will be searched in a case-sensitive manner. " "The default is to use a case-insensitive search."), NULL); gtk_table_attach (GTK_TABLE (table), button, 2, 3, 1, 2, GTK_FILL, 0, 0, 0); gtk_widget_show (button); }
int main(int argc, char* argv[]) { GtkWidget* window; GtkWidget* vbox; GtkWidget* hbox; GtkWidget* button; GtkWidget* frame; gtk_init(&argc, &argv); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(KeyPress), NULL); //按键信号 gtk_window_set_title(GTK_WINDOW(window), "Snake Game"); gtk_window_set_resizable(GTK_WINDOW(window), FALSE); //禁止调整窗口大小 gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_container_set_border_width(GTK_CONTAINER(window), 5); //设置窗口边框厚度 //垂直排放 vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); //水平排放 hbox = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(vbox), hbox); //“单词”标签 frame = gtk_frame_new("单词"); word_label = gtk_label_new(" Eureka "); gtk_container_add(GTK_CONTAINER(frame), word_label); gtk_box_pack_start(GTK_BOX(hbox), frame, TRUE, TRUE, 5); //“单词序列”标签 frame = gtk_frame_new("单词序列"); seq_label = gtk_label_new(" E u r e k a "); gtk_container_add(GTK_CONTAINER(frame), seq_label); gtk_box_pack_start(GTK_BOX(hbox), frame, TRUE, TRUE, 3); /* //游戏LOGO GtkWidget *logo; pix = gdk_pixbuf_new_from_file("logo.png", NULL); logo = gtk_image_new_from_pixbuf(pix); gtk_box_pack_start(GTK_BOX(hbox), logo, FALSE, FALSE, 0); */ //水平排放 hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 5); //30*20表格容器 table = gtk_table_new(30, 20, FALSE); gtk_box_pack_start(GTK_BOX(hbox), table, TRUE, TRUE, 5); //垂直排放 vbox = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 3); //“开始”按钮 button = gtk_button_new_with_label("开始"); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(on_begin_clicked), NULL); //on_begin_clicked gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 3); //“退出”按钮 button = gtk_button_new_with_label("退出"); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(on_exit_clicked), NULL); //on_exit_clicked gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 3); //“等级”标签 frame = gtk_frame_new("等级"); level_label = gtk_label_new("\n1-1\n\n"); gtk_container_add(GTK_CONTAINER(frame), level_label); gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 3); //“时间”标签 frame = gtk_frame_new("时间"); time_label = gtk_label_new("\n19:31:51\n"); gtk_container_add(GTK_CONTAINER(frame), time_label); gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 3); Start(); gtk_widget_show_all(window); gtk_main(); return FALSE; }
static void gimp_hue_saturation_tool_dialog (GimpImageMapTool *image_map_tool) { GimpHueSaturationTool *hs_tool = GIMP_HUE_SATURATION_TOOL (image_map_tool); GimpHueSaturationConfig *config = hs_tool->config; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *abox; GtkWidget *table; GtkWidget *button; GtkWidget *frame; GtkWidget *hbox; GtkObject *data; GtkSizeGroup *label_group; GtkSizeGroup *spinner_group; GSList *group = NULL; gint i; const struct { const gchar *label; const gchar *tooltip; gint label_col; gint label_row; gint frame_col; gint frame_row; } hue_range_table[] = { { N_("M_aster"), N_("Adjust all colors"), 2, 3, 0, 0 }, { N_("_R"), N_("Red"), 2, 1, 2, 0 }, { N_("_Y"), N_("Yellow"), 1, 2, 0, 2 }, { N_("_G"), N_("Green"), 1, 4, 0, 4 }, { N_("_C"), N_("Cyan"), 2, 5, 2, 6 }, { N_("_B"), N_("Blue"), 3, 4, 4, 4 }, { N_("_M"), N_("Magenta"), 3, 2, 4, 2 } }; main_vbox = gimp_image_map_tool_dialog_get_vbox (image_map_tool); frame = gimp_frame_new (_("Select Primary Color to Adjust")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), abox, TRUE, TRUE, 0); gtk_widget_show (abox); /* The table containing hue ranges */ table = gtk_table_new (7, 5, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4); gtk_table_set_col_spacing (GTK_TABLE (table), 3, 4); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2); gtk_table_set_row_spacing (GTK_TABLE (table), 5, 2); gtk_container_add (GTK_CONTAINER (abox), table); /* the radio buttons for hue ranges */ for (i = 0; i < G_N_ELEMENTS (hue_range_table); i++) { button = gtk_radio_button_new_with_mnemonic (group, gettext (hue_range_table[i].label)); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (i)); gimp_help_set_help_data (button, gettext (hue_range_table[i].tooltip), NULL); if (i == 0) { gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE); hs_tool->range_radio = button; } gtk_table_attach (GTK_TABLE (table), button, hue_range_table[i].label_col, hue_range_table[i].label_col + 1, hue_range_table[i].label_row, hue_range_table[i].label_row + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); if (i > 0) { GimpRGB color = { 0.0 }; frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_table_attach (GTK_TABLE (table), frame, hue_range_table[i].frame_col, hue_range_table[i].frame_col + 1, hue_range_table[i].frame_row, hue_range_table[i].frame_row + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (frame); hs_tool->hue_range_color_area[i - 1] = gimp_color_area_new (&color, GIMP_COLOR_AREA_FLAT, 0); gtk_widget_set_size_request (hs_tool->hue_range_color_area[i - 1], DA_WIDTH, DA_HEIGHT); gtk_container_add (GTK_CONTAINER (frame), hs_tool->hue_range_color_area[i - 1]); gtk_widget_show (hs_tool->hue_range_color_area[i - 1]); } g_signal_connect (button, "toggled", G_CALLBACK (hue_saturation_range_callback), hs_tool); gtk_widget_show (button); } gtk_widget_show (table); label_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); spinner_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); /* Create the 'Overlap' option slider */ table = gtk_table_new (3, 1, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 4); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("_Overlap:"), SLIDER_WIDTH, -1, config->overlap * 100.0, 0.0, 100.0, 1.0, 15.0, 0, TRUE, 0.0, 0.0, NULL, NULL); hs_tool->overlap_data = GTK_ADJUSTMENT (data); gtk_size_group_add_widget (label_group, GIMP_SCALE_ENTRY_LABEL (data)); gtk_size_group_add_widget (spinner_group, GIMP_SCALE_ENTRY_SPINBUTTON (data)); g_object_unref (label_group); g_object_unref (spinner_group); g_signal_connect (data, "value-changed", G_CALLBACK (hue_saturation_overlap_changed), hs_tool); frame = gimp_frame_new (_("Adjust Selected Color")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); /* The table containing sliders */ vbox = gtk_vbox_new (FALSE, 4); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); table = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 4); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); /* Create the hue scale widget */ data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("_Hue:"), SLIDER_WIDTH, -1, config->hue[config->range] * 180.0, -180.0, 180.0, 1.0, 15.0, 0, TRUE, 0.0, 0.0, NULL, NULL); hs_tool->hue_data = GTK_ADJUSTMENT (data); gtk_size_group_add_widget (label_group, GIMP_SCALE_ENTRY_LABEL (data)); gtk_size_group_add_widget (spinner_group, GIMP_SCALE_ENTRY_SPINBUTTON (data)); g_signal_connect (data, "value-changed", G_CALLBACK (hue_saturation_hue_changed), hs_tool); /* Create the lightness scale widget */ data = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Lightness:"), SLIDER_WIDTH, -1, config->lightness[config->range] * 100.0, -100.0, 100.0, 1.0, 10.0, 0, TRUE, 0.0, 0.0, NULL, NULL); hs_tool->lightness_data = GTK_ADJUSTMENT (data); gtk_size_group_add_widget (label_group, GIMP_SCALE_ENTRY_LABEL (data)); gtk_size_group_add_widget (spinner_group, GIMP_SCALE_ENTRY_SPINBUTTON (data)); g_signal_connect (data, "value-changed", G_CALLBACK (hue_saturation_lightness_changed), hs_tool); /* Create the saturation scale widget */ data = gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("_Saturation:"), SLIDER_WIDTH, -1, config->saturation[config->range] * 100.0, -100.0, 100.0, 1.0, 10.0, 0, TRUE, 0.0, 0.0, NULL, NULL); hs_tool->saturation_data = GTK_ADJUSTMENT (data); gtk_size_group_add_widget (label_group, GIMP_SCALE_ENTRY_LABEL (data)); gtk_size_group_add_widget (spinner_group, GIMP_SCALE_ENTRY_SPINBUTTON (data)); g_signal_connect (hs_tool->saturation_data, "value-changed", G_CALLBACK (hue_saturation_saturation_changed), hs_tool); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); button = gtk_button_new_with_mnemonic (_("R_eset Color")); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (hue_saturation_range_reset_callback), hs_tool); gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (hs_tool->range_radio), config->range); hue_saturation_update_color_areas (hs_tool); }
int main(int argc,char *argv[]) { GtkWidget *window; GtkWidget *vbox; GtkWidget *table; GtkWidget *button; guint i,j,num; gchar *values[20]={"7","8","9", "4","5","6", "1","2","3", "0",".","=", "/","*","-","+", "Bksp","CE","Clear","+/-" }; gtk_init(&argc,&argv); //窗体设置 window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window),"计算器"); gtk_window_set_default_size(GTK_WINDOW(window),400,300); gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER); gtk_window_set_icon(GTK_WINDOW(window),create_pixbuf("calc.png")); gtk_container_set_border_width(GTK_CONTAINER(window),10); g_signal_connect(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit),NULL); vbox=gtk_vbox_new(FALSE,5); gtk_container_add(GTK_CONTAINER(window),vbox); table=gtk_table_new(6,4,TRUE); gtk_table_set_row_spacings(GTK_TABLE(table),10); gtk_table_set_col_spacings(GTK_TABLE(table),10); gtk_box_pack_start(GTK_BOX(vbox),table,TRUE,TRUE,0); entry=gtk_entry_new(); gtk_entry_set_alignment(GTK_ENTRY(entry),1); gtk_table_attach_defaults(GTK_TABLE(table),entry,0,4,0,1); //数字0-9和小数点按钮 num=0; for(j=2;j<6;j++) { for(i=0;i<3;i++) { button=gtk_button_new_with_label(values[num]); gtk_table_attach_defaults(GTK_TABLE(table),button,i,i+1,j,j+1); num++; g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(num_click),NULL); if(j==5 && i==1) i=3; } } //加、减、乘、除按钮 num=12; for(j=2,i=3;j<6;j++,i--) { button=gtk_button_new_with_label(values[num]); gtk_table_attach_defaults(GTK_TABLE(table),button,3,4,j,j+1); num++; g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(suan_click),NULL); } //等号按钮 button=gtk_button_new_with_label(values[11]); gtk_table_attach_defaults(GTK_TABLE(table),button,2,3,5,6); g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(deng_click),NULL); //Backspace按钮 button=gtk_button_new_with_label(values[16]); gtk_table_attach_defaults(GTK_TABLE(table),button,0,1,1,2); g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(backspace_click),NULL); //CE按钮 button=gtk_button_new_with_label(values[17]); gtk_table_attach_defaults(GTK_TABLE(table),button,1,2,1,2); g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(ce_click),NULL); //Clear按钮 button=gtk_button_new_with_label(values[18]); gtk_table_attach_defaults(GTK_TABLE(table),button,2,3,1,2); g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(clear_click),NULL); //+/-按钮 button=gtk_button_new_with_label(values[19]); gtk_table_attach_defaults(GTK_TABLE(table),button,3,4,1,2); g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(flag_click),NULL); frame=gtk_frame_new(""); gtk_box_pack_start(GTK_BOX(vbox),frame,TRUE,TRUE,0); label=gtk_label_new(""); gtk_label_set_markup(GTK_LABEL(label),title); gtk_container_add(GTK_CONTAINER(frame),label); gtk_widget_show_all(window); gtk_main(); }
static GtkWidget* gui_ext_flags(void) { GdkFont *font; GtkWidget *b_expire; GtkWidget *hbox1; GtkWidget *table1; GtkWidget *label1; GtkWidget *label3; GtkWidget *label6; hbox1 = gtk_hbox_new(FALSE, 0); gtk_widget_hide(hbox1); table1 = gtk_table_new(2, 4, FALSE); gtk_widget_show(table1); gtk_box_pack_start(GTK_BOX(hbox1), table1, FALSE, FALSE, 3); gtk_table_set_col_spacings(GTK_TABLE(table1), 4); gtk_table_set_row_spacings(GTK_TABLE(table1), 4); label1 = gtk_label_new(_("Created:")); font = gtk_widget_get_style(label1)->font; gtk_widget_show(label1); gtk_table_attach(GTK_TABLE(table1), label1, 0, 1, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_misc_set_alignment(GTK_MISC(label1), 1, 0.5); sp->tlabel_created = time_label_new(); time_label_set_format(TIME_LABEL(sp->tlabel_created), "%b %d %Y %X"); gtk_widget_show(sp->tlabel_created); gtk_table_attach(GTK_TABLE(table1), sp->tlabel_created, 1, 2, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_misc_set_alignment(GTK_MISC(sp->tlabel_created), 0, 0.5); label3 = gtk_label_new(_("Changed:")); gtk_widget_show(label3); gtk_table_attach(GTK_TABLE(table1), label3, 2, 3, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_misc_set_alignment(GTK_MISC(label3), 1, 0.5); sp->tlabel_changed = time_label_new(); time_label_set_format(TIME_LABEL(sp->tlabel_changed), "%b %d %Y %X"); gtk_widget_show(sp->tlabel_changed); gtk_table_attach(GTK_TABLE(table1), sp->tlabel_changed, 3, 4, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_misc_set_alignment(GTK_MISC(sp->tlabel_changed), 0, 0.5); label6 = gtk_label_new(_("Changes:")); gtk_widget_show(label6); gtk_table_attach(GTK_TABLE(table1), label6, 2, 3, 1, 2, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_misc_set_alignment(GTK_MISC(label6), 1, 0.5); sp->label_changes = gtk_label_new(""); gtk_widget_show(sp->label_changes); gtk_table_attach(GTK_TABLE(table1), sp->label_changes, 3, 4, 1, 2, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_misc_set_alignment(GTK_MISC(sp->label_changes), 0, 0.5); b_expire = gtk_button_new_with_label(_("Expires:")); gtk_widget_set_usize(b_expire, -1, gdk_string_height(font, "W") + 10); gtk_widget_show(b_expire); gtk_table_attach(GTK_TABLE(table1), b_expire, 0, 1, 1, 2, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); sp->tlabel_expire = time_label_new(); time_label_set_format(TIME_LABEL(sp->tlabel_expire), "%b %d %Y"); gtk_widget_show(sp->tlabel_expire); gtk_table_attach(GTK_TABLE(table1), sp->tlabel_expire, 1, 2, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_misc_set_alignment(GTK_MISC(sp->tlabel_expire), 0, 0.5); gtk_signal_connect(GTK_OBJECT(b_expire), "clicked", GTK_SIGNAL_FUNC(cb_open_date_sel), sp->tlabel_expire); return (hbox1); }
/** * @param ddisp The diagram display object that a window is created for * @param width Diagram widgth * @param height Diagram Height * @param title Window title * @param use_mbar Flag to indicate whether to add a menubar to the window */ void create_display_shell(DDisplay *ddisp, int width, int height, char *title, int use_mbar) { GtkWidget *table, *widget; GtkWidget *status_hbox; GtkWidget *root_vbox = NULL; GtkWidget *zoom_hbox, *zoom_label; int s_width, s_height; if (app_is_interactive() && is_integrated_ui()) { use_integrated_ui_for_display_shell(ddisp, title); return; } ddisp->is_standalone_window = TRUE; ddisp->container = NULL; s_width = gdk_screen_width (); s_height = gdk_screen_height (); if (width > s_width) width = s_width; if (height > s_height) height = s_height; /* The toplevel shell */ ddisp->shell = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (ddisp->shell), title); gtk_window_set_role (GTK_WINDOW (ddisp->shell), "diagram_window"); gtk_window_set_icon_name (GTK_WINDOW (ddisp->shell), "dia"); gtk_window_set_default_size(GTK_WINDOW (ddisp->shell), width, height); /* set_icon_name needs registered theme icons, not always available: provide fallback */ if (!gtk_window_get_icon (GTK_WINDOW (ddisp->shell))) { static GdkPixbuf *pixbuf = NULL; if (!pixbuf) pixbuf = gdk_pixbuf_new_from_inline(-1, dia_diagram_icon, FALSE, NULL); if (pixbuf) gtk_window_set_icon (GTK_WINDOW (ddisp->shell), pixbuf); } g_object_set_data (G_OBJECT (ddisp->shell), "user_data", (gpointer) ddisp); _ddisplay_setup_events (ddisp, ddisp->shell); /* following two not shared with integrated UI */ g_signal_connect (G_OBJECT (ddisp->shell), "delete_event", G_CALLBACK (ddisplay_delete), ddisp); g_signal_connect (G_OBJECT (ddisp->shell), "destroy", G_CALLBACK (ddisplay_destroy), ddisp); /* the table containing all widgets */ table = gtk_table_new (4, 3, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table), 0, 1); gtk_table_set_col_spacing (GTK_TABLE (table), 1, 2); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 1); gtk_table_set_row_spacing (GTK_TABLE (table), 1, 2); gtk_container_set_border_width (GTK_CONTAINER (table), 2); if (use_mbar) { root_vbox = gtk_vbox_new (FALSE, 1); gtk_container_add (GTK_CONTAINER (ddisp->shell), root_vbox); gtk_box_pack_end (GTK_BOX (root_vbox), table, TRUE, TRUE, 0); } else { gtk_container_add (GTK_CONTAINER (ddisp->shell), table); } /* scrollbars, rulers, canvas, menu popup button */ if (!use_mbar) { ddisp->origin = gtk_button_new(); #if GTK_CHECK_VERSION(2,18,0) gtk_widget_set_can_focus (ddisp->origin, FALSE); #else GTK_WIDGET_UNSET_FLAGS(ddisp->origin, GTK_CAN_FOCUS); #endif widget = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_OUT); gtk_container_add(GTK_CONTAINER(ddisp->origin), widget); gtk_widget_set_tooltip_text(widget, _("Diagram menu.")); gtk_widget_show(widget); g_signal_connect(G_OBJECT(ddisp->origin), "button_press_event", G_CALLBACK(origin_button_press), ddisp); } else { ddisp->origin = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (ddisp->origin), GTK_SHADOW_OUT); } _ddisplay_setup_rulers (ddisp, ddisp->shell, table); _ddisplay_setup_scrollbars (ddisp, table, width, height); _ddisplay_setup_navigation (ddisp, table, FALSE); ddisp->canvas = create_canvas (ddisp); /* pack all remaining widgets */ gtk_table_attach (GTK_TABLE (table), ddisp->origin, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table), ddisp->canvas, 1, 2, 1, 2, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); /* TODO rob use per window accel */ ddisp->accel_group = menus_get_display_accels (); gtk_window_add_accel_group(GTK_WINDOW(ddisp->shell), ddisp->accel_group); if (use_mbar) { ddisp->menu_bar = menus_create_display_menubar (&ddisp->ui_manager, &ddisp->actions); g_assert (ddisp->menu_bar); gtk_box_pack_start (GTK_BOX (root_vbox), ddisp->menu_bar, FALSE, TRUE, 0); } /* the statusbars */ status_hbox = gtk_hbox_new (FALSE, 2); /* Zoom status pseudo-optionmenu */ ddisp->zoom_status = create_zoom_widget(ddisp); zoom_hbox = gtk_hbox_new(FALSE, 0); zoom_label = gtk_label_new(_("Zoom")); gtk_box_pack_start (GTK_BOX(zoom_hbox), zoom_label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(zoom_hbox), ddisp->zoom_status, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (status_hbox), zoom_hbox, FALSE, FALSE, 0); /* Grid on/off button */ ddisp->grid_status = dia_toggle_button_new_with_icons(dia_on_grid_icon, dia_off_grid_icon); g_signal_connect(G_OBJECT(ddisp->grid_status), "toggled", G_CALLBACK (grid_toggle_snap), ddisp); gtk_widget_set_tooltip_text(ddisp->grid_status, _("Toggles snap-to-grid for this window.")); gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->grid_status, FALSE, FALSE, 0); ddisp->mainpoint_status = dia_toggle_button_new_with_icons(dia_mainpoints_on_icon, dia_mainpoints_off_icon); g_signal_connect(G_OBJECT(ddisp->mainpoint_status), "toggled", G_CALLBACK (interface_toggle_mainpoint_magnetism), ddisp); gtk_widget_set_tooltip_text(ddisp->mainpoint_status, _("Toggles object snapping for this window.")); gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->mainpoint_status, FALSE, FALSE, 0); /* Statusbar */ ddisp->modified_status = gtk_statusbar_new (); gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->modified_status, TRUE, TRUE, 0); gtk_table_attach (GTK_TABLE (table), status_hbox, 0, 3, 3, 4, GTK_FILL, GTK_FILL, 0, 0); display_rulers_show (ddisp); gtk_widget_show (ddisp->zoom_status); gtk_widget_show (zoom_hbox); gtk_widget_show (zoom_label); gtk_widget_show (ddisp->grid_status); gtk_widget_show (ddisp->mainpoint_status); gtk_widget_show (ddisp->modified_status); gtk_widget_show (status_hbox); gtk_widget_show (table); if (use_mbar) { gtk_widget_show (ddisp->menu_bar); gtk_widget_show (root_vbox); } gtk_widget_show (ddisp->shell); /* before showing up, checking canvas's REAL size */ if (use_mbar && ddisp->hrule->allocation.width > width) { /* The menubar is not shrinkable, so the shell will have at least * the menubar's width. If the diagram's requested width is smaller, * the canvas will be enlarged to fit the place. In this case, we * need to adjust the horizontal scrollbar according to the size * that will be allocated, which the same as the hrule got. */ width = ddisp->hrule->allocation.width; gtk_adjustment_set_upper (ddisp->hsbdata, width); gtk_adjustment_set_page_increment (ddisp->hsbdata, (width - 1) / 4); gtk_adjustment_set_page_size (ddisp->hsbdata, width - 1); gtk_adjustment_changed (GTK_ADJUSTMENT(ddisp->hsbdata)); } gtk_widget_show (ddisp->canvas); /* set the focus to the canvas area */ gtk_widget_grab_focus (ddisp->canvas); }
GtkWidget* build_gui ( void ) { GtkWidget *window1; GtkWidget *vbox1; GtkWidget *vbox2; GtkWidget *table1; GtkWidget *label1; GtkWidget *label2; GtkWidget *label3; GtkWidget *label4; GtkWidget *radiobutton1; GSList *radiobutton1_group = NULL; GtkWidget *radiobutton2; GtkWidget *entry1; window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window1), "tracking antenna"); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (window1), vbox1); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0); table1 = gtk_table_new (4, 3, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (vbox2), table1, TRUE, TRUE, 0); gtk_table_set_col_spacings (GTK_TABLE (table1), 5); label1 = gtk_label_new ("Azimuth"); gtk_widget_show (label1); gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5); label2 = gtk_label_new ("Elevation"); gtk_widget_show (label2); gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); label3 = gtk_label_new ("Id"); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5); label4 = gtk_label_new ("mode"); gtk_widget_show (label4); gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5); radiobutton1 = gtk_radio_button_new_with_mnemonic (NULL, "manual"); gtk_widget_show (radiobutton1); gtk_table_attach (GTK_TABLE (table1), radiobutton1, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton1), radiobutton1_group); radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton1)); radiobutton2 = gtk_radio_button_new_with_mnemonic (NULL, "tracking"); gtk_widget_show (radiobutton2); gtk_table_attach (GTK_TABLE (table1), radiobutton2, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton2), radiobutton1_group); radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton2)); azim_scale = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (144.7, 0, 360, 1, 1, 1))); gtk_widget_show (azim_scale); gtk_table_attach (GTK_TABLE (table1), azim_scale, 1, 3, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_range_set_update_policy (GTK_RANGE (azim_scale), GTK_UPDATE_DELAYED); elev_scale = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (32.3, 0, 90, 1, 1, 1))); gtk_widget_show (elev_scale); gtk_table_attach (GTK_TABLE (table1), elev_scale, 1, 3, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); entry1 = gtk_entry_new (); gtk_widget_show (entry1); gtk_table_attach (GTK_TABLE (table1), entry1, 1, 3, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect ((gpointer) radiobutton1, "toggled", G_CALLBACK (on_mode_changed), NULL); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (window1, window1, "window1"); GLADE_HOOKUP_OBJECT (window1, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (window1, vbox2, "vbox2"); GLADE_HOOKUP_OBJECT (window1, table1, "table1"); GLADE_HOOKUP_OBJECT (window1, label1, "label1"); GLADE_HOOKUP_OBJECT (window1, label2, "label2"); GLADE_HOOKUP_OBJECT (window1, label3, "label3"); GLADE_HOOKUP_OBJECT (window1, label4, "label4"); GLADE_HOOKUP_OBJECT (window1, radiobutton1, "radiobutton1"); GLADE_HOOKUP_OBJECT (window1, radiobutton2, "radiobutton2"); GLADE_HOOKUP_OBJECT (window1, entry1, "entry1"); return window1; }
GtkWidget * gimp_proc_view_new (const gchar *name, const gchar *menu_path, const gchar *blurb, const gchar *help, const gchar *author, const gchar *copyright, const gchar *date, GimpPDBProcType type, gint n_params, gint n_return_vals, GimpParamDef *params, GimpParamDef *return_vals) { GtkWidget *main_vbox; GtkWidget *frame; GtkWidget *vbox; GtkWidget *table; GtkWidget *label; GtkSizeGroup *name_group; GtkSizeGroup *type_group; GtkSizeGroup *desc_group; const gchar *type_str; gint row; if (blurb && strlen (blurb) < 2) blurb = NULL; if (help && strlen (help) < 2) help = NULL; if (author && strlen (author) < 2) author = NULL; if (date && strlen (date) < 2) date = NULL; if (copyright && strlen (copyright) < 2) copyright = NULL; if (blurb && help && ! strcmp (blurb, help)) help = NULL; main_vbox = gtk_vbox_new (FALSE, 12); /* show the name */ frame = gimp_frame_new (name); label = gtk_frame_get_label_widget (GTK_FRAME (frame)); gtk_label_set_selectable (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 8); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); if (! gimp_enum_get_value (GIMP_TYPE_PDB_PROC_TYPE, type, NULL, NULL, &type_str, NULL)) type_str = "UNKNOWN"; label = gtk_label_new (type_str); gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, -1); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); if (menu_path) { label = gtk_label_new_with_mnemonic (menu_path); gtk_label_set_selectable (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); } if (blurb) { label = gtk_label_new (blurb); gtk_label_set_selectable (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); } name_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); type_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); desc_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); /* in parameters */ if (n_params) { frame = gimp_frame_new (_("Parameters")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gimp_proc_view_create_params (params, n_params, name_group, type_group, desc_group); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); } /* out parameters */ if (n_return_vals) { frame = gimp_frame_new (_("Return Values")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gimp_proc_view_create_params (return_vals, n_return_vals, name_group, type_group, desc_group); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); } if (! help && ! author && ! date && ! copyright) return main_vbox; frame = gimp_frame_new (_("Additional Information")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 8); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); /* show the help */ if (help) { label = gtk_label_new (help); gtk_label_set_selectable (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); } /* show the author & the copyright */ if (! author && ! date && ! copyright) return main_vbox; table = gtk_table_new ((author != 0) + (date != 0) + (copyright != 0), 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 4); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); row = 0; if (author) { label = gtk_label_new (author); gtk_label_set_selectable (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gimp_table_attach_aligned (GTK_TABLE (table), 0, row++, _("Author:"), 0.0, 0.0, label, 3, FALSE); } if (date) { label = gtk_label_new (date); gtk_label_set_selectable (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gimp_table_attach_aligned (GTK_TABLE (table), 0, row++, _("Date:"), 0.0, 0.0, label, 3, FALSE); } if (copyright) { label = gtk_label_new (copyright); gtk_label_set_selectable (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gimp_table_attach_aligned (GTK_TABLE (table), 0, row++, _("Copyright:"), 0.0, 0.0, label, 3, FALSE); } return main_vbox; }
/** * gimp_display_shell_scale_dialog: * @shell: the #GimpDisplayShell * * Constructs and displays a dialog allowing the user to enter a * custom display scale. **/ void gimp_display_shell_scale_dialog (GimpDisplayShell *shell) { ScaleDialogData *data; GimpImage *image; GtkWidget *toplevel; GtkWidget *hbox; GtkWidget *table; GtkWidget *spin; GtkWidget *label; gint num, denom, row; g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell)); if (shell->scale_dialog) { gtk_window_present (GTK_WINDOW (shell->scale_dialog)); return; } if (SCALE_EQUALS (shell->other_scale, 0.0)) { /* other_scale not yet initialized */ shell->other_scale = gimp_zoom_model_get_factor (shell->zoom); } image = gimp_display_get_image (shell->display); data = g_slice_new (ScaleDialogData); data->shell = shell; data->model = g_object_new (GIMP_TYPE_ZOOM_MODEL, "value", fabs (shell->other_scale), NULL); shell->scale_dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (image), gimp_get_user_context (shell->display->gimp), _("Zoom Ratio"), "display_scale", GTK_STOCK_ZOOM_100, _("Select Zoom Ratio"), GTK_WIDGET (shell), gimp_standard_help_func, GIMP_HELP_VIEW_ZOOM_OTHER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (shell->scale_dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_object_weak_ref (G_OBJECT (shell->scale_dialog), (GWeakNotify) gimp_display_shell_scale_dialog_free, data); g_object_weak_ref (G_OBJECT (shell->scale_dialog), (GWeakNotify) g_object_unref, data->model); g_object_add_weak_pointer (G_OBJECT (shell->scale_dialog), (gpointer) &shell->scale_dialog); toplevel = gtk_widget_get_toplevel (GTK_WIDGET (shell)); gtk_window_set_transient_for (GTK_WINDOW (shell->scale_dialog), GTK_WINDOW (toplevel)); gtk_window_set_destroy_with_parent (GTK_WINDOW (shell->scale_dialog), TRUE); g_signal_connect (shell->scale_dialog, "response", G_CALLBACK (gimp_display_shell_scale_dialog_response), data); table = gtk_table_new (2, 2, FALSE); gtk_container_set_border_width (GTK_CONTAINER (table), 12); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (shell->scale_dialog))), table, TRUE, TRUE, 0); gtk_widget_show (table); row = 0; hbox = gtk_hbox_new (FALSE, 6); gimp_table_attach_aligned (GTK_TABLE (table), 0, row++, _("Zoom ratio:"), 0.0, 0.5, hbox, 1, FALSE); gimp_zoom_model_get_fraction (data->model, &num, &denom); spin = gimp_spin_button_new ((GtkObject **) &data->num_adj, num, 1, 256, 1, 8, 0, 1, 0); gtk_entry_set_activates_default (GTK_ENTRY (spin), TRUE); gtk_box_pack_start (GTK_BOX (hbox), spin, TRUE, TRUE, 0); gtk_widget_show (spin); label = gtk_label_new (":"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); spin = gimp_spin_button_new ((GtkObject **) &data->denom_adj, denom, 1, 256, 1, 8, 0, 1, 0); gtk_entry_set_activates_default (GTK_ENTRY (spin), TRUE); gtk_box_pack_start (GTK_BOX (hbox), spin, TRUE, TRUE, 0); gtk_widget_show (spin); hbox = gtk_hbox_new (FALSE, 6); gimp_table_attach_aligned (GTK_TABLE (table), 0, row++, _("Zoom:"), 0.0, 0.5, hbox, 1, FALSE); spin = gimp_spin_button_new ((GtkObject **) &data->scale_adj, fabs (shell->other_scale) * 100, 100.0 / 256.0, 25600.0, 10, 50, 0, 1, 2); gtk_entry_set_activates_default (GTK_ENTRY (spin), TRUE); gtk_box_pack_start (GTK_BOX (hbox), spin, TRUE, TRUE, 0); gtk_widget_show (spin); label = gtk_label_new ("%"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_signal_connect (data->scale_adj, "value-changed", G_CALLBACK (update_zoom_values), data); g_signal_connect (data->num_adj, "value-changed", G_CALLBACK (update_zoom_values), data); g_signal_connect (data->denom_adj, "value-changed", G_CALLBACK (update_zoom_values), data); gtk_widget_show (shell->scale_dialog); }
void ags_matrix_init(AgsMatrix *matrix) { GtkFrame *frame; GtkTable *table; GtkToggleButton *button; GtkVScrollbar *vscrollbar; AgsLed *led; GtkVBox *vbox; GtkHBox *hbox; AgsAudio *audio; GList *list; int i, j; g_signal_connect_after((GObject *) matrix, "parent_set\0", G_CALLBACK(ags_matrix_parent_set_callback), (gpointer) matrix); audio = AGS_MACHINE(matrix)->audio; audio->flags |= (AGS_AUDIO_OUTPUT_HAS_RECYCLING | AGS_AUDIO_INPUT_HAS_RECYCLING | AGS_AUDIO_SYNC | AGS_AUDIO_ASYNC | AGS_AUDIO_NOTATION_DEFAULT | AGS_AUDIO_HAS_NOTATION); // audio->audio_channels = 1; AGS_MACHINE(matrix)->input_pad_type = G_TYPE_NONE; AGS_MACHINE(matrix)->input_line_type = G_TYPE_NONE; AGS_MACHINE(matrix)->output_pad_type = G_TYPE_NONE; AGS_MACHINE(matrix)->output_line_type = G_TYPE_NONE; g_signal_connect_after(G_OBJECT(AGS_MACHINE(matrix)->audio), "set_audio_channels\0", G_CALLBACK(ags_matrix_set_audio_channels), NULL); g_signal_connect_after(G_OBJECT(AGS_MACHINE(matrix)->audio), "set_pads\0", G_CALLBACK(ags_matrix_set_pads), NULL); /* */ //TODO:JK: uncomment me AGS_MACHINE(matrix)->flags |= AGS_MACHINE_IS_SEQUENCER; matrix->flags = 0; matrix->name = NULL; matrix->xml_type = "ags-matrix\0"; matrix->mapped_input_pad = 0; matrix->mapped_output_pad = 0; /* create widgets */ frame = (GtkFrame *) (gtk_bin_get_child((GtkBin *) matrix)); matrix->table = (GtkTable *) gtk_table_new(4, 4, FALSE); gtk_container_add((GtkContainer *) frame, (GtkWidget *) matrix->table); AGS_MACHINE(matrix)->play = matrix->run = (GtkToggleButton *) gtk_toggle_button_new_with_label("run\0"); gtk_table_attach(matrix->table, (GtkWidget *) matrix->run, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); table = (GtkTable *) gtk_table_new(3, 3, FALSE); gtk_table_attach(matrix->table, (GtkWidget *) table, 1, 2, 0, 2, GTK_FILL, GTK_FILL, 0, 0); matrix->selected = NULL; for(i = 0; i < 3; i++){ for(j = 0; j < 3; j++){ //TODO:JK: verify leak of string matrix->index[i * 3 + j] = button = (GtkToggleButton *) gtk_toggle_button_new_with_label(g_strdup_printf("%d\0", i * 3 + j +1)); g_object_set_data((GObject *) button, AGS_MATRIX_INDEX, GUINT_TO_POINTER(i * 3 + j)); gtk_table_attach(table, (GtkWidget *) button, j, j +1, i, i +1, GTK_FILL, GTK_FILL, 0, 0); } } matrix->selected = matrix->index[0]; gtk_toggle_button_set_active(matrix->selected, TRUE); /* sequencer */ table = (GtkTable *) gtk_table_new(2, 2, FALSE); gtk_table_attach(matrix->table, (GtkWidget *) table, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0); matrix->drawing_area = (GtkDrawingArea *) gtk_drawing_area_new(); gtk_widget_set_size_request((GtkWidget *) matrix->drawing_area, 32 * AGS_MATRIX_CELL_WIDTH +1, AGS_MATRIX_OCTAVE * AGS_MATRIX_CELL_HEIGHT +1); gtk_widget_set_style((GtkWidget *) matrix->drawing_area, matrix_style); gtk_table_attach(table, (GtkWidget *) matrix->drawing_area, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_set_events ((GtkWidget *) matrix->drawing_area, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK); matrix->adjustment = (GtkAdjustment *) gtk_adjustment_new(0.0, 0.0, 77.0, 1.0, 1.0, (gdouble) AGS_MATRIX_OCTAVE); vscrollbar = (GtkVScrollbar *) gtk_vscrollbar_new(matrix->adjustment); gtk_widget_set_style((GtkWidget *) vscrollbar, matrix_style); gtk_table_attach(table, (GtkWidget *) vscrollbar, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0); /* led */ matrix->active_led = 0; matrix->led = hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0); gtk_table_attach(matrix->table, (GtkWidget *) hbox, 2, 3, 1, 2, GTK_FILL, GTK_FILL, 0, 0); for(i = 0; i < 32; i++){ led = ags_led_new(); gtk_widget_set_size_request((GtkWidget *) led, AGS_MATRIX_CELL_WIDTH, AGS_MATRIX_CELL_WIDTH / 2); gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) led, FALSE, FALSE, 0); } /* */ vbox = (GtkVBox *) gtk_vbox_new(FALSE, 0); gtk_table_attach(matrix->table, (GtkWidget *) vbox, 3, 4, 0, 1, GTK_FILL, GTK_FILL, 0, 0); hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0); gtk_box_pack_start((GtkBox *) vbox, (GtkWidget *) hbox, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox *) hbox, gtk_label_new("length\0"), FALSE, FALSE, 0); matrix->length_spin = (GtkSpinButton *) gtk_spin_button_new_with_range(1.0, 32.0, 1.0); matrix->length_spin->adjustment->value = 16.0; gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) matrix->length_spin, FALSE, FALSE, 0); matrix->loop_button = (GtkCheckButton *) gtk_check_button_new_with_label("loop\0"); gtk_box_pack_start((GtkBox *) vbox, (GtkWidget *) matrix->loop_button, FALSE, FALSE, 0); /* effect bridge */ AGS_MACHINE(matrix)->bridge = ags_matrix_bridge_new(audio); gtk_table_attach(matrix->table, (GtkWidget *) AGS_MACHINE(matrix)->bridge, 0, 4, 2, 3, GTK_FILL, GTK_FILL, 0, 0); }
/* * display the statistics windows */ void gtkui_show_stats(void) { GtkWidget *table, *label; DEBUG_MSG("gtkui_show_stats"); /* if the object already exist, set the focus to it */ if (stats_window) { /* show stats window */ if(GTK_IS_WINDOW (stats_window)) gtk_window_present(GTK_WINDOW (stats_window)); else gtkui_page_present(stats_window); return; } stats_window = gtkui_page_new("Statistics", >kui_stop_stats, >kui_stats_detach); /* alright, this is a lot of code but it'll keep everything lined up nicely */ /* if you need to add a row, don't forget to increase the number in gtk_table_new */ table = gtk_table_new(12, 2, FALSE); /* rows, cols, size */ gtk_table_set_col_spacings(GTK_TABLE (table), 10); gtk_container_add(GTK_CONTAINER (stats_window), table); packets_recv = gtk_label_new(" "); gtk_label_set_selectable(GTK_LABEL (packets_recv), TRUE); gtk_misc_set_alignment(GTK_MISC (packets_recv), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), packets_recv, 1, 2, 0, 1); label = gtk_label_new( "Received packets:"); gtk_label_set_selectable(GTK_LABEL (label), TRUE); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1); packets_drop = gtk_label_new(" "); gtk_label_set_selectable(GTK_LABEL (packets_drop), TRUE); gtk_misc_set_alignment(GTK_MISC (packets_drop), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), packets_drop, 1, 2, 1, 2); label = gtk_label_new("Dropped packets:"); gtk_label_set_selectable(GTK_LABEL (label), TRUE); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2); packets_forw = gtk_label_new(" 0 bytes: 0 "); gtk_label_set_selectable(GTK_LABEL (packets_forw), TRUE); gtk_misc_set_alignment(GTK_MISC (packets_forw), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), packets_forw, 1, 2, 2, 3); label = gtk_label_new("Forwarded packets:"); gtk_label_set_selectable(GTK_LABEL (label), TRUE); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 2, 3); queue_len = gtk_label_new("0/0 "); gtk_label_set_selectable(GTK_LABEL (queue_len), TRUE); gtk_misc_set_alignment(GTK_MISC (queue_len), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), queue_len, 1, 2, 3, 4); label = gtk_label_new("Current queue length:"); gtk_label_set_selectable(GTK_LABEL (label), TRUE); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4); sample_rate = gtk_label_new("0 "); gtk_label_set_selectable(GTK_LABEL (sample_rate), TRUE); gtk_misc_set_alignment(GTK_MISC (sample_rate), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), sample_rate, 1, 2, 4, 5); label = gtk_label_new("Sampling rate:"); gtk_label_set_selectable(GTK_LABEL (label), TRUE); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 4, 5); recv_bottom = gtk_label_new("pck: 0 bytes: 0"); gtk_label_set_selectable(GTK_LABEL (recv_bottom), TRUE); gtk_misc_set_alignment(GTK_MISC (recv_bottom), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), recv_bottom, 1, 2, 5, 6); label = gtk_label_new("Bottom Half received packet:"); gtk_label_set_selectable(GTK_LABEL (label), TRUE); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 5, 6); recv_top = gtk_label_new("pck: 0 bytes: 0"); gtk_label_set_selectable(GTK_LABEL (recv_top), TRUE); gtk_misc_set_alignment(GTK_MISC (recv_top), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), recv_top, 1, 2, 6, 7); label = gtk_label_new("Top Half received packet:"); gtk_label_set_selectable(GTK_LABEL (label), TRUE); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 6, 7); interesting = gtk_label_new("0.00 %"); gtk_label_set_selectable(GTK_LABEL (interesting), TRUE); gtk_misc_set_alignment(GTK_MISC (interesting), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), interesting, 1, 2, 7, 8); label = gtk_label_new("Interesting packets:"); gtk_label_set_selectable(GTK_LABEL (label), TRUE); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 7, 8); rate_bottom = gtk_label_new("worst: 0 adv: 0 b/s"); gtk_label_set_selectable(GTK_LABEL (rate_bottom), TRUE); gtk_misc_set_alignment(GTK_MISC (rate_bottom), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), rate_bottom, 1, 2, 8, 9); label = gtk_label_new("Bottom Half packet rate:"); gtk_label_set_selectable(GTK_LABEL (label), TRUE); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 8, 9); rate_top = gtk_label_new("worst: 0 adv: 0 b/s"); gtk_label_set_selectable(GTK_LABEL (rate_top), TRUE); gtk_misc_set_alignment(GTK_MISC (rate_top), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), rate_top, 1, 2, 9, 10); label = gtk_label_new("Top Half packet rate:"); gtk_label_set_selectable(GTK_LABEL (label), TRUE); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 9, 10); through_bottom = gtk_label_new("worst: 0 adv: 0 b/s"); gtk_label_set_selectable(GTK_LABEL (through_bottom), TRUE); gtk_misc_set_alignment(GTK_MISC (through_bottom), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), through_bottom, 1, 2, 10, 11); label = gtk_label_new("Bottom Half throughput:"); gtk_label_set_selectable(GTK_LABEL (label), TRUE); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 10, 11); through_top = gtk_label_new("worst: 0 adv: 0 b/s"); gtk_label_set_selectable(GTK_LABEL (through_top), TRUE); gtk_misc_set_alignment(GTK_MISC (through_top), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), through_top, 1, 2, 11, 12); label = gtk_label_new("Top Half throughput:"); gtk_label_set_selectable(GTK_LABEL (label), TRUE); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 11, 12); gtk_widget_show_all(table); gtk_widget_show(stats_window); /* display the stats */ refresh_stats(NULL); /* refresh the stats window every 200 ms */ /* GTK has a gtk_idle_add also but it calls too much and uses 100% cpu */ stats_idle = gtk_timeout_add(200, refresh_stats, NULL); }