void Human (GtkWidget *humwidget, gpointer humdata) { if ((ifilestuff == 0) && ((biscomputer == 0) || (wiscomputer == 0)) && (iyesno == 0)) { ichangecolorh = (int) humdata; humwindow = gtk_window_new (GTK_WINDOW_TOPLEVEL); if (ichangecolorh == 1) { gtk_window_set_title (GTK_WINDOW (humwindow), "change white"); } else { gtk_window_set_title (GTK_WINDOW (humwindow), "change black"); } gtk_signal_connect (GTK_OBJECT (humwindow), "delete_event", GTK_SIGNAL_FUNC (DestroyHuman), NULL); gtk_window_set_policy (GTK_WINDOW (humwindow), 0, 0, 1); gtk_container_border_width (GTK_CONTAINER (humwindow), 0); gtk_widget_realize (humwindow); humbox1 = gtk_vbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (humbox1), 0); gtk_container_add (GTK_CONTAINER (humwindow), humbox1); gtk_widget_show (humbox1); humbox2 = gtk_hbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (humbox2), 0); gtk_box_pack_start (GTK_BOX (humbox1), humbox2, FALSE, FALSE, 0); gtk_widget_show (humbox2); humtable1 = gtk_table_new (1, 3, FALSE); gtk_box_pack_start (GTK_BOX (humbox2), humtable1, TRUE, TRUE, 0); gtk_widget_show (humtable1); humentry = gtk_entry_new_with_max_length (50); gtk_signal_connect (GTK_OBJECT (humentry), "activate", GTK_SIGNAL_FUNC (ActivateHuman), NULL); if ((ichangecolorh == 1) && (wiscomputer == 0)) { gtk_entry_set_text (GTK_ENTRY (humentry), wplayername); gtk_entry_select_region (GTK_ENTRY (humentry), 0, GTK_ENTRY (humentry)->text_length); } if ((ichangecolorh == 2) && (biscomputer == 0)) { gtk_entry_set_text (GTK_ENTRY (humentry), bplayername); gtk_entry_select_region (GTK_ENTRY (humentry), 0, GTK_ENTRY (humentry)->text_length); } gtk_table_attach (GTK_TABLE (humtable1), humentry, 0, 1, 0, 1, GTK_EXPAND, GTK_EXPAND, 10, 10); gtk_widget_grab_focus (humentry); gtk_widget_show (humentry); humsep = gtk_hseparator_new (); gtk_table_attach (GTK_TABLE (humtable1), humsep, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (humsep); #ifdef USE_GNOME humbutton = gnome_stock_button (GNOME_STOCK_BUTTON_OK); #else humbutton = gtk_button_new_with_label ("OK"); #endif gtk_signal_connect (GTK_OBJECT (humbutton), "clicked", GTK_SIGNAL_FUNC (ActivateHuman), NULL); GTK_WIDGET_SET_FLAGS (humbutton, GTK_CAN_DEFAULT); gtk_window_set_default (GTK_WINDOW (humwindow), humbutton); gtk_table_attach (GTK_TABLE (humtable1), humbutton, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 2, 2); gtk_widget_show (humbutton); gtk_widget_show (humwindow); iyesno = 1; } }
int fe_dcc_open_recv_win (int passive) { GtkWidget *radio, *table, *vbox, *bbox, *view, *exp, *detailbox; GtkListStore *store; GSList *group; if (dccfwin.window) { if (!passive) mg_bring_tofront (dccfwin.window); return TRUE; } dccfwin.window = mg_create_generic_tab ("Transfers", _(DISPLAY_NAME": Uploads and Downloads"), FALSE, TRUE, close_dcc_file_window, NULL, win_width, win_height, &vbox, 0); gtkutil_destroy_on_esc (dccfwin.window); gtk_container_set_border_width (GTK_CONTAINER (dccfwin.window), 3); gtk_box_set_spacing (GTK_BOX (vbox), 3); store = gtk_list_store_new (N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, GDK_TYPE_COLOR); view = gtkutil_treeview_new (vbox, GTK_TREE_MODEL (store), NULL, -1); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE); /* Up/Down Icon column */ gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), -1, NULL, gtk_cell_renderer_pixbuf_new (), "pixbuf", COL_TYPE, NULL); dcc_add_column (view, COL_STATUS, COL_COLOR, _("Status"), FALSE); dcc_add_column (view, COL_FILE, COL_COLOR, _("File"), FALSE); dcc_add_column (view, COL_SIZE, COL_COLOR, _("Size"), TRUE); dcc_add_column (view, COL_POS, COL_COLOR, _("Position"), TRUE); dcc_add_column (view, COL_PERC, COL_COLOR, "%", TRUE); dcc_add_column (view, COL_SPEED, COL_COLOR, "KB/s", TRUE); dcc_add_column (view, COL_ETA, COL_COLOR, _("ETA"), FALSE); dcc_add_column (view, COL_NICK, COL_COLOR, _("Nick"), FALSE); gtk_tree_view_column_set_expand (gtk_tree_view_get_column (GTK_TREE_VIEW (view), COL_FILE), TRUE); gtk_tree_view_column_set_expand (gtk_tree_view_get_column (GTK_TREE_VIEW (view), COL_NICK), TRUE); dccfwin.list = view; dccfwin.store = store; dccfwin.sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view)); view_mode = VIEW_BOTH; gtk_tree_selection_set_mode (dccfwin.sel, GTK_SELECTION_MULTIPLE); if (!prefs.hex_gui_tab_utils) g_signal_connect (G_OBJECT (dccfwin.window), "configure_event", G_CALLBACK (dcc_configure_cb), 0); g_signal_connect (G_OBJECT (dccfwin.sel), "changed", G_CALLBACK (dcc_row_cb), NULL); /* double click */ g_signal_connect (G_OBJECT (view), "row-activated", G_CALLBACK (dcc_dclick_cb), NULL); table = gtk_table_new (1, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 16); gtk_box_pack_start (GTK_BOX (vbox), table, 0, 0, 0); radio = gtk_radio_button_new_with_mnemonic (NULL, _("Both")); g_signal_connect (G_OBJECT (radio), "toggled", G_CALLBACK (dcc_toggle), GINT_TO_POINTER (VIEW_BOTH)); gtk_table_attach (GTK_TABLE (table), radio, 3, 4, 0, 1, GTK_FILL, GTK_FILL, 0, 0); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)); radio = gtk_radio_button_new_with_mnemonic (group, _("Uploads")); g_signal_connect (G_OBJECT (radio), "toggled", G_CALLBACK (dcc_toggle), GINT_TO_POINTER (VIEW_UPLOAD)); gtk_table_attach (GTK_TABLE (table), radio, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)); radio = gtk_radio_button_new_with_mnemonic (group, _("Downloads")); g_signal_connect (G_OBJECT (radio), "toggled", G_CALLBACK (dcc_toggle), GINT_TO_POINTER (VIEW_DOWNLOAD)); gtk_table_attach (GTK_TABLE (table), radio, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0); exp = gtk_expander_new (_("Details")); gtk_table_attach (GTK_TABLE (table), exp, 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0); detailbox = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (detailbox), 6); gtk_table_set_row_spacings (GTK_TABLE (detailbox), 2); gtk_container_set_border_width (GTK_CONTAINER (detailbox), 6); g_signal_connect (G_OBJECT (exp), "activate", G_CALLBACK (dcc_exp_cb), detailbox); gtk_table_attach (GTK_TABLE (table), detailbox, 0, 4, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0); dccfwin.file_label = dcc_detail_label (_("File:"), detailbox, 0); dccfwin.address_label = dcc_detail_label (_("Address:"), detailbox, 1); bbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD); gtk_box_pack_end (GTK_BOX (vbox), bbox, FALSE, FALSE, 2); dccfwin.abort_button = gtkutil_button (bbox, GTK_STOCK_CANCEL, 0, abort_clicked, 0, _("Abort")); dccfwin.accept_button = gtkutil_button (bbox, GTK_STOCK_APPLY, 0, accept_clicked, 0, _("Accept")); dccfwin.resume_button = gtkutil_button (bbox, GTK_STOCK_REFRESH, 0, resume_clicked, 0, _("Resume")); dccfwin.clear_button = gtkutil_button (bbox, GTK_STOCK_CLEAR, 0, clear_completed, 0, _("Clear")); dccfwin.open_button = gtkutil_button (bbox, 0, 0, browse_dcc_folder, 0, _("Open Folder...")); gtk_widget_set_sensitive (dccfwin.accept_button, FALSE); gtk_widget_set_sensitive (dccfwin.resume_button, FALSE); gtk_widget_set_sensitive (dccfwin.abort_button, FALSE); dcc_fill_window (3); gtk_widget_show_all (dccfwin.window); gtk_widget_hide (detailbox); return FALSE; }
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 *)malloc(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_ENTRY(gtk_combo_box_entry_new_text()); dt_gui_key_accel_block_on_focus(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_ENTRY(gtk_bin_get_child(GTK_BIN(d->title))), "activate", G_CALLBACK (enter_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_ENTRY(gtk_combo_box_entry_new_text()); dt_gui_key_accel_block_on_focus(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_ENTRY(gtk_bin_get_child(GTK_BIN(d->description))), "activate", G_CALLBACK (enter_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_ENTRY(gtk_combo_box_entry_new_text()); dt_gui_key_accel_block_on_focus(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_ENTRY(gtk_bin_get_child(GTK_BIN(d->creator))), "activate", G_CALLBACK (enter_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_ENTRY(gtk_combo_box_entry_new_text()); dt_gui_key_accel_block_on_focus(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_ENTRY(gtk_bin_get_child(GTK_BIN(d->publisher))), "activate", G_CALLBACK (enter_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_ENTRY(gtk_combo_box_entry_new_text()); dt_gui_key_accel_block_on_focus(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_ENTRY(gtk_bin_get_child(GTK_BIN(d->rights))), "activate", G_CALLBACK (enter_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); }
/** \brief Create and initialise widgets. * */ GtkWidget *sat_pref_help_create () { GtkWidget *vbox; /* vbox containing the list part and the details part */ GtkWidget *table; GtkWidget *label; guint i; gint idx; vbox = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (vbox), 20); /* header */ label = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_markup (GTK_LABEL (label), _("<b>Html Browser:</b>")); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0); /* table for combo box and command string */ table = gtk_table_new (2, 2, TRUE); gtk_table_set_col_spacings (GTK_TABLE (table), 10); gtk_table_set_row_spacings (GTK_TABLE (table), 10); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, TRUE, 0); /* browser type */ label = gtk_label_new (_("Browser type:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); combo = gtk_combo_box_new_text (); for (i = 0; i < BROWSER_TYPE_NUM; i++) gtk_combo_box_append_text (GTK_COMBO_BOX (combo), sat_help[i].type); gtk_table_attach (GTK_TABLE (table), combo, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0); g_signal_connect (combo, "changed", G_CALLBACK (browser_changed_cb), NULL); /* command string */ label = gtk_label_new (_("Command string:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); entry = gtk_entry_new (); gtk_entry_set_max_length (GTK_ENTRY (entry), 100); gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0); /* get curreent browser */ idx = sat_cfg_get_int (SAT_CFG_INT_WEB_BROWSER_TYPE); /* some sanity check before accessing the arrays ;-) */ if ((idx < BROWSER_TYPE_NONE) || (idx >= BROWSER_TYPE_NUM)) { idx = BROWSER_TYPE_NONE; } gtk_combo_box_set_active (GTK_COMBO_BOX (combo), idx); if (idx == BROWSER_TYPE_OTHER) gtk_entry_set_text (GTK_ENTRY (entry), sat_cfg_get_str (SAT_CFG_STR_WEB_BROWSER)); /** FIXME */ gtk_widget_set_sensitive (vbox, FALSE); dirty = FALSE; return vbox; }
static GtkWidget *create_dialog(void) { GtkWidget *dialog; GtkWidget *header_image; GtkWidget *header_label; GtkWidget *label_info; GtkWidget *codename_label; GtkWidget *builddate_label; GtkWidget *url_button; GtkWidget *cop_label; GtkWidget *label; GtkWidget *license_textview; GtkWidget *notebook; GtkWidget *box; GtkWidget *credits_scrollwin; GtkWidget *table; GtkWidget *license_scrollwin; GtkWidget *info_box; GtkWidget *header_hbox; GtkWidget *header_eventbox; GtkTextBuffer* tb; gchar *license_text = NULL; gchar buffer[512]; gchar buffer2[128]; guint i, row = 0; gchar *build_date; dialog = gtk_dialog_new(); /* configure dialog */ gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window)); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany")); gtk_window_set_icon_name(GTK_WINDOW(dialog), "geany"); gtk_widget_set_name(dialog, "GeanyDialog"); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL); /* create header */ header_eventbox = gtk_event_box_new(); gtk_widget_show(header_eventbox); header_hbox = gtk_hbox_new(FALSE, 12); gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4); gtk_widget_show(header_hbox); gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox); header_image = gtk_image_new_from_icon_name("geany", GTK_ICON_SIZE_DIALOG); gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0); header_label = gtk_label_new(NULL); gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE); /* print the subversion revision generated by ./configure if it is available */ g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string()); gtk_label_set_markup(GTK_LABEL(header_label), buffer); gtk_widget_show(header_label); gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0); header_eventbox_style_set(header_eventbox); header_label_style_set(header_label); g_signal_connect_after(header_eventbox, "style-set", G_CALLBACK(header_eventbox_style_set), NULL); g_signal_connect_after(header_label, "style-set", G_CALLBACK(header_label_style_set), NULL); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), header_eventbox, FALSE, FALSE, 0); /* create notebook */ notebook = gtk_notebook_new(); gtk_widget_show(notebook); gtk_container_set_border_width(GTK_CONTAINER(notebook), 2); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), notebook, TRUE, TRUE, 0); /* create "Info" tab */ info_box = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(info_box), 6); gtk_widget_show(info_box); label_info = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(label_info), TRUE); gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE); g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE")); gtk_label_set_markup(GTK_LABEL(label_info), buffer); gtk_misc_set_padding(GTK_MISC(label_info), 2, 11); gtk_widget_show(label_info); gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0); /* Codename label */ codename_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE); gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME); gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8); gtk_widget_show(codename_label); gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0); /* build date label */ builddate_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE); build_date = utils_parse_and_format_build_date(__DATE__); g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), build_date); g_free(build_date); g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2); gtk_label_set_markup(GTK_LABEL(builddate_label), buffer); gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2); gtk_widget_show(builddate_label); gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0); box = gtk_hbutton_box_new(); url_button = gtk_button_new(); gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE); g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE); label = gtk_label_new(NULL); gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE); gtk_widget_show(label); gtk_container_add(GTK_CONTAINER(url_button), label); gtk_widget_show(url_button); gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0); gtk_widget_show(box); gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10); /* copyright label */ cop_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE); gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE); gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT); gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10); gtk_widget_show(cop_label); gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0); /*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */ label = gtk_label_new(_("Info")); gtk_widget_show(label); gtk_widget_show_all(info_box); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label); /* create "Credits" tab */ credits_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 6); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE); gtk_table_set_col_spacings(GTK_TABLE(table), 10); row = 0; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < translators_len; i++) { ROW(translators[i][0], row, 0, 1, 4, 0); ROW(translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < prev_translators_len; i++) { ROW(prev_translators[i][0], row, 0, 1, 4, 0); ROW(prev_translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; g_snprintf(buffer, sizeof(buffer), _("Some of the many contributors (for a more detailed list, see the file %s):"), #ifdef G_OS_WIN32 "Thanks.txt" #else "THANKS" #endif ); label = geany_wrap_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; label = geany_wrap_label_new(contributors); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table); gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE); gtk_widget_show_all(table); label = gtk_label_new(_("Credits")); gtk_widget_show(label); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label); /* create "License" tab */ license_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_SHADOW_IN); license_textview = gtk_text_view_new(); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(license_textview), 2); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(license_textview), 2); gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE); gtk_widget_show(license_textview); gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview); label = gtk_label_new(_("License")); gtk_widget_show(label); g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir); g_file_get_contents(buffer, &license_text, NULL, NULL); if (license_text == NULL) { license_text = g_strdup( _("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online.")); } tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview)); gtk_text_buffer_set_text(tb, license_text, -1); g_free(license_text); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), license_scrollwin, label); gtk_widget_show_all(dialog); return dialog; }
void gtkui_dhcp_spoofing(void) { GtkWidget *dialog, *table, *hbox, *image, *label, *entry1, *entry2, *entry3, *frame; gint response = 0; DEBUG_MSG("gtk_dhcp_spoofing"); dialog = gtk_dialog_new_with_buttons("MITM Attack: DHCP Spoofing", GTK_WINDOW (window), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_container_set_border_width(GTK_CONTAINER (dialog), 5); gtk_dialog_set_has_separator(GTK_DIALOG (dialog), FALSE); hbox = gtk_hbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.1); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 5); gtk_widget_show(image); frame = gtk_frame_new("Server Information"); gtk_container_set_border_width(GTK_CONTAINER (frame), 5); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show(frame); table = gtk_table_new(3, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE (table), 5); gtk_table_set_col_spacings(GTK_TABLE (table), 5); gtk_container_set_border_width(GTK_CONTAINER (table), 8); gtk_container_add(GTK_CONTAINER (frame), table); gtk_widget_show(table); label = gtk_label_new("IP Pool (optional)"); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach(GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show(label); entry1 = gtk_entry_new(); gtk_table_attach_defaults(GTK_TABLE (table), entry1, 1, 2, 0, 1); gtk_widget_show(entry1); label = gtk_label_new("Netmask"); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach(GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show(label); entry2 = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY (entry2), IP6_ASCII_ADDR_LEN); gtk_table_attach_defaults(GTK_TABLE (table), entry2, 1, 2, 1, 2); gtk_widget_show(entry2); label = gtk_label_new("DNS Server IP"); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_table_attach(GTK_TABLE (table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show(label); entry3 = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY (entry3), IP6_ASCII_ADDR_LEN); gtk_table_attach_defaults(GTK_TABLE (table), entry3, 1, 2, 2, 3); gtk_widget_show(entry3); response = gtk_dialog_run(GTK_DIALOG(dialog)); if(response == GTK_RESPONSE_OK) { gtk_widget_hide(dialog); sprintf(params, "dhcp:"); strncat(params, gtk_entry_get_text(GTK_ENTRY(entry1)), PARAMS_LEN); strncat(params, "/", PARAMS_LEN); strncat(params, gtk_entry_get_text(GTK_ENTRY(entry2)), PARAMS_LEN); strncat(params, "/", PARAMS_LEN); strncat(params, gtk_entry_get_text(GTK_ENTRY(entry3)), PARAMS_LEN); gtkui_start_mitm(); } gtk_widget_destroy(dialog); /* a simpler method: gtkui_input_call("Parameters :", params + strlen("dhcp:"), PARAMS_LEN - strlen("dhcp:"), gtkui_start_mitm); */ }
GtkWidget * create_Configure(void) { GtkWidget *Configure; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *cbIntern; GtkWidget *comboboxType; GtkWidget *table1; GtkWidget *label3; GtkWidget *label4; GtkWidget *entryCommand0; GtkWidget *entryCommand1; GtkWidget *label2; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; Configure = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW(Configure), _("Doc")); gtk_window_set_type_hint(GTK_WINDOW(Configure), GDK_WINDOW_TYPE_HINT_DIALOG); dialog_vbox1 = GTK_DIALOG(Configure)->vbox; gtk_widget_show(dialog_vbox1); vbox1 = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox1); gtk_box_pack_start(GTK_BOX(dialog_vbox1), vbox1, TRUE, TRUE, 0); cbIntern = gtk_check_button_new_with_mnemonic(_("Put output in buffer")); gtk_widget_show(cbIntern); gtk_box_pack_start(GTK_BOX(vbox1), cbIntern, FALSE, FALSE, 0); comboboxType = gtk_combo_box_new_text(); gtk_widget_show(comboboxType); gtk_box_pack_start(GTK_BOX(vbox1), comboboxType, FALSE, FALSE, 0); table1 = gtk_table_new(2, 2, FALSE); gtk_widget_show(table1); gtk_box_pack_start(GTK_BOX(vbox1), table1, TRUE, TRUE, 0); label3 = gtk_label_new(_("Command 0:")); gtk_widget_show(label3); gtk_table_attach(GTK_TABLE(table1), label3, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment(GTK_MISC(label3), 0, 0.5); label4 = gtk_label_new(_("Command 1:")); gtk_widget_show(label4); gtk_table_attach(GTK_TABLE(table1), label4, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment(GTK_MISC(label4), 0, 0.5); entryCommand0 = gtk_entry_new(); gtk_widget_show(entryCommand0); gtk_table_attach(GTK_TABLE(table1), entryCommand0, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_entry_set_invisible_char(GTK_ENTRY(entryCommand0), 8226); entryCommand1 = gtk_entry_new(); gtk_widget_show(entryCommand1); gtk_table_attach(GTK_TABLE(table1), entryCommand1, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_entry_set_invisible_char(GTK_ENTRY(entryCommand1), 8226); label2 = gtk_label_new(_("%w will be replaced with current word\n")); gtk_widget_show(label2); gtk_box_pack_start(GTK_BOX(dialog_vbox1), label2, FALSE, FALSE, 0); dialog_action_area1 = GTK_DIALOG(Configure)->action_area; gtk_widget_show(dialog_action_area1); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock("gtk-cancel"); gtk_widget_show(cancelbutton1); gtk_dialog_add_action_widget(GTK_DIALOG(Configure), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS(cancelbutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock("gtk-ok"); gtk_widget_show(okbutton1); gtk_dialog_add_action_widget(GTK_DIALOG(Configure), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS(okbutton1, GTK_CAN_DEFAULT); g_signal_connect_after((gpointer) comboboxType, "changed", G_CALLBACK(on_comboboxType_changed), NULL); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF(Configure, Configure, "Configure"); GLADE_HOOKUP_OBJECT_NO_REF(Configure, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT(Configure, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT(Configure, cbIntern, "cbIntern"); GLADE_HOOKUP_OBJECT(Configure, comboboxType, "comboboxType"); GLADE_HOOKUP_OBJECT(Configure, table1, "table1"); GLADE_HOOKUP_OBJECT(Configure, label3, "label3"); GLADE_HOOKUP_OBJECT(Configure, label4, "label4"); GLADE_HOOKUP_OBJECT(Configure, entryCommand0, "entryCommand0"); GLADE_HOOKUP_OBJECT(Configure, entryCommand1, "entryCommand1"); GLADE_HOOKUP_OBJECT(Configure, label2, "label2"); GLADE_HOOKUP_OBJECT_NO_REF(Configure, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT(Configure, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT(Configure, okbutton1, "okbutton1"); return Configure; }
/** * resolution_calibrate_dialog: * @resolution_entry: a #GimpSizeEntry to connect the dialog to * @pixbuf: an optional #GdkPixbuf for the upper left corner * * Displays a dialog that allows the user to interactively determine * her monitor resolution. This dialog runs it's own GTK main loop and * is connected to a #GimpSizeEntry handling the resolution to be set. **/ void resolution_calibrate_dialog (GtkWidget *resolution_entry, GdkPixbuf *pixbuf) { GtkWidget *dialog; GtkWidget *table; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *ruler; GtkWidget *label; GdkScreen *screen; GdkRectangle rect; gint monitor; g_return_if_fail (GIMP_IS_SIZE_ENTRY (resolution_entry)); g_return_if_fail (GTK_WIDGET_REALIZED (resolution_entry)); g_return_if_fail (pixbuf == NULL || GDK_IS_PIXBUF (pixbuf)); /* this dialog can only exist once */ if (calibrate_entry) return; dialog = gimp_dialog_new (_("Calibrate Monitor Resolution"), "gimp-resolution-calibration", gtk_widget_get_toplevel (resolution_entry), GTK_DIALOG_DESTROY_WITH_PARENT, NULL, NULL, 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); screen = gtk_widget_get_screen (dialog); monitor = gdk_screen_get_monitor_at_window (screen, resolution_entry->window); gdk_screen_get_monitor_geometry (screen, monitor, &rect); ruler_width = rect.width - 300 - (rect.width % 100); ruler_height = rect.height - 300 - (rect.height % 100); table = gtk_table_new (4, 4, FALSE); gtk_container_set_border_width (GTK_CONTAINER (table), 12); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), table); gtk_widget_show (table); if (pixbuf) { GtkWidget *image = gtk_image_new_from_pixbuf (pixbuf); gtk_table_attach (GTK_TABLE (table), image, 0, 1, 0, 1, GTK_SHRINK, GTK_SHRINK, 4, 4); gtk_widget_show (image); } ruler = gimp_ruler_new (GTK_ORIENTATION_HORIZONTAL); gtk_widget_set_size_request (ruler, ruler_width, 32); gimp_ruler_set_range (GIMP_RULER (ruler), 0, ruler_width, ruler_width); gtk_table_attach (GTK_TABLE (table), ruler, 1, 3, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0); gtk_widget_show (ruler); ruler = gimp_ruler_new (GTK_ORIENTATION_VERTICAL); gtk_widget_set_size_request (ruler, 32, ruler_height); gimp_ruler_set_range (GIMP_RULER (ruler), 0, ruler_height, ruler_height); gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 3, GTK_SHRINK, GTK_SHRINK, 0, 0); gtk_widget_show (ruler); vbox = gtk_vbox_new (FALSE, 12); gtk_table_attach (GTK_TABLE (table), vbox, 1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0); gtk_widget_show (vbox); label = gtk_label_new (_("Measure the rulers and enter their lengths:")); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_SCALE, PANGO_SCALE_LARGE, PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD, -1); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); calibrate_xres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (resolution_entry), 0); calibrate_yres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (resolution_entry), 1); calibrate_entry = gimp_coordinates_new (GIMP_UNIT_INCH, "%p", FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_SIZE, FALSE, FALSE, _("_Horizontal:"), ruler_width, calibrate_xres, 1, GIMP_MAX_IMAGE_SIZE, 0, 0, _("_Vertical:"), ruler_height, calibrate_yres, 1, GIMP_MAX_IMAGE_SIZE, 0, 0); gtk_widget_hide (GTK_WIDGET (GIMP_COORDINATES_CHAINBUTTON (calibrate_entry))); g_signal_connect (dialog, "destroy", G_CALLBACK (gtk_widget_destroyed), &calibrate_entry); gtk_box_pack_end (GTK_BOX (hbox), calibrate_entry, FALSE, FALSE, 0); gtk_widget_show (calibrate_entry); gtk_widget_show (dialog); switch (gimp_dialog_run (GIMP_DIALOG (dialog))) { case GTK_RESPONSE_OK: { GtkWidget *chain_button; gdouble x, y; x = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (calibrate_entry), 0); y = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (calibrate_entry), 1); calibrate_xres = (gdouble) ruler_width * calibrate_xres / x; calibrate_yres = (gdouble) ruler_height * calibrate_yres / y; chain_button = GIMP_COORDINATES_CHAINBUTTON (resolution_entry); if (ABS (x - y) > GIMP_MIN_RESOLUTION) gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chain_button), FALSE); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (resolution_entry), 0, calibrate_xres); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (resolution_entry), 1, calibrate_yres); } default: break; } gtk_widget_destroy (dialog); }
void create_display_shell(DDisplay *ddisp, int width, int height, char *title) { GtkWidget *table; GtkWidget *status_hbox; int s_width, s_height; s_width = gdk_screen_width (); s_height = gdk_screen_height (); if (width > s_width) width = s_width; if (height > s_height) width = s_width; /* The adjustment datums */ ddisp->hsbdata = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, width, 1, 1, width-1)); ddisp->vsbdata = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, height, 1, 1, height-1)); /* The toplevel shell */ ddisp->shell = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (ddisp->shell), title); gtk_window_set_wmclass (GTK_WINDOW (ddisp->shell), "diagram_window", "Dia"); gtk_window_set_policy (GTK_WINDOW (ddisp->shell), TRUE, TRUE, TRUE); gtk_object_set_user_data (GTK_OBJECT (ddisp->shell), (gpointer) ddisp); gtk_widget_set_events (ddisp->shell, GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_FOCUS_CHANGE_MASK); /* GDK_ALL_EVENTS_MASK */ gtk_signal_connect (GTK_OBJECT (ddisp->shell), "delete_event", GTK_SIGNAL_FUNC (ddisplay_delete), ddisp); gtk_signal_connect (GTK_OBJECT (ddisp->shell), "destroy", GTK_SIGNAL_FUNC (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); gtk_container_add (GTK_CONTAINER (ddisp->shell), table); /* scrollbars, rulers, canvas, menu popup button */ ddisp->origin = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (ddisp->origin), GTK_SHADOW_OUT); ddisp->hrule = gtk_hruler_new (); gtk_signal_connect_object (GTK_OBJECT (ddisp->shell), "motion_notify_event", (GtkSignalFunc) GTK_WIDGET_CLASS (GTK_OBJECT (ddisp->hrule)->klass)->motion_notify_event, GTK_OBJECT (ddisp->hrule)); ddisp->vrule = gtk_vruler_new (); gtk_signal_connect_object (GTK_OBJECT (ddisp->shell), "motion_notify_event", (GtkSignalFunc) GTK_WIDGET_CLASS (GTK_OBJECT (ddisp->vrule)->klass)->motion_notify_event, GTK_OBJECT (ddisp->vrule)); ddisp->hsb = gtk_hscrollbar_new (ddisp->hsbdata); GTK_WIDGET_UNSET_FLAGS (ddisp->hsb, GTK_CAN_FOCUS); ddisp->vsb = gtk_vscrollbar_new (ddisp->vsbdata); GTK_WIDGET_UNSET_FLAGS (ddisp->vsb, GTK_CAN_FOCUS); /* set up the scrollbar observers */ gtk_signal_connect (GTK_OBJECT (ddisp->hsbdata), "value_changed", (GtkSignalFunc) ddisplay_hsb_update, ddisp); gtk_signal_connect (GTK_OBJECT (ddisp->vsbdata), "value_changed", (GtkSignalFunc) ddisplay_vsb_update, ddisp); ddisp->canvas = gtk_drawing_area_new (); gtk_drawing_area_size (GTK_DRAWING_AREA (ddisp->canvas), width, height); gtk_widget_set_events (ddisp->canvas, CANVAS_EVENT_MASK); GTK_WIDGET_SET_FLAGS (ddisp->canvas, GTK_CAN_FOCUS); gtk_signal_connect (GTK_OBJECT (ddisp->canvas), "event", (GtkSignalFunc) ddisplay_canvas_events, ddisp); gtk_object_set_user_data (GTK_OBJECT (ddisp->canvas), (gpointer) ddisp); /* pack all the 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->hrule, 1, 2, 0, 1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table), ddisp->vrule, 0, 1, 1, 2, GTK_FILL, GTK_EXPAND | GTK_SHRINK | 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); gtk_table_attach (GTK_TABLE (table), ddisp->hsb, 0, 2, 2, 3, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table), ddisp->vsb, 2, 3, 0, 2, GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); /* the popup menu */ #ifdef GNOME ddisp->popup = gnome_display_menus_create (); ddisp->accel_group = gnome_popup_menu_get_accel_group(GTK_MENU(ddisp->popup)); #else menus_get_image_menu (&ddisp->popup, &ddisp->accel_group); #endif /* the accelerator table/group for the popup */ gtk_window_add_accel_group (GTK_WINDOW(ddisp->shell), ddisp->accel_group); /* the statusbars */ status_hbox = gtk_hbox_new (FALSE, 2); ddisp->zoom_status = gtk_statusbar_new (); ddisp->modified_status = gtk_statusbar_new (); gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->zoom_status, FALSE, FALSE, 0); 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); gtk_widget_show (ddisp->hsb); gtk_widget_show (ddisp->vsb); gtk_widget_show (ddisp->origin); gtk_widget_show (ddisp->hrule); gtk_widget_show (ddisp->vrule); gtk_widget_show (ddisp->canvas); gtk_widget_show (ddisp->zoom_status); gtk_widget_show (ddisp->modified_status); gtk_widget_show (status_hbox); gtk_widget_show (table); gtk_widget_show (ddisp->shell); /* set the focus to the canvas area */ gtk_widget_grab_focus (ddisp->canvas); }
/*-----------------------------------------------------------*/ GtkWidget *create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *table1; GtkWidget *label1; GtkWidget *label3; GtkWidget *label4; GtkWidget *label5; GtkWidget *label6; GtkWidget *label7; GtkWidget *label8; GtkWidget *label2; GtkWidget *label_phasis; GtkWidget *label_frame; GtkWidget *label_eta; GtkWidget *label_codec; GtkWidget *label_fps; GtkWidget *label_quant; GtkWidget *label_size; GtkWidget *label_bitrate; GtkWidget *progressbar1; GtkWidget *dialog_action_area1; GtkWidget *closebutton1; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), _("Encoding in progress")); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0); table1 = gtk_table_new (8, 2, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (vbox1), table1, TRUE, TRUE, 0); label1 = gtk_label_new (_("Phasis")); gtk_widget_show (label1); gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_widget_set_size_request (label1, 60, -1); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5); label3 = gtk_label_new (_("Estimated time left ")); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5); label4 = gtk_label_new (_("Codec")); gtk_widget_show (label4); gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5); label5 = gtk_label_new (_("FPS")); gtk_widget_show (label5); gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5); label6 = gtk_label_new (_("Bitrate")); gtk_widget_show (label6); gtk_table_attach (GTK_TABLE (table1), label6, 0, 1, 5, 6, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5); label7 = gtk_label_new (_("Quantizer")); gtk_widget_show (label7); gtk_table_attach (GTK_TABLE (table1), label7, 0, 1, 6, 7, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5); label8 = gtk_label_new (_("Size(mb)")); gtk_widget_show (label8); gtk_table_attach (GTK_TABLE (table1), label8, 0, 1, 7, 8, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label8), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5); label2 = gtk_label_new (_("Frame")); gtk_widget_show (label2); gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_widget_set_size_request (label2, 50, -1); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); label_phasis = gtk_label_new (_("None")); gtk_widget_show (label_phasis); gtk_table_attach (GTK_TABLE (table1), label_phasis, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label_phasis), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label_phasis), 0, 0.5); label_frame = gtk_label_new (_("0/0")); gtk_widget_show (label_frame); gtk_table_attach (GTK_TABLE (table1), label_frame, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label_frame), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label_frame), 0, 0.5); label_eta = gtk_label_new (_("0:0:0")); gtk_widget_show (label_eta); gtk_table_attach (GTK_TABLE (table1), label_eta, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label_eta), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label_eta), 0, 0.5); label_codec = gtk_label_new (_("None")); gtk_widget_show (label_codec); gtk_table_attach (GTK_TABLE (table1), label_codec, 1, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label_codec), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label_codec), 0, 0.5); label_fps = gtk_label_new (_("0")); gtk_widget_show (label_fps); gtk_table_attach (GTK_TABLE (table1), label_fps, 1, 2, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label_fps), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label_fps), 0, 0.5); label_quant = gtk_label_new (_("31")); gtk_widget_show (label_quant); gtk_table_attach (GTK_TABLE (table1), label_quant, 1, 2, 6, 7, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label_quant), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label_quant), 0, 0.5); label_size = gtk_label_new (_("0")); gtk_widget_show (label_size); gtk_table_attach (GTK_TABLE (table1), label_size, 1, 2, 7, 8, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label_size), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label_size), 0, 0.5); label_bitrate = gtk_label_new (_("0")); gtk_widget_show (label_bitrate); gtk_table_attach (GTK_TABLE (table1), label_bitrate, 1, 2, 5, 6, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label_bitrate), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label_bitrate), 0, 0.5); progressbar1 = gtk_progress_bar_new (); gtk_widget_show (progressbar1); gtk_box_pack_start (GTK_BOX (vbox1), progressbar1, FALSE, FALSE, 0); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); closebutton1 = gtk_button_new_from_stock ("gtk-close"); gtk_widget_show (closebutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), closebutton1, GTK_RESPONSE_CLOSE); GTK_WIDGET_SET_FLAGS (closebutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (dialog1, table1, "table1"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT (dialog1, label3, "label3"); GLADE_HOOKUP_OBJECT (dialog1, label4, "label4"); GLADE_HOOKUP_OBJECT (dialog1, label5, "label5"); GLADE_HOOKUP_OBJECT (dialog1, label6, "label6"); GLADE_HOOKUP_OBJECT (dialog1, label7, "label7"); GLADE_HOOKUP_OBJECT (dialog1, label8, "label8"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, label_phasis, "label_phasis"); GLADE_HOOKUP_OBJECT (dialog1, label_frame, "label_frame"); GLADE_HOOKUP_OBJECT (dialog1, label_eta, "label_eta"); GLADE_HOOKUP_OBJECT (dialog1, label_codec, "label_codec"); GLADE_HOOKUP_OBJECT (dialog1, label_fps, "label_fps"); GLADE_HOOKUP_OBJECT (dialog1, label_quant, "label_quant"); GLADE_HOOKUP_OBJECT (dialog1, label_size, "label_size"); GLADE_HOOKUP_OBJECT (dialog1, label_bitrate, "label_bitrate"); GLADE_HOOKUP_OBJECT (dialog1, progressbar1, "progressbar1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, closebutton1, "closebutton1"); return dialog1; }
/** \brief Create and initialise widgets for the single pass cfg tab. * * The widgets must be preloaded with values from config. If a config value * is NULL, sensible default values, eg. those from defaults.h should * be laoded. */ GtkWidget *sat_pref_single_sat_create (GKeyFile *cfg) { GtkWidget *table; GtkWidget *vbox; GtkWidget *label; guint i; /* create the table */ table = gtk_table_new ((SINGLE_SAT_FIELD_NUMBER+1)/COLUMNS + 1, COLUMNS, TRUE); //gtk_container_set_border_width (GTK_CONTAINER (table), 20); gtk_table_set_row_spacings (GTK_TABLE (table), 10); gtk_table_set_col_spacings (GTK_TABLE (table), 5); /* create header */ label = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_markup (GTK_LABEL (label), _("<b>Visible Fields:</b>")); gtk_table_attach (GTK_TABLE (table), label, 0, 2, 0, 1, GTK_FILL, GTK_SHRINK, 0, 0); /* get visible column flags */ if (cfg != NULL) { flags = mod_cfg_get_int (cfg, MOD_CFG_SINGLE_SAT_SECTION, MOD_CFG_SINGLE_SAT_FIELDS, SAT_CFG_INT_SINGLE_SAT_FIELDS); } else { flags = sat_cfg_get_int (SAT_CFG_INT_SINGLE_SAT_FIELDS); } for (i = 0; i < SINGLE_SAT_FIELD_NUMBER; i++) { check[i] = gtk_check_button_new_with_label (_(SINGLE_SAT_FIELD_TITLE[i])); gtk_widget_set_tooltip_text (check[i], _(SINGLE_SAT_FIELD_HINT[i])); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check[i]), flags & (1 << i)); gtk_table_attach (GTK_TABLE (table), check[i], i % COLUMNS, (i % COLUMNS) + 1, Y0 + i / COLUMNS, Y0 + i / COLUMNS + 1, GTK_FILL, GTK_SHRINK, 0, 0); g_signal_connect (check[i], "toggled", G_CALLBACK (toggle_cb), GUINT_TO_POINTER (i)); } /* create vertical box */ vbox = gtk_vbox_new (FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (vbox), 20); gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0); /* create RESET button */ create_reset_button (cfg, GTK_BOX (vbox)); startflags = flags; dirty = FALSE; reset = FALSE; return vbox; }
void ags_audio_preferences_init(AgsAudioPreferences *audio_preferences) { GtkTable *table; GtkLabel *label; GtkCellRenderer *cell_renderer; table = (GtkTable *) gtk_table_new(2, 4, FALSE); gtk_box_pack_start(GTK_BOX(audio_preferences), GTK_WIDGET(table), FALSE, FALSE, 2); /* sound card */ label = (GtkLabel *) g_object_new(GTK_TYPE_LABEL, "label\0", "sound card\0", "xalign\0", 0.0, NULL); gtk_table_attach(table, GTK_WIDGET(label), 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); audio_preferences->card = (GtkComboBox *) gtk_combo_box_new(); gtk_table_attach(table, GTK_WIDGET(audio_preferences->card), 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0); cell_renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(audio_preferences->card), cell_renderer, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(audio_preferences->card), cell_renderer, "text\0", 0, "text\0", 1, NULL); gtk_combo_box_set_active(audio_preferences->card, 0); /* audio channels */ label = (GtkLabel *) g_object_new(GTK_TYPE_LABEL, "label\0", "audio channels\0", "xalign\0", 0.0, NULL); gtk_table_attach(table, GTK_WIDGET(label), 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); audio_preferences->audio_channels = (GtkSpinButton *) gtk_spin_button_new_with_range(1.0, 24.0, 1.0); gtk_spin_button_set_value(audio_preferences->audio_channels, 2); gtk_table_attach(table, GTK_WIDGET(audio_preferences->audio_channels), 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0); /* samplerate */ label = (GtkLabel *) g_object_new(GTK_TYPE_LABEL, "label\0", "samplerate\0", "xalign\0", 0.0, NULL); gtk_table_attach(table, GTK_WIDGET(label), 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0); audio_preferences->samplerate = (GtkSpinButton *) gtk_spin_button_new_with_range(1.0, 192000.0, 1.0); gtk_spin_button_set_value(audio_preferences->samplerate, 44100); gtk_table_attach(table, GTK_WIDGET(audio_preferences->samplerate), 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0); /* buffer size */ label = (GtkLabel *) g_object_new(GTK_TYPE_LABEL, "label\0", "buffer size\0", "xalign\0", 0.0, NULL); gtk_table_attach(table, GTK_WIDGET(label), 0, 1, 3, 4, GTK_FILL, GTK_FILL, 0, 0); audio_preferences->buffer_size = (GtkSpinButton *) gtk_spin_button_new_with_range(1.0, 65535.0, 1.0); gtk_spin_button_set_value(audio_preferences->buffer_size, 512); gtk_table_attach(table, GTK_WIDGET(audio_preferences->buffer_size), 1, 2, 3, 4, GTK_FILL, GTK_FILL, 0, 0); }
static void prefs_create_dialog(void) { GtkWidget *label; GtkWidget *dialog_vbox; GtkWidget *notebook; GtkTable *top_table = NULL; /* top level table for the tab */ GtkTable *current_table = NULL; int i; int tab_idx = -1; if (prefs_dialog != NULL) return; prefs_dialog = gtk_dialog_new_with_buttons( _("Preferences"), GTK_WINDOW(interface_get_toolbox_shell()), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_APPLY, GTK_RESPONSE_APPLY, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG(prefs_dialog), GTK_RESPONSE_OK); gtk_window_set_resizable (GTK_WINDOW (prefs_dialog), TRUE); dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (prefs_dialog)); gtk_window_set_role (GTK_WINDOW (prefs_dialog), "preferences_window"); g_signal_connect(G_OBJECT (prefs_dialog), "response", G_CALLBACK (prefs_respond), NULL); g_signal_connect (G_OBJECT (prefs_dialog), "delete_event", G_CALLBACK(gtk_widget_hide), NULL); g_signal_connect (G_OBJECT (prefs_dialog), "destroy", G_CALLBACK(gtk_widget_destroyed), &prefs_dialog); notebook = gtk_notebook_new (); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP); gtk_box_pack_start (GTK_BOX (dialog_vbox), notebook, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (notebook), 2); gtk_widget_show (notebook); for (i=0;i<NUM_PREFS_TABS;i++) { GtkWidget *table; GtkWidget *notebook_page; label = gtk_label_new(gettext(prefs_tabs[i].title)); gtk_widget_show(label); table = gtk_table_new (9, 2, FALSE); prefs_tabs[i].table = GTK_TABLE(table); gtk_widget_set_size_request(table, -1, -1); gtk_widget_show(table); #ifdef SCROLLED_PAGES notebook_page = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (notebook_page), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show(notebook_page); #else notebook_page = table; #endif/* SCROLLED_PAGES */ gtk_notebook_append_page(GTK_NOTEBOOK(notebook), notebook_page, label); #ifdef SCROLLED_PAGES gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(notebook_page), table); gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_bin_get_child(GTK_BIN(notebook_page))), GTK_SHADOW_NONE); #endif /* SCROLLED_PAGES */ } gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_LEFT); tab_idx = -1; for (i=0;i<NUM_PREFS_DATA;i++) { GtkWidget *widget = NULL; int row; if (prefs_data[i].hidden) continue; if (tab_idx != prefs_data[i].tab) { tab_idx = prefs_data[i].tab; top_table = prefs_tabs[prefs_data[i].tab].table; current_table = top_table; } row = prefs_tabs[tab_idx].row++; switch(prefs_data[i].type) { case PREF_NONE: widget = gtk_frame_new(gettext(prefs_data[i].label_text)); gtk_widget_show (widget); gtk_table_attach (current_table, widget, 0, 2, row, row + 1, GTK_FILL | GTK_EXPAND, GTK_FILL, 1, 1); current_table = GTK_TABLE(gtk_table_new (9, 2, FALSE)); gtk_container_add(GTK_CONTAINER(widget), GTK_WIDGET(current_table)); gtk_widget_show(GTK_WIDGET(current_table)); break; case PREF_END_GROUP: current_table = top_table; break; case PREF_BOOLEAN: widget = gtk_check_button_new_with_label (gettext(prefs_data[i].label_text)); gtk_widget_show (widget); gtk_table_attach (current_table, widget, 0, 2, row, row + 1, GTK_FILL | GTK_EXPAND, GTK_FILL, 1, 1); break; default: label = gtk_label_new (gettext(prefs_data[i].label_text)); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.3); gtk_widget_show (label); gtk_table_attach (current_table, label, 0, 1, row, row + 1, GTK_FILL | GTK_EXPAND, GTK_FILL, 1, 1); widget = prefs_get_property_widget(&prefs_data[i]); if (widget != NULL) { gtk_table_attach (current_table, widget, 1, 2, row, row + 1, GTK_FILL, GTK_FILL, 1, 1); } break; } prefs_data[i].widget = widget; } gtk_widget_show (prefs_dialog); }
void ags_drum_init(AgsDrum *drum) { GtkVBox *vbox; GtkHBox *hbox; GtkToggleButton *toggle_button; GtkFrame *frame; GtkTable *table0, *table1; GtkRadioButton *radio_button; AgsAudio *audio; GList *list; guint stream_length; int i, j; g_signal_connect_after((GObject *) drum, "parent_set\0", G_CALLBACK(ags_drum_parent_set_callback), (gpointer) drum); audio = AGS_MACHINE(drum)->audio; audio->flags |= (AGS_AUDIO_OUTPUT_HAS_RECYCLING | AGS_AUDIO_INPUT_HAS_RECYCLING | AGS_AUDIO_INPUT_TAKES_FILE | AGS_AUDIO_SYNC | AGS_AUDIO_ASYNC); AGS_MACHINE(drum)->flags |= AGS_MACHINE_IS_SEQUENCER; AGS_MACHINE(drum)->input_pad_type = AGS_TYPE_DRUM_INPUT_PAD; AGS_MACHINE(drum)->input_line_type = AGS_TYPE_DRUM_INPUT_LINE; AGS_MACHINE(drum)->output_pad_type = AGS_TYPE_DRUM_OUTPUT_PAD; AGS_MACHINE(drum)->output_line_type = AGS_TYPE_DRUM_OUTPUT_LINE; g_signal_connect_after(G_OBJECT(audio), "set_audio_channels\0", G_CALLBACK(ags_drum_set_audio_channels), drum); g_signal_connect_after(G_OBJECT(audio), "set_pads\0", G_CALLBACK(ags_drum_set_pads), drum); drum->flags = 0; drum->name = NULL; drum->xml_type = "ags-drum\0"; /* create widgets */ drum->vbox = (GtkVBox *) gtk_vbox_new(FALSE, 0); gtk_container_add((GtkContainer*) gtk_bin_get_child((GtkBin *) drum), (GtkWidget *) drum->vbox); hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0); gtk_box_pack_start((GtkBox *) drum->vbox, (GtkWidget *) hbox, FALSE, FALSE, 0); drum->input_pad = (GtkHBox *) gtk_hbox_new(FALSE, 0); AGS_MACHINE(drum)->input = (GtkContainer *) drum->input_pad; gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) drum->input_pad, FALSE, FALSE, 0); drum->output_pad = (GtkVBox *) gtk_vbox_new(FALSE, 0); AGS_MACHINE(drum)->output = (GtkContainer *) drum->output_pad; gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) drum->output_pad, FALSE, FALSE, 0); drum->selected_pad = NULL; drum->selected_edit_button = NULL; hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0); gtk_box_pack_start((GtkBox *) drum->vbox, (GtkWidget *) hbox, FALSE, FALSE, 0); frame = (GtkFrame *) gtk_frame_new("kit\0"); gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) frame, FALSE, FALSE, 0); vbox = (GtkVBox *) gtk_vbox_new(FALSE, 0); gtk_container_add((GtkContainer*) frame, (GtkWidget *) vbox); gtk_box_pack_start((GtkBox *) vbox, (GtkWidget *) gtk_label_new("default\0"), FALSE, FALSE, 0); gtk_box_pack_start((GtkBox *) vbox, (GtkWidget *) (drum->open = (GtkButton *) gtk_button_new_from_stock(GTK_STOCK_OPEN)), FALSE, FALSE, 0); /* sequencer */ frame = (GtkFrame *) gtk_frame_new("Pattern\0"); gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) frame, FALSE, FALSE, 0); table0 = (GtkTable *) gtk_table_new(16, 4, FALSE); gtk_container_add((GtkContainer*) frame, (GtkWidget *) table0); drum->loop_button = (GtkCheckButton *) gtk_check_button_new_with_label("loop\0"); gtk_table_attach_defaults(table0, (GtkWidget *) drum->loop_button, 0, 1, 2, 3); AGS_MACHINE(drum)->play = drum->run = (GtkToggleButton *) gtk_toggle_button_new_with_label("run\0"); gtk_table_attach_defaults(table0, (GtkWidget *) drum->run, 1, 2, 2, 3); /* bank */ table1 = (GtkTable *) gtk_table_new(3, 5, TRUE); gtk_table_attach_defaults(table0, (GtkWidget *) table1, 2, 3, 0, 3); drum->selected1 = NULL; for(i = 0; i < 3; i++) for(j = 0; j < 4; j++){ gtk_table_attach_defaults(table1, (GtkWidget *) (drum->index1[i * 4 + j] = (GtkToggleButton *) gtk_toggle_button_new()), j, j +1, i, i +1); g_object_set_data((GObject *) drum->index1[i * 4 + j], AGS_DRUM_INDEX, GUINT_TO_POINTER(i * 4 + j)); } drum->selected1 = drum->index1[0]; gtk_toggle_button_set_active(drum->index1[0], TRUE); drum->selected0 = NULL; for(j = 0; j < 4; j++){ gtk_table_attach_defaults(table1, (GtkWidget *) (drum->index0[j] = (GtkToggleButton *) gtk_toggle_button_new()), j, j +1, 4, 5); g_object_set_data((GObject *) drum->index0[j], AGS_DRUM_INDEX, GUINT_TO_POINTER(j)); } drum->selected0 = drum->index0[0]; gtk_toggle_button_set_active(drum->index0[0], TRUE); /* duration */ hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0); gtk_table_attach(table0, (GtkWidget *) hbox, 6, 7, 0, 1, GTK_EXPAND, GTK_EXPAND, 0, 0); gtk_box_pack_start((GtkBox*) hbox, gtk_label_new("length\0"), FALSE, FALSE, 0); drum->length_spin = (GtkSpinButton *) gtk_spin_button_new_with_range(1.0, 64.0, 1.0); drum->length_spin->adjustment->value = 16.0; gtk_box_pack_start((GtkBox*) hbox, (GtkWidget *) drum->length_spin, FALSE, FALSE, 0); /* led */ drum->active_led = 0; drum->led = hbox = (GtkHBox *) gtk_hbox_new(FALSE, 16); gtk_table_attach_defaults(table0, (GtkWidget *) hbox, 3, 15, 1, 2); for(i = 0; i < 16; i++){ toggle_button = (GtkToggleButton *) ags_led_new(); gtk_widget_set_size_request((GtkWidget *) toggle_button, 8, 4); gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) toggle_button, FALSE, FALSE, 0); } /* pattern */ drum->pattern = hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0); gtk_table_attach_defaults(table0, (GtkWidget *) hbox, 3, 15, 2, 3); for(i = 0; i < 16; i++){ toggle_button = (GtkToggleButton *) gtk_toggle_button_new(); gtk_widget_set_size_request((GtkWidget *) toggle_button, 24, 24); gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) toggle_button, FALSE, FALSE, 0); } /* page / offset */ drum->offset = (GtkVBox*) gtk_vbox_new(FALSE, 0); gtk_table_attach_defaults(table0, (GtkWidget *) drum->offset, 15, 16, 0, 3); radio_button = (GtkRadioButton *) gtk_radio_button_new_with_label(NULL, "1-16\0"); gtk_box_pack_start((GtkBox*) drum->offset, (GtkWidget *) radio_button, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*) drum->offset, (GtkWidget *) gtk_radio_button_new_with_label(radio_button->group, "17-32\0"), FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*) drum->offset, (GtkWidget *) gtk_radio_button_new_with_label(radio_button->group, "33-48\0"), FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*) drum->offset, (GtkWidget *) gtk_radio_button_new_with_label(radio_button->group, "49-64\0"), FALSE, FALSE, 0); }
static void saa_solid_manager_init (SaaSolidManager * mgr) { GtkWidget * but_numero, * but_wythoff, * but_filename; GtkWidget * image1, * image2, * image3; GtkObject * sbut_numero_adj; const gchar * filename_path; gtk_table_resize(GTK_TABLE(mgr), 3, 5); gtk_table_set_homogeneous(GTK_TABLE(mgr), FALSE); gtk_table_set_row_spacings (GTK_TABLE (mgr), 5); gtk_table_set_col_spacings (GTK_TABLE (mgr), 5); gtk_container_set_border_width (GTK_CONTAINER (mgr), 5); // Numero mgr->radio_numero = gtk_radio_button_new_with_label_from_widget (NULL, _("Number:")); gtk_widget_set_name(mgr->radio_numero, "numero-rad"); gtk_widget_show (mgr->radio_numero); gtk_table_attach (GTK_TABLE (mgr), mgr->radio_numero, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); sbut_numero_adj = gtk_adjustment_new (1, 1, 80, 1, 10, 0); mgr->spin_numero = gtk_spin_button_new (GTK_ADJUSTMENT (sbut_numero_adj), 1, 0); gtk_widget_set_name(mgr->spin_numero, "numero-ent"); gtk_widget_show (mgr->spin_numero); gtk_table_attach (GTK_TABLE (mgr), mgr->spin_numero, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mgr->spin_numero), TRUE); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mgr->spin_numero), TRUE); but_numero = gtk_button_new (); gtk_widget_set_name(but_numero, "numero-btn"); gtk_widget_show (but_numero); gtk_table_attach (GTK_TABLE (mgr), but_numero, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0); image1 = gtk_image_new_from_stock ("gtk-refresh", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image1); gtk_container_add (GTK_CONTAINER (but_numero), image1); // Wythoff mgr->radio_wythoff = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (mgr->radio_numero), _("Wythoff symbol:")); gtk_widget_set_name(mgr->radio_wythoff, "wythoff-rad"); gtk_widget_show (mgr->radio_wythoff); gtk_table_attach (GTK_TABLE (mgr), mgr->radio_wythoff, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); mgr->entry_wythoff = gtk_entry_new (); gtk_widget_set_name(mgr->entry_wythoff, "wythoff-ent"); gtk_widget_show (mgr->entry_wythoff); gtk_table_attach (GTK_TABLE (mgr), mgr->entry_wythoff, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_entry_set_has_frame (GTK_ENTRY (mgr->entry_wythoff), FALSE); but_wythoff = gtk_button_new (); gtk_widget_set_name(but_wythoff, "wythoff-btn"); gtk_widget_show (but_wythoff); gtk_table_attach (GTK_TABLE (mgr), but_wythoff, 2, 3, 1, 2, GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); image2 = gtk_image_new_from_stock ("gtk-refresh", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image2); gtk_container_add (GTK_CONTAINER (but_wythoff), image2); // Dual mgr->but_dual = gtk_toggle_button_new_with_mnemonic (_("Dual")); gtk_widget_set_name(mgr->but_dual, "numero-wythoff-dual-btn"); gtk_widget_show (mgr->but_dual); gtk_table_attach (GTK_TABLE (mgr), mgr->but_dual, 3, 4, 0, 2, GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); // Filename mgr->radio_filename = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (mgr->radio_wythoff), _("File:")); gtk_widget_set_name(mgr->radio_filename, "filename-rad"); gtk_widget_show (mgr->radio_filename); gtk_table_attach (GTK_TABLE (mgr), mgr->radio_filename, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0); mgr->but_filename = gtk_file_chooser_button_new (_("Load a solid"), GTK_FILE_CHOOSER_ACTION_OPEN); gtk_widget_set_name(mgr->but_filename, "filename-but"); gtk_widget_show (mgr->but_filename); gtk_table_attach (GTK_TABLE (mgr), mgr->but_filename, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0); filename_path = g_get_user_special_dir(G_USER_DIRECTORY_DOCUMENTS); gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(mgr->but_filename), filename_path); but_filename = gtk_button_new (); gtk_widget_set_name(but_filename, "filename-btn"); gtk_widget_show (but_filename); gtk_table_attach (GTK_TABLE (mgr), but_filename, 2, 3, 2, 3, GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); image3 = gtk_image_new_from_stock ("gtk-refresh", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image3); gtk_container_add (GTK_CONTAINER (but_filename), image3); // Nom mgr->label_nom = gtk_label_new (""); gtk_widget_set_name(mgr->label_nom, "numero-wythoff-filename-lbl"); gtk_widget_show (mgr->label_nom); gtk_table_attach (GTK_TABLE (mgr), mgr->label_nom, 0, 4, 4, 5, GTK_FILL, GTK_FILL, 0, 0); gtk_label_set_justify (GTK_LABEL (mgr->label_nom), GTK_JUSTIFY_CENTER); g_signal_connect_swapped ((gpointer) mgr->radio_numero, "toggled", G_CALLBACK (saa_solid_manager_radio_numero_toggled), mgr); g_signal_connect_swapped ((gpointer) mgr->radio_wythoff, "toggled", G_CALLBACK (saa_solid_manager_radio_wythoff_toggled), mgr); g_signal_connect_swapped ((gpointer) mgr->radio_filename, "toggled", G_CALLBACK (saa_solid_manager_radio_filename_toggled), mgr); g_signal_connect_swapped ((gpointer) but_numero, "clicked", G_CALLBACK (saa_solid_manager_numero_changed), mgr); g_signal_connect_swapped ((gpointer) but_wythoff, "clicked", G_CALLBACK (saa_solid_manager_wythoff_changed), mgr); g_signal_connect_swapped ((gpointer) but_filename, "clicked", G_CALLBACK (saa_solid_manager_filename_changed), mgr); g_signal_connect_swapped ((gpointer) mgr->but_dual, "toggled", G_CALLBACK (saa_solid_manager_dual_toggled), mgr); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mgr->radio_wythoff), TRUE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mgr->radio_numero), TRUE); }
static void create_tools(GtkWidget *parent) { GtkWidget *table; GtkWidget *button; GtkWidget *pixmapwidget; GdkPixmap *pixmap; GdkBitmap *mask; GtkStyle *style; char **pixmap_data; int i; table = gtk_table_new (ROWS, COLUMNS, FALSE); gtk_box_pack_start (GTK_BOX (parent), table, FALSE, TRUE, 0); gtk_widget_realize (table); for (i = 0; i < NUM_TOOLS; i++) { tool_widgets[i] = button = gtk_radio_button_new (tool_group); gtk_container_set_border_width (GTK_CONTAINER (button), 0); tool_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE); gtk_table_attach (GTK_TABLE (table), button, (i % COLUMNS), (i % COLUMNS) + 1, (i / COLUMNS), (i / COLUMNS) + 1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); if (tool_data[i].callback_data.type == MODIFY_TOOL) { modify_tool_button = GTK_WIDGET(button); } if (tool_data[i].icon_data==NULL) { ObjectType *type; type = object_get_type((char *)tool_data[i].callback_data.extra_data); if (type == NULL) pixmap_data = tool_data[0].icon_data; else pixmap_data = type->pixmap; } else { pixmap_data = tool_data[i].icon_data; } style = gtk_widget_get_style(button); pixmap = gdk_pixmap_create_from_xpm_d(parent->window, &mask, &style->bg[GTK_STATE_NORMAL], pixmap_data); pixmapwidget = gtk_pixmap_new(pixmap, mask); gtk_misc_set_padding(GTK_MISC(pixmapwidget), 4, 4); gtk_container_add (GTK_CONTAINER (button), pixmapwidget); gtk_signal_connect (GTK_OBJECT (button), "toggled", GTK_SIGNAL_FUNC (tool_select_update), &tool_data[i].callback_data); gtk_signal_connect (GTK_OBJECT (button), "button_press_event", GTK_SIGNAL_FUNC (tool_button_press), &tool_data[i].callback_data); gtk_tooltips_set_tip (tool_tips, button, gettext(tool_data[i].tool_desc), NULL); gtk_widget_show (pixmapwidget); gtk_widget_show (button); } gtk_widget_show(table); }
static gboolean edge_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *hbox; GtkWidget *table; GtkWidget *combo; GtkWidget *toggle; GtkObject *scale_data; GSList *group = NULL; gboolean run; gboolean use_wrap = (evals.wrapmode == GIMP_PIXEL_FETCHER_EDGE_WRAP); gboolean use_smear = (evals.wrapmode == GIMP_PIXEL_FETCHER_EDGE_SMEAR); gboolean use_black = (evals.wrapmode == GIMP_PIXEL_FETCHER_EDGE_BLACK); gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Edge Detection"), PLUG_IN_BINARY, 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)); main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start_defaults (GTK_BOX (main_vbox), preview); gtk_widget_show (preview); g_signal_connect (preview, "invalidated", G_CALLBACK (edge_preview_update), NULL); table = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); combo = gimp_int_combo_box_new (_("Sobel"), SOBEL, _("Prewitt compass"), PREWITT, _("Gradient"), GRADIENT, _("Roberts"), ROBERTS, _("Differential"), DIFFERENTIAL, _("Laplace"), LAPLACE, NULL); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), evals.edgemode, G_CALLBACK (gimp_int_combo_box_get_active), &evals.edgemode); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("_Algorithm:"), 0.0, 0.5, combo, 2, FALSE); g_signal_connect_swapped (combo, "changed", G_CALLBACK (gimp_preview_invalidate), preview); /* Label, scale, entry for evals.amount */ scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("A_mount:"), 100, 0, evals.amount, 1.0, 10.0, 0.1, 1.0, 1, FALSE, 1.0, G_MAXFLOAT, NULL, NULL); g_signal_connect (scale_data, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &evals.amount); g_signal_connect_swapped (scale_data, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* Radio buttons WRAP, SMEAR, BLACK */ hbox = gtk_hbox_new (FALSE, 4); gtk_table_attach (GTK_TABLE (table), hbox, 0, 3, 2, 3, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (hbox); toggle = gtk_radio_button_new_with_mnemonic (group, _("_Wrap")); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (toggle)); gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), use_wrap); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &use_wrap); g_signal_connect_swapped (toggle, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); toggle = gtk_radio_button_new_with_mnemonic (group, _("_Smear")); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (toggle)); gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), use_smear); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &use_smear); g_signal_connect_swapped (toggle, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); toggle = gtk_radio_button_new_with_mnemonic (group, _("_Black")); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (toggle)); gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), use_black); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &use_black); g_signal_connect_swapped (toggle, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); if (use_wrap) evals.wrapmode = GIMP_PIXEL_FETCHER_EDGE_WRAP; else if (use_smear) evals.wrapmode = GIMP_PIXEL_FETCHER_EDGE_SMEAR; else if (use_black) evals.wrapmode = GIMP_PIXEL_FETCHER_EDGE_BLACK; return run; }
static GtkWidget * create_sheet_page(GtkWidget *parent, Sheet *sheet) { GSList *list; SheetObject *sheet_obj; GtkWidget *table; GtkWidget *button; GtkWidget *pixmapwidget; GdkPixmap *pixmap; GdkBitmap *mask; ToolButtonData *data; GtkStyle *style; GtkWidget *scrolled_window; int i; int rows; scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); rows = (g_slist_length(sheet->objects) - 1) / COLUMNS + 1; if (rows<1) rows = 1; table = gtk_table_new (rows, COLUMNS, TRUE); style = gtk_widget_get_style(parent); i = 0; list = sheet->objects; while (list != NULL) { sheet_obj = (SheetObject *) list->data; if (sheet_obj->pixmap != NULL) { pixmap = gdk_pixmap_create_from_xpm_d(parent->window, &mask, &style->bg[GTK_STATE_NORMAL], sheet_obj->pixmap); } else if (sheet_obj->pixmap_file != NULL) { pixmap = gdk_pixmap_create_from_xpm(parent->window, &mask, &style->bg[GTK_STATE_NORMAL], sheet_obj->pixmap_file); } else { ObjectType *type; type = object_get_type(sheet_obj->object_type); pixmap = gdk_pixmap_create_from_xpm_d(parent->window, &mask, &style->bg[GTK_STATE_NORMAL], type->pixmap); } pixmapwidget = gtk_pixmap_new(pixmap, mask); button = gtk_radio_button_new (tool_group); gtk_container_set_border_width (GTK_CONTAINER (button), 0); tool_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE); gtk_container_add (GTK_CONTAINER (button), pixmapwidget); gtk_table_attach (GTK_TABLE (table), button, (i % COLUMNS), (i % COLUMNS) + 1, (i / COLUMNS), (i / COLUMNS) + 1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); /* This is a Memory leak, these can't be freed. Doesn't matter much anyway... */ data = g_new(ToolButtonData, 1); data->type = CREATE_OBJECT_TOOL; data->extra_data = sheet_obj->object_type; data->user_data = sheet_obj->user_data; gtk_signal_connect (GTK_OBJECT (button), "toggled", GTK_SIGNAL_FUNC (tool_select_update), data); gtk_signal_connect (GTK_OBJECT (button), "button_press_event", GTK_SIGNAL_FUNC (tool_button_press), data); gtk_tooltips_set_tip (tool_tips, button, gettext(sheet_obj->description), NULL); list = g_slist_next(list); i++; } gtk_widget_show(table); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), table); return scrolled_window; }
/** * \brief Create and initialise time controller widgets. * \param module The parent GtkSatModule * */ void tmg_create(GtkSatModule * mod) { GtkWidget *vbox, *hbox, *table; GtkWidget *image; GtkWidget *label; gchar *title; gchar *buff; /* make sure controller is not already active */ if (mod->tmgActive) { sat_log_log(SAT_LOG_LEVEL_INFO, _("%s: Time Controller for %s is already active"), __func__, mod->name); /* try to make window visible in case it is covered by something else */ gtk_window_present(GTK_WINDOW(mod->tmgWin)); return; } /* create hbox containing the controls the controls are implemented as radiobuttons in order to inherit the mutual exclusion behaviour */ hbox = gtk_hbox_new(FALSE, 0); /* FWD */ mod->tmgFwd = gtk_radio_button_new(NULL); gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(mod->tmgFwd), FALSE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mod->tmgFwd), TRUE); image = gtk_image_new_from_stock(GTK_STOCK_MEDIA_FORWARD, GTK_ICON_SIZE_BUTTON); gtk_container_add(GTK_CONTAINER(mod->tmgFwd), image); gtk_widget_set_tooltip_text(mod->tmgFwd, _("Play forward")); g_signal_connect(mod->tmgFwd, "toggled", G_CALLBACK(tmg_fwd), mod); gtk_box_pack_end(GTK_BOX(hbox), mod->tmgFwd, FALSE, FALSE, 0); /* STOP */ mod->tmgStop = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(mod->tmgFwd)); gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(mod->tmgStop), FALSE); image = gtk_image_new_from_stock(GTK_STOCK_MEDIA_PAUSE, GTK_ICON_SIZE_BUTTON); gtk_container_add(GTK_CONTAINER(mod->tmgStop), image); gtk_widget_set_tooltip_text(mod->tmgStop, _("Stop")); g_signal_connect(mod->tmgStop, "toggled", G_CALLBACK(tmg_stop), mod); gtk_box_pack_end(GTK_BOX(hbox), mod->tmgStop, FALSE, FALSE, 0); /* BWD */ mod->tmgBwd = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(mod->tmgFwd)); gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(mod->tmgBwd), FALSE); image = gtk_image_new_from_stock(GTK_STOCK_MEDIA_REWIND, GTK_ICON_SIZE_BUTTON); gtk_container_add(GTK_CONTAINER(mod->tmgBwd), image); gtk_widget_set_tooltip_text(mod->tmgBwd, _("Play backwards")); g_signal_connect(mod->tmgBwd, "toggled", G_CALLBACK(tmg_bwd), mod); gtk_box_pack_end(GTK_BOX(hbox), mod->tmgBwd, FALSE, FALSE, 0); /* reset time */ mod->tmgReset = gtk_button_new_with_label(_("Reset")); gtk_widget_set_tooltip_text(mod->tmgReset, _("Reset to current date and time")); g_signal_connect(mod->tmgReset, "clicked", G_CALLBACK(tmg_reset), mod); gtk_box_pack_end(GTK_BOX(hbox), mod->tmgReset, FALSE, FALSE, 10); /* status label */ mod->tmgState = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(mod->tmgState), 0.0, 0.5); gtk_label_set_markup(GTK_LABEL(mod->tmgState), _("<b>Real-Time</b>")); gtk_box_pack_start(GTK_BOX(hbox), mod->tmgState, TRUE, TRUE, 10); /* create table containing the date and time widgets */ table = gtk_table_new(5, 3, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 0); mod->tmgCal = gtk_calendar_new(); gtk_calendar_set_display_options(GTK_CALENDAR(mod->tmgCal), GTK_CALENDAR_SHOW_HEADING | GTK_CALENDAR_SHOW_DAY_NAMES | GTK_CALENDAR_WEEK_START_MONDAY); g_signal_connect(mod->tmgCal, "day-selected", G_CALLBACK(tmg_time_set), mod); gtk_table_attach(GTK_TABLE(table), mod->tmgCal, 0, 1, 0, 5, GTK_SHRINK, GTK_SHRINK, 0, 0); /* Time controllers. Note that the controllers for hours, minutes, and seconds have ranges; however, they can wrap around their limits in order to ensure a smooth and continuous control of the time */ /* hour */ label = gtk_label_new(_(" Hour:")); gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1, GTK_SHRINK, GTK_SHRINK, 5, 0); mod->tmgHour = gtk_spin_button_new_with_range(0, 23, 1); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(mod->tmgHour), TRUE); gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(mod->tmgHour), GTK_UPDATE_IF_VALID); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(mod->tmgHour), 0); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(mod->tmgHour), TRUE); //FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgHour), 2); gtk_widget_set_tooltip_text(mod->tmgHour, _("Use this control to set the hour")); g_signal_connect(mod->tmgHour, "value-changed", G_CALLBACK(tmg_time_set), mod); g_signal_connect(mod->tmgHour, "wrapped", G_CALLBACK(tmg_hour_wrap), mod); gtk_table_attach(GTK_TABLE(table), mod->tmgHour, 2, 3, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0); /* minutes */ label = gtk_label_new(_(" Min:")); gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 5, 0); mod->tmgMin = gtk_spin_button_new_with_range(0, 59, 1); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(mod->tmgMin), TRUE); gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(mod->tmgMin), GTK_UPDATE_IF_VALID); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(mod->tmgMin), 0); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(mod->tmgMin), TRUE); //FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgMin), 2); gtk_widget_set_tooltip_text(mod->tmgMin, _("Use this control to set the minutes")); g_signal_connect(mod->tmgMin, "value-changed", G_CALLBACK(tmg_time_set), mod); g_signal_connect(mod->tmgMin, "wrapped", G_CALLBACK(tmg_min_wrap), mod); gtk_table_attach(GTK_TABLE(table), mod->tmgMin, 2, 3, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0); /* seconds */ label = gtk_label_new(_(" Sec:")); gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 2, 3, GTK_SHRINK, GTK_SHRINK, 5, 0); mod->tmgSec = gtk_spin_button_new_with_range(0, 59, 1); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(mod->tmgSec), TRUE); gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(mod->tmgSec), GTK_UPDATE_IF_VALID); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(mod->tmgSec), 0); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(mod->tmgSec), TRUE); //FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgSec), 2); gtk_widget_set_tooltip_text(mod->tmgSec, _("Use this control to set the seconds")); g_signal_connect(mod->tmgSec, "value-changed", G_CALLBACK(tmg_time_set), mod); g_signal_connect(mod->tmgSec, "wrapped", G_CALLBACK(tmg_sec_wrap), mod); gtk_table_attach(GTK_TABLE(table), mod->tmgSec, 2, 3, 2, 3, GTK_SHRINK, GTK_SHRINK, 0, 0); /* milliseconds */ label = gtk_label_new(_(" Msec:")); gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 3, 4, GTK_SHRINK, GTK_SHRINK, 5, 0); mod->tmgMsec = gtk_spin_button_new_with_range(0, 999, 1); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(mod->tmgMsec), TRUE); gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(mod->tmgMsec), GTK_UPDATE_IF_VALID); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(mod->tmgMsec), 0); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(mod->tmgMsec), TRUE); //FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgMsec), 2); gtk_widget_set_tooltip_text(mod->tmgMsec, _("Use this control to set the milliseconds")); g_signal_connect(mod->tmgMsec, "value-changed", G_CALLBACK(tmg_time_set), mod); g_signal_connect(mod->tmgMsec, "wrapped", G_CALLBACK(tmg_msec_wrap), mod); gtk_table_attach(GTK_TABLE(table), mod->tmgMsec, 2, 3, 3, 4, GTK_SHRINK, GTK_SHRINK, 0, 0); /* time throttle */ label = gtk_label_new(_("Throttle:")); gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 4, 5, GTK_SHRINK, GTK_SHRINK, 5, 0); mod->tmgFactor = gtk_spin_button_new_with_range(1, 100, 1); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(mod->tmgFactor), TRUE); gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(mod->tmgFactor), GTK_UPDATE_IF_VALID); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(mod->tmgFactor), 0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(mod->tmgFactor), 1); gtk_widget_set_tooltip_text(mod->tmgFactor, _("Time throttle / compression factor")); g_signal_connect(mod->tmgFactor, "value-changed", G_CALLBACK(tmg_throttle), mod); gtk_table_attach(GTK_TABLE(table), mod->tmgFactor, 2, 3, 4, 5, GTK_SHRINK, GTK_SHRINK, 0, 0); /* add slider */ mod->tmgSlider = gtk_hscale_new_with_range(-0.1, +0.1, 0.0001); // +/- 2.5 hr /*gtk_widget_set_tooltip_text (mod->tmgSlider, _("Drag the slider to change the time up to +/- 2.5 hours.\n"\ "Resolution is ~ 8 seconds.")); */ gtk_scale_set_draw_value(GTK_SCALE(mod->tmgSlider), FALSE); gtk_range_set_value(GTK_RANGE(mod->tmgSlider), 0.0); g_signal_connect(mod->tmgSlider, "value-changed", G_CALLBACK(slider_moved), mod); /* create the vertical box */ vbox = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), mod->tmgSlider, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); /* create main window */ mod->tmgWin = gtk_window_new(GTK_WINDOW_TOPLEVEL); title = g_strconcat(_("Time Controller"), " / ", mod->name, NULL); gtk_window_set_title(GTK_WINDOW(mod->tmgWin), title); g_free(title); gtk_window_set_transient_for(GTK_WINDOW(mod->tmgWin), GTK_WINDOW(gtk_widget_get_toplevel (GTK_WIDGET(mod)))); g_signal_connect(G_OBJECT(mod->tmgWin), "delete_event", G_CALLBACK(tmg_delete), mod); g_signal_connect(G_OBJECT(mod->tmgWin), "destroy", G_CALLBACK(tmg_destroy), mod); /* window icon */ buff = icon_file_name("gpredict-clock.png"); gtk_window_set_icon_from_file(GTK_WINDOW(mod->tmgWin), buff, NULL); g_free(buff); gtk_container_add(GTK_CONTAINER(mod->tmgWin), vbox); gtk_widget_show_all(mod->tmgWin); mod->tmgActive = TRUE; sat_log_log(SAT_LOG_LEVEL_INFO, _("%s: Time Controller for %s launched"), __func__, mod->name); }
/* Create the greyramp widget. Pass the initial value for the top and bottom spin buttons. If * 'swapValues' is true these will be swapped. */ GtkWidget* createGreyrampTool(DotterWindowContext *dwc, const int whitePointIn, const int blackPointIn, const gboolean swapValues, GtkWidget **greyrampWindow_out) { DEBUG_ENTER("createGreyrampTool"); /* Create the window */ GtkWidget *greyrampTool = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(greyrampTool), GTK_SHADOW_ETCHED_IN); /* Outer container is a table */ const int numRows = 5; const int numCols = 2; const int padding = 0; GtkTable *table = GTK_TABLE(gtk_table_new(numRows, numCols, FALSE)); gtk_container_add(GTK_CONTAINER(greyrampTool), GTK_WIDGET(table)); /* Create a layout for drawing the greyramp gradient onto. This will be in the first column, * spanning all rows */ GdkRectangle gradientRect; GtkWidget *gradientWidget = createGradientRect(greyrampTool, &gradientRect); gtk_table_attach(table, gradientWidget, 0, 1, 0, numRows, GTK_SHRINK, GTK_SHRINK, padding, padding); /* Create the toolbar and pack it into the parent */ const int whitePoint = swapValues ? blackPointIn : whitePointIn; const int blackPoint = swapValues ? whitePointIn : blackPointIn; GtkWidget *whiteSpinButton = createSpinButton(whitePoint + 1, G_CALLBACK(onWhiteSpinButtonChanged), greyrampTool); GtkWidget *blackSpinButton = createSpinButton(blackPoint + 1, G_CALLBACK(onBlackSpinButtonChanged), greyrampTool); createGreyrampToolbar(table, 1, greyrampTool, whiteSpinButton, blackSpinButton, blackPoint, whitePoint); GtkWidget *greyrampWindow = createGreyrampToolWindow(dwc, greyrampTool); greyrampCreateProperties(greyrampTool, greyrampWindow, dwc, &gradientRect, whiteSpinButton, blackSpinButton, blackPoint, whitePoint, 0, 255, swapValues); gtk_spin_button_set_value(GTK_SPIN_BUTTON(whiteSpinButton), (float)whitePoint); gtk_spin_button_set_value(GTK_SPIN_BUTTON(blackSpinButton), (float)blackPoint); gtk_widget_show_all(greyrampTool); updateGreyMap(greyrampTool); if (greyrampWindow_out) *greyrampWindow_out = greyrampWindow; DEBUG_EXIT("createGreyrampTool returning "); return greyrampTool; }
/** * dialog_init: * @state: * * Create the dialog (guru). * **/ static gboolean dialog_init (GoalSeekState *state) { GtkTable *table; state->dialog = glade_xml_get_widget (state->gui, "GoalSeek"); if (state->dialog == NULL) return TRUE; state->close_button = glade_xml_get_widget (state->gui, "closebutton"); g_signal_connect (G_OBJECT (state->close_button), "clicked", G_CALLBACK (cb_dialog_close_clicked), state); state->cancel_button = glade_xml_get_widget (state->gui, "cancelbutton"); g_signal_connect (G_OBJECT (state->cancel_button), "clicked", G_CALLBACK (cb_dialog_cancel_clicked), state); state->apply_button = glade_xml_get_widget (state->gui, "applybutton"); g_signal_connect (G_OBJECT (state->apply_button), "clicked", G_CALLBACK (cb_dialog_apply_clicked), state); gnumeric_init_help_button ( glade_xml_get_widget (state->gui, "helpbutton"), GNUMERIC_HELP_LINK_GOAL_SEEK); state->to_value_entry = glade_xml_get_widget (state->gui, "to_value_entry"); state->at_least_entry = glade_xml_get_widget (state->gui, "at_least-entry"); state->at_most_entry = glade_xml_get_widget (state->gui, "at_most-entry"); state->target_value_label = glade_xml_get_widget (state->gui, "target-value"); gtk_label_set_justify (GTK_LABEL (state->target_value_label), GTK_JUSTIFY_RIGHT); state->current_value_label = glade_xml_get_widget (state->gui, "current-value"); gtk_label_set_justify (GTK_LABEL (state->current_value_label), GTK_JUSTIFY_RIGHT); state->solution_label = glade_xml_get_widget (state->gui, "solution"); gtk_label_set_justify (GTK_LABEL (state->solution_label), GTK_JUSTIFY_RIGHT); state->result_label = glade_xml_get_widget (state->gui, "result-label"); state->result_table = glade_xml_get_widget (state->gui, "result-table"); table = GTK_TABLE (glade_xml_get_widget (state->gui, "goal-table")); state->set_cell_entry = gnm_expr_entry_new (state->wbcg, TRUE); gnm_expr_entry_set_flags (state->set_cell_entry, GNM_EE_SINGLE_RANGE | GNM_EE_FORCE_ABS_REF, GNM_EE_MASK); gtk_table_attach (table, GTK_WIDGET (state->set_cell_entry), 2, 3, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0); gnumeric_editable_enters (GTK_WINDOW (state->dialog), GTK_WIDGET (state->set_cell_entry)); dialog_preload_selection (state, state->set_cell_entry); gtk_widget_show (GTK_WIDGET (state->set_cell_entry)); state->change_cell_entry = gnm_expr_entry_new (state->wbcg, TRUE); gnm_expr_entry_set_flags (state->change_cell_entry, GNM_EE_SINGLE_RANGE | GNM_EE_FORCE_ABS_REF, GNM_EE_MASK); gtk_table_attach (table, GTK_WIDGET (state->change_cell_entry), 2, 3, 3, 4, GTK_EXPAND | GTK_FILL, 0, 0, 0); gnumeric_editable_enters (GTK_WINDOW (state->dialog), GTK_WIDGET (state->change_cell_entry)); dialog_preload_selection (state, state->change_cell_entry); gtk_widget_show (GTK_WIDGET (state->change_cell_entry)); g_signal_connect (G_OBJECT (state->dialog), "realize", G_CALLBACK (dialog_realized), state); state->old_value = NULL; state->old_cell = NULL; wbc_gtk_attach_guru (state->wbcg, state->dialog); g_object_set_data_full (G_OBJECT (state->dialog), "state", state, (GDestroyNotify) cb_dialog_destroy); gnm_expr_entry_grab_focus (state->set_cell_entry, FALSE); return FALSE; }
void create_vector_table_options_dialog (vector_table_options_D *dialog) { GtkWidget *tbl = NULL, *toolbar = NULL, *btn = NULL, *btnBaseRadioSource = NULL ; GtkAccelGroup *accel_group = NULL ; GtkTreeViewColumn *col = NULL ; GtkCellRenderer *cr = NULL ; accel_group = gtk_accel_group_new () ; dialog->dialog = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_modal (GTK_WINDOW (dialog->dialog), TRUE); gtk_window_set_title (GTK_WINDOW (dialog->dialog), _("Vector Table Setup")); gtk_window_set_resizable (GTK_WINDOW (dialog->dialog), TRUE) ; g_object_set_data (G_OBJECT (dialog->dialog), "dialog", dialog) ; tbl = gtk_table_new (2, 1, FALSE) ; gtk_widget_show (tbl) ; gtk_container_add (GTK_CONTAINER (dialog->dialog), tbl) ; toolbar = gtk_toolbar_new () ; gtk_widget_show (toolbar) ; gtk_table_attach (GTK_TABLE (tbl), toolbar, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0) ; gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar), GTK_ORIENTATION_HORIZONTAL) ; gtk_toolbar_set_tooltips (GTK_TOOLBAR (toolbar), TRUE) ; gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH) ; g_object_set_data (G_OBJECT (btn = gtk_toolbar_append_element ( GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("Close"), _("Close Window"), _("Close vector table editor."), gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_LARGE_TOOLBAR), (GCallback)vector_table_options_dialog_btnClose_clicked, NULL)), "dialog", dialog) ; gtk_widget_add_accelerator (btn, "clicked", accel_group, GDK_w, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE) ; gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)) ; #ifdef STDIO_FILEIO dialog->btnOpen = btn = gtk_toolbar_append_element ( GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("Open"), _("Open Vector Table"), _("Open and display another vector table."), gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_LARGE_TOOLBAR), (GCallback)vector_table_options_dialog_btnOpen_clicked, dialog) ; gtk_widget_add_accelerator (btn, "clicked", accel_group, GDK_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE) ; dialog->btnSave = btn = gtk_toolbar_append_element ( GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("Save"), _("Save Vector Table"), _("Save the displayed vector table."), gtk_image_new_from_stock (GTK_STOCK_SAVE, GTK_ICON_SIZE_LARGE_TOOLBAR), (GCallback)vector_table_options_dialog_btnSave_clicked, dialog->dialog) ; gtk_widget_add_accelerator (btn, "clicked", accel_group, GDK_s, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE) ; #endif /* def STDIO_FILEIO */ gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)) ; g_object_set_data (G_OBJECT ( dialog->tbtnExhaustive = btnBaseRadioSource = gtk_toolbar_append_element ( GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, NULL, _("Exhaustive"), _("Exhaustive Verification"), _("Attempt all possible inputs."), gtk_image_new_from_stock (GTK_STOCK_YES, GTK_ICON_SIZE_LARGE_TOOLBAR), (GCallback)vector_table_options_dialog_btnSimType_clicked, dialog)), "sim_type", (gpointer)EXHAUSTIVE_VERIFICATION) ; g_object_set_data (G_OBJECT ( dialog->tbtnVT = gtk_toolbar_append_element ( GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, btnBaseRadioSource, _("Vector Table"), _("Vector Table Simulation"), _("Create a sequence of inputs."), gtk_image_new_from_stock (GTK_STOCK_NO, GTK_ICON_SIZE_LARGE_TOOLBAR), (GCallback)vector_table_options_dialog_btnSimType_clicked, dialog)), "sim_type", (gpointer)VECTOR_TABLE) ; dialog->tblVT = gtk_table_new (1, 2, FALSE) ; gtk_widget_show (dialog->tblVT) ; gtk_table_attach (GTK_TABLE (tbl), dialog->tblVT, 0, 1, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0) ; toolbar = gtk_toolbar_new () ; gtk_widget_show (toolbar) ; gtk_table_attach (GTK_TABLE (dialog->tblVT), toolbar, 0, 1, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0) ; gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar), GTK_ORIENTATION_VERTICAL) ; gtk_toolbar_set_tooltips (GTK_TOOLBAR (toolbar), TRUE) ; gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS) ; dialog->btnAdd = btn = gtk_toolbar_append_element ( GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("Add"), _("Add Vector"), _("Apend a vector to the end of the table."), gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_LARGE_TOOLBAR), (GCallback)vector_table_options_dialog_btnAdd_clicked, dialog->dialog) ; dialog->btnInsert = btn = gtk_toolbar_append_element ( GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("Insert Before"), _("Insert Vector Before"), _("Insert vector before the selected one."), gtk_image_new_from_stock (QCAD_STOCK_INSERT_COL_BEFORE, GTK_ICON_SIZE_LARGE_TOOLBAR), (GCallback)vector_table_options_dialog_btnAdd_clicked, dialog->dialog) ; dialog->btnDelete = btn = gtk_toolbar_append_element ( GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("Delete Vector"), _("Delete Vector"), _("Insert the selected vector."), gtk_image_new_from_stock (GTK_STOCK_DELETE, GTK_ICON_SIZE_LARGE_TOOLBAR), (GCallback)vector_table_options_dialog_btnDelete_clicked, dialog->dialog) ; dialog->sw = qcad_tree_view_container_new () ; gtk_widget_show (dialog->sw) ; gtk_table_attach (GTK_TABLE (dialog->tblVT), dialog->sw, 1, 2, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 2, 2) ; gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (dialog->sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC) ; gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (dialog->sw), GTK_SHADOW_IN) ; dialog->tv = create_bus_layout_tree_view (TRUE, _("Inputs"), GTK_SELECTION_SINGLE) ; gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->tv), col = gtk_tree_view_column_new ()) ; gtk_tree_view_column_set_title (col, _("Active")) ; gtk_tree_view_column_pack_start (col, cr = dialog->crActive = gtk_cell_renderer_toggle_new (), TRUE) ; gtk_tree_view_column_add_attribute (col, cr, "active", VECTOR_TABLE_MODEL_COLUMN_ACTIVE) ; g_object_set (G_OBJECT (cr), "activatable", TRUE, NULL) ; gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (cr), TRUE) ; gtk_widget_show (dialog->tv) ; gtk_container_add (GTK_CONTAINER (dialog->sw), dialog->tv) ; qcad_tree_view_container_freeze_columns (QCAD_TREE_VIEW_CONTAINER (dialog->sw), 2) ; g_signal_connect (G_OBJECT (dialog->tv), "style-set", (GCallback)tree_view_style_set, NULL) ; g_signal_connect (G_OBJECT (cr), "toggled", (GCallback)vt_model_active_toggled, dialog->tv) ; g_signal_connect (G_OBJECT (dialog->dialog), "delete-event", (GCallback)vector_table_options_dialog_btnClose_clicked, NULL) ; gtk_window_add_accel_group (GTK_WINDOW (dialog->dialog), accel_group) ; }
void ags_automation_editor_init(AgsAutomationEditor *automation_editor) { GtkTable *table; GtkHPaned *paned; GtkScrolledWindow *scrolled_window; GtkNotebook *notebook; table = gtk_table_new(2, 2, FALSE); gtk_box_pack_start(GTK_BOX(automation_editor), GTK_WIDGET(table), TRUE, TRUE, 0); automation_editor->automation_toolbar = ags_automation_toolbar_new(); gtk_table_attach(table, GTK_WIDGET(automation_editor->automation_toolbar), 0, 2, 0, 1, GTK_FILL, 0, 0, 0); paned = (GtkHPaned *) gtk_hpaned_new(); gtk_table_attach(table, GTK_WIDGET(paned), 0, 2, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0); /* machine selector */ scrolled_window = (GtkScrolledWindow *) gtk_scrolled_window_new(NULL, NULL); gtk_paned_pack1((GtkPaned *) paned, (GtkWidget *) scrolled_window, FALSE, TRUE); automation_editor->machine_selector = ags_machine_selector_new(); gtk_scrolled_window_add_with_viewport(scrolled_window, (GtkWidget *) automation_editor->machine_selector); automation_editor->selected_machine = NULL; /**/ notebook = gtk_notebook_new(); gtk_paned_pack2((GtkPaned *) paned, (GtkWidget *) notebook, TRUE, FALSE); /* notebook and automation edit */ /* audio */ automation_editor->audio_table = (GtkTable *) gtk_table_new(4, 3, FALSE); gtk_notebook_append_page(notebook, automation_editor->audio_table, gtk_label_new("audio\0")); automation_editor->audio_automation_edit = NULL; /* output */ automation_editor->output_table = (GtkTable *) gtk_table_new(4, 3, FALSE); gtk_notebook_append_page(notebook, automation_editor->output_table, gtk_label_new("output\0")); automation_editor->output_automation_edit = NULL; automation_editor->output_notebook = ags_notebook_new(); automation_editor->output_notebook->flags |= (AGS_NOTEBOOK_SHOW_INPUT); gtk_table_attach(automation_editor->output_table, (GtkWidget *) automation_editor->output_notebook, 0, 3, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0); /* input */ automation_editor->input_table = (GtkTable *) gtk_table_new(4, 3, FALSE); gtk_notebook_append_page(notebook, automation_editor->input_table, gtk_label_new("input\0")); automation_editor->input_automation_edit = NULL; automation_editor->input_notebook = ags_notebook_new(); automation_editor->input_notebook->flags |= (AGS_NOTEBOOK_SHOW_INPUT); gtk_table_attach(automation_editor->input_table, (GtkWidget *) automation_editor->input_notebook, 0, 3, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0); }
/* Almost straigh out of glade2 */ GtkWidget* create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *table1; GtkWidget *label1; GtkWidget *label2; GtkWidget *label3; GtkWidget *label4; GtkWidget *hbox1; GtkWidget *label_sub; GtkWidget *button_sub; GtkWidget *image1; GtkWidget *hbox2; GtkWidget *label_font; GtkWidget *button_font; GtkWidget *image2; GtkWidget *optionmenu1; GtkWidget *menu1; GtkWidget *enc_ascii; /* GtkWidget *enc_8859; GtkWidget *ebc_cyrillic; GtkWidget *enc_german; */ GtkObject *spinbutton_fontsize_adj; GtkWidget *spinbutton_fontsize; GtkWidget *label5; GtkWidget *button_color; GtkWidget *hbox3; GtkWidget *drawingarea1; GtkWidget *vscale1; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *applybutton1; GtkWidget *okbutton1; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), _("Subtitle selector")); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0); table1 = gtk_table_new (5, 2, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (vbox1), table1, TRUE, TRUE, 0); label1 = gtk_label_new (_("Subtitle file ")); gtk_widget_show (label1); gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5); label2 = gtk_label_new (_("Font (TTF)")); gtk_widget_show (label2); gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); label3 = gtk_label_new (_("Encoding ")); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5); label4 = gtk_label_new (_("Font Size")); gtk_widget_show (label4); gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_table_attach (GTK_TABLE (table1), hbox1, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); label_sub = gtk_label_new (_("sub")); gtk_widget_show (label_sub); gtk_box_pack_start (GTK_BOX (hbox1), label_sub, TRUE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label_sub), GTK_JUSTIFY_LEFT); button_sub = gtk_button_new (); gtk_widget_show (button_sub); gtk_box_pack_start (GTK_BOX (hbox1), button_sub, FALSE, FALSE, 0); image1 = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image1); gtk_container_add (GTK_CONTAINER (button_sub), image1); hbox2 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox2); gtk_table_attach (GTK_TABLE (table1), hbox2, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); label_font = gtk_label_new (_("font")); gtk_widget_show (label_font); gtk_box_pack_start (GTK_BOX (hbox2), label_font, TRUE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label_font), GTK_JUSTIFY_LEFT); button_font = gtk_button_new (); gtk_widget_show (button_font); gtk_box_pack_start (GTK_BOX (hbox2), button_font, FALSE, FALSE, 0); image2 = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image2); gtk_container_add (GTK_CONTAINER (button_font), image2); optionmenu1 = gtk_option_menu_new (); gtk_widget_show (optionmenu1); gtk_table_attach (GTK_TABLE (table1), optionmenu1, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); menu1 = gtk_menu_new (); enc_ascii = gtk_menu_item_new_with_mnemonic (_("Ascii")); gtk_widget_show (enc_ascii); gtk_container_add (GTK_CONTAINER (menu1), enc_ascii); /* enc_8859 = gtk_menu_item_new_with_mnemonic (_("Iso 8859-1 (Czech...)")); gtk_widget_show (enc_8859); gtk_container_add (GTK_CONTAINER (menu1), enc_8859); ebc_cyrillic = gtk_menu_item_new_with_mnemonic (_("Cyrillic")); gtk_widget_show (ebc_cyrillic); gtk_container_add (GTK_CONTAINER (menu1), ebc_cyrillic); enc_german = gtk_menu_item_new_with_mnemonic (_("German")); gtk_widget_show (enc_german); gtk_container_add (GTK_CONTAINER (menu1), enc_german); */ gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1), menu1); spinbutton_fontsize_adj = gtk_adjustment_new (26, 8, 100, 1, 10, 10); spinbutton_fontsize = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton_fontsize_adj), 1, 0); gtk_widget_show (spinbutton_fontsize); gtk_table_attach (GTK_TABLE (table1), spinbutton_fontsize, 1, 2, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton_fontsize), TRUE); label5 = gtk_label_new (_("Select color")); gtk_widget_show (label5); gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5); button_color = gtk_button_new_with_mnemonic (_("Select")); gtk_widget_show (button_color); gtk_table_attach (GTK_TABLE (table1), button_color, 1, 2, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); hbox3 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox3); gtk_box_pack_start (GTK_BOX (vbox1), hbox3, TRUE, TRUE, 0); drawingarea1 = gtk_drawing_area_new (); gtk_widget_show (drawingarea1); gtk_box_pack_start (GTK_BOX (hbox3), drawingarea1, TRUE, TRUE, 0); gtk_widget_set_size_request (drawingarea1, 352, 288); vscale1 = gtk_vscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 1, 576, 1, 1, 1))); gtk_widget_show (vscale1); gtk_box_pack_start (GTK_BOX (hbox3), vscale1, FALSE, TRUE, 0); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); applybutton1 = gtk_button_new_from_stock ("gtk-apply"); gtk_widget_show (applybutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), applybutton1, GTK_RESPONSE_APPLY); GTK_WIDGET_SET_FLAGS (applybutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (dialog1, table1, "table1"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, label3, "label3"); GLADE_HOOKUP_OBJECT (dialog1, label4, "label4"); GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1"); GLADE_HOOKUP_OBJECT (dialog1, label_sub, "label_sub"); GLADE_HOOKUP_OBJECT (dialog1, button_sub, "button_sub"); GLADE_HOOKUP_OBJECT (dialog1, image1, "image1"); GLADE_HOOKUP_OBJECT (dialog1, hbox2, "hbox2"); GLADE_HOOKUP_OBJECT (dialog1, label_font, "label_font"); GLADE_HOOKUP_OBJECT (dialog1, button_font, "button_font"); GLADE_HOOKUP_OBJECT (dialog1, image2, "image2"); GLADE_HOOKUP_OBJECT (dialog1, optionmenu1, "optionmenu1"); GLADE_HOOKUP_OBJECT (dialog1, menu1, "menu1"); GLADE_HOOKUP_OBJECT (dialog1, enc_ascii, "enc_ascii"); /* GLADE_HOOKUP_OBJECT (dialog1, enc_8859, "enc_8859"); GLADE_HOOKUP_OBJECT (dialog1, ebc_cyrillic, "ebc_cyrillic"); GLADE_HOOKUP_OBJECT (dialog1, enc_german, "enc_german"); */ GLADE_HOOKUP_OBJECT (dialog1, spinbutton_fontsize, "spinbutton_fontsize"); GLADE_HOOKUP_OBJECT (dialog1, label5, "label5"); GLADE_HOOKUP_OBJECT (dialog1, button_color, "button_color"); GLADE_HOOKUP_OBJECT (dialog1, hbox3, "hbox3"); GLADE_HOOKUP_OBJECT (dialog1, drawingarea1, "drawingarea1"); GLADE_HOOKUP_OBJECT (dialog1, vscale1, "vscale1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (dialog1, applybutton1, "applybutton1"); GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1"); return dialog1; }
static gboolean unrotate_dialog(UnrotateArgs *args, GwyContainer *data, GwyDataField *dfield, gint id, gdouble *correction, GwyPlaneSymmetry guess) { enum { RESPONSE_RESET = 1 }; GtkWidget *dialog, *table, *label, *hbox; GwyPixmapLayer *layer; UnrotateControls controls; const gchar *s; gint response; gint row; controls.correction = correction; controls.guess = guess; controls.args = args; dialog = gtk_dialog_new_with_buttons(_("Correct Rotation"), NULL, 0, _("_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); gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT); hbox = gtk_hbox_new(FALSE, 8); gtk_container_set_border_width(GTK_CONTAINER(hbox), 4); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 4); table = gtk_table_new(4, 3, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_box_pack_start(GTK_BOX(hbox), table, FALSE, FALSE, 0); row = 0; gtk_table_attach(GTK_TABLE(table), gwy_label_new_header(_("Structure")), 0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); row++; label = gtk_label_new(_("Detected:")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); s = gwy_sgettext(gwy_enum_to_string(guess, gwy_plane_symmetry_get_enum(), -1)); label = gtk_label_new(_(s)); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); row++; controls.symmetry = gwy_enum_combo_box_new(gwy_plane_symmetry_get_enum(), -1, G_CALLBACK(unrotate_symmetry_cb), &controls, args->symmetry, TRUE); gwy_table_attach_row(table, row, _("_Assume:"), NULL, controls.symmetry); row++; label = gtk_label_new(_("Correction:")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); controls.corrlabel = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(controls.corrlabel), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), controls.corrlabel, 1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_table_set_row_spacing(GTK_TABLE(table), row, 8); row++; controls.interp = gwy_enum_combo_box_new(gwy_interpolation_type_get_enum(), -1, G_CALLBACK(unrotate_interp_cb), &controls, args->interp, TRUE); gwy_table_attach_row(table, row, _("_Interpolation type:"), "", controls.interp); controls.data = create_preview_data(data, dfield, id); controls.data_view = gwy_data_view_new(controls.data); g_object_unref(controls.data); layer = gwy_layer_basic_new(); gwy_pixmap_layer_set_data_key(layer, "/0/show"); gwy_layer_basic_set_gradient_key(GWY_LAYER_BASIC(layer), "/0/base/palette"); gwy_data_view_set_data_prefix(GWY_DATA_VIEW(controls.data_view), "/0/data"); gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.data_view), layer); gtk_box_pack_start(GTK_BOX(hbox), controls.data_view, FALSE, FALSE, 8); unrotate_dialog_update(&controls, args); gtk_widget_show_all(dialog); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: gtk_widget_destroy(dialog); case GTK_RESPONSE_NONE: return FALSE; break; case GTK_RESPONSE_OK: break; case RESPONSE_RESET: *args = unrotate_defaults; unrotate_dialog_update(&controls, args); break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); gtk_widget_destroy(dialog); return TRUE; }
static GtkWidget * normal_contents (void) { GtkWidget *table; GtkWidget *toolbar; GtkWidget *handlebox; GtkWidget *statusbar; GtkWidget *contents; GtkWidget *sw; GtkItemFactory *item_factory; table = gtk_table_new (1, 4, FALSE); /* Create the menubar */ item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", NULL); gtk_item_factory_set_translate_func(item_factory, (GtkTranslateFunc)gettext, NULL, NULL); /* Set up item factory to go away */ g_object_ref (item_factory); g_object_ref_sink (item_factory); g_object_unref (item_factory); g_object_set_data_full (G_OBJECT (table), "<main>", item_factory, (GDestroyNotify) g_object_unref); /* create menu items */ gtk_item_factory_create_items (item_factory, G_N_ELEMENTS (menu_items), menu_items, NULL); gtk_table_attach (GTK_TABLE (table), gtk_item_factory_get_widget (item_factory, "<main>"), /* X direction */ /* Y direction */ 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); /* Create the toolbar */ toolbar = gtk_toolbar_new (); GtkToolItem *newButton = gtk_tool_button_new_from_stock(GTK_STOCK_NEW); gtk_tool_item_set_tooltip_text(newButton, "Open another one of these windows"); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), newButton, -1); /*-1 means append to end of toolbar*/ GtkToolItem *openButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN); gtk_tool_item_set_tooltip_text(openButton, "This is a demo button with an \'open\' icon"); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), openButton, -1); /*-1 means append to end of toolbar*/ GtkToolItem *quitButton = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT); gtk_tool_item_set_tooltip_text(quitButton, "This is a demo button with a \'quit\' icon"); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), quitButton, -1); /*-1 means append to end of toolbar*/ handlebox = gtk_handle_box_new (); gtk_container_add (GTK_CONTAINER (handlebox), toolbar); gtk_table_attach (GTK_TABLE (table), handlebox, /* X direction */ /* Y direction */ 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0); /* Create document */ sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_table_attach (GTK_TABLE (table), sw, /* X direction */ /* Y direction */ 0, 1, 2, 3, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); contents = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents), PANGO_WRAP_WORD); gtk_container_add (GTK_CONTAINER (sw), contents); /* Create statusbar */ statusbar = gtk_statusbar_new (); gtk_table_attach (GTK_TABLE (table), statusbar, /* X direction */ /* Y direction */ 0, 1, 3, 4, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_widget_show_all (table); return table; }
static gboolean level_dialog(LevelArgs *args, const gchar *title) { enum { RESPONSE_RESET = 1 }; static const GwyEnum modes[] = { { N_("_Exclude region under mask"), LEVEL_EXCLUDE, }, { N_("Exclude region _outside mask"), LEVEL_INCLUDE, }, { N_("Use entire _image (ignore mask)"), LEVEL_NORMAL, }, }; GtkWidget *dialog, *label, *table; gint row, response; LevelControls controls; controls.args = args; dialog = gtk_dialog_new_with_buttons(title, NULL, 0, _("_Reset"), RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); table = gtk_table_new(12, 3, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), table); row = 0; label = gwy_label_new_header(_("Plane Fit Mode")); gtk_table_attach(GTK_TABLE(table), label, 0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); row++; controls.mode = gwy_radio_buttons_create(modes, G_N_ELEMENTS(modes), G_CALLBACK(mode_changed_cb), &controls, args->level_mode); row = gwy_radio_buttons_attach_to_table(controls.mode, GTK_TABLE(table), 3, row); gtk_widget_show_all(dialog); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: gtk_widget_destroy(dialog); case GTK_RESPONSE_NONE: return FALSE; break; case GTK_RESPONSE_OK: break; case RESPONSE_RESET: *args = level_defaults; gwy_radio_buttons_set_current(controls.mode, args->level_mode); break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); gtk_widget_destroy(dialog); return TRUE; }
GtkWidget* create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *table1; GtkWidget *label1; GtkWidget *label2; GtkWidget *label3; GtkWidget *label4; GtkObject *spinbuttonT_adj; GtkWidget *spinbuttonT; GtkObject *spinbuttonD_adj; GtkWidget *spinbuttonD; GtkObject *spinbuttonB_adj; GtkWidget *spinbuttonB; GtkWidget *checkbuttonBF; GtkWidget *hscale1; GtkWidget *drawingarea1; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("ASharp by MarcFD")); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0); table1 = gtk_table_new (4, 2, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (vbox1), table1, TRUE, TRUE, 0); label1 = gtk_label_new (QT_TR_NOOP("Threshold :")); gtk_widget_show (label1); gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5); label2 = gtk_label_new (QT_TR_NOOP("Strength :")); gtk_widget_show (label2); gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); label3 = gtk_label_new (QT_TR_NOOP("Block Adaptative :")); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5); label4 = gtk_label_new (QT_TR_NOOP("High Quality Block Filtering :")); gtk_widget_show (label4); gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5); spinbuttonT_adj = gtk_adjustment_new (1, -1, 100, 0.5, 0.1, 0); spinbuttonT = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonT_adj), 1, 1); gtk_widget_show (spinbuttonT); gtk_table_attach (GTK_TABLE (table1), spinbuttonT, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonT), TRUE); spinbuttonD_adj = gtk_adjustment_new (1, -1, 100, 0.5, 0.1, 0); spinbuttonD = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonD_adj), 1, 1); gtk_widget_show (spinbuttonD); gtk_table_attach (GTK_TABLE (table1), spinbuttonD, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonD), TRUE); spinbuttonB_adj = gtk_adjustment_new (1, -1, 100, 0.5, 0.1, 0); spinbuttonB = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonB_adj), 1, 1); gtk_widget_show (spinbuttonB); gtk_table_attach (GTK_TABLE (table1), spinbuttonB, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonB), TRUE); checkbuttonBF = gtk_check_button_new_with_mnemonic (QT_TR_NOOP(" ")); gtk_widget_show (checkbuttonBF); gtk_table_attach (GTK_TABLE (table1), checkbuttonBF, 1, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 100, 1, 1, 0))); gtk_widget_show (hscale1); gtk_box_pack_start (GTK_BOX (vbox1), hscale1, TRUE, TRUE, 0); drawingarea1 = gtk_drawing_area_new (); gtk_widget_show (drawingarea1); gtk_box_pack_start (GTK_BOX (vbox1), drawingarea1, TRUE, TRUE, 0); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (dialog1, table1, "table1"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, label3, "label3"); GLADE_HOOKUP_OBJECT (dialog1, label4, "label4"); GLADE_HOOKUP_OBJECT (dialog1, spinbuttonT, "spinbuttonT"); GLADE_HOOKUP_OBJECT (dialog1, spinbuttonD, "spinbuttonD"); GLADE_HOOKUP_OBJECT (dialog1, spinbuttonB, "spinbuttonB"); GLADE_HOOKUP_OBJECT (dialog1, checkbuttonBF, "checkbuttonBF"); GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1"); GLADE_HOOKUP_OBJECT (dialog1, drawingarea1, "drawingarea1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1"); return dialog1; }
static gboolean dwt_denoise_dialog(DWTDenoiseArgs *args) { GtkWidget *dialog, *table; DWTDenoiseControls controls; enum { RESPONSE_RESET = 1 }; gint response; dialog = gtk_dialog_new_with_buttons(_("2D DWT Denoise"), NULL, 0, _("_Reset"), RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); table = gtk_table_new(2, 5, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, FALSE, FALSE, 4); controls.preserve = gtk_check_button_new_with_mnemonic(_("_Preserve size (don't " "resize to power of 2)")); gtk_table_attach(GTK_TABLE(table), controls.preserve, 0, 3, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.preserve), args->preserve); g_signal_connect(controls.preserve, "toggled", G_CALLBACK(preserve_changed_cb), args); controls.interp = gwy_enum_combo_box_new(gwy_interpolation_type_get_enum(), -1, G_CALLBACK(gwy_enum_combo_box_update_int), &args->interp, args->interp, TRUE); gwy_table_attach_row(table, 1, _("_Interpolation type:"), "", controls.interp); controls.wavelet = gwy_enum_combo_box_new(gwy_dwt_type_get_enum(), -1, G_CALLBACK(gwy_enum_combo_box_update_int), &args->wavelet, args->wavelet, TRUE); gwy_table_attach_row(table, 2, _("_Wavelet type:"), "", controls.wavelet); controls.method = gwy_enum_combo_box_new(gwy_dwt_denoise_type_get_enum(), -1, G_CALLBACK(gwy_enum_combo_box_update_int), &args->method, args->method, TRUE); gwy_table_attach_row(table, 3, _("T_hreshold:"), "", controls.method); gtk_widget_show_all(dialog); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: gtk_widget_destroy(dialog); case GTK_RESPONSE_NONE: return FALSE; break; case GTK_RESPONSE_OK: break; case RESPONSE_RESET: *args = dwt_denoise_defaults; dwt_denoise_dialog_update(&controls, args); break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); gtk_widget_destroy(dialog); return TRUE; }
void create_login (HWND hwnd, LPCSTR username, LPCSTR password, LPCSTR dsn, TLOGIN *log_t) { GtkWidget *login; GtkWidget *dialog_vbox8; GtkWidget *frame99; GtkWidget *alignment83; GtkWidget *table9; GtkWidget *label165; GtkWidget *t_user; GtkWidget *t_password; GtkWidget *label164; GtkWidget *dialog_action_area8; GtkWidget *b_ok; GtkWidget *b_cancel; char buff[1024]; if (hwnd == (HWND) - 1L) { gtk_init (0, NULL); hwnd = gtk_window_new (GTK_WINDOW_TOPLEVEL); } if (hwnd == NULL || !GTK_IS_WIDGET (hwnd)) return; login = gtk_dialog_new (); gtk_widget_set_name (login, "login"); gtk_widget_set_size_request (login, 400, 150); sprintf (buff, "Login for DSN %s ...", (dsn) ? dsn : "Unknown"); gtk_window_set_title (GTK_WINDOW (login), buff); gtk_window_set_position (GTK_WINDOW (login), GTK_WIN_POS_CENTER); gtk_window_set_modal (GTK_WINDOW (login), TRUE); gtk_window_set_default_size (GTK_WINDOW (login), 400, 150); gtk_window_set_type_hint (GTK_WINDOW (login), GDK_WINDOW_TYPE_HINT_DIALOG); #if GTK_CHECK_VERSION(2,0,0) gtk_widget_show (login); #endif dialog_vbox8 = GTK_DIALOG (login)->vbox; gtk_widget_set_name (dialog_vbox8, "dialog_vbox8"); gtk_widget_show (dialog_vbox8); frame99 = gtk_frame_new (NULL); gtk_widget_set_name (frame99, "frame99"); gtk_widget_show (frame99); gtk_box_pack_start (GTK_BOX (dialog_vbox8), frame99, TRUE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame99), GTK_SHADOW_NONE); alignment83 = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_set_name (alignment83, "alignment83"); gtk_widget_show (alignment83); gtk_container_add (GTK_CONTAINER (frame99), alignment83); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment83), 4, 0, 6, 7); table9 = gtk_table_new (2, 2, FALSE); gtk_widget_set_name (table9, "table9"); gtk_widget_show (table9); gtk_container_add (GTK_CONTAINER (alignment83), table9); gtk_table_set_row_spacings (GTK_TABLE (table9), 10); gtk_table_set_col_spacings (GTK_TABLE (table9), 6); label165 = gtk_label_new (_("Password :"******"label165"); gtk_widget_show (label165); gtk_table_attach (GTK_TABLE (table9), label165, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label165), 0, 0.5); t_user = gtk_entry_new (); gtk_widget_set_name (t_user, "t_user"); gtk_widget_show (t_user); gtk_table_attach (GTK_TABLE (table9), t_user, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); if (username && STRLEN (username)) gtk_entry_set_text (GTK_ENTRY (t_user), username); t_password = gtk_entry_new (); gtk_widget_set_name (t_password, "t_password"); gtk_widget_show (t_password); gtk_table_attach (GTK_TABLE (table9), t_password, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_entry_set_visibility (GTK_ENTRY (t_password), FALSE); if (password && STRLEN (password)) gtk_entry_set_text (GTK_ENTRY (t_password), password); label164 = gtk_label_new (_("Username :"******"label164"); gtk_widget_show (label164); gtk_table_attach (GTK_TABLE (table9), label164, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label164), 0, 0.5); dialog_action_area8 = GTK_DIALOG (login)->action_area; gtk_widget_set_name (dialog_action_area8, "dialog_action_area8"); gtk_widget_show (dialog_action_area8); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area8), GTK_BUTTONBOX_END); b_cancel = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_set_name (b_cancel, "b_cancel"); gtk_widget_show (b_cancel); gtk_dialog_add_action_widget (GTK_DIALOG (login), b_cancel, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (b_cancel, GTK_CAN_DEFAULT); b_ok = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_set_name (b_ok, "b_ok"); gtk_widget_show (b_ok); gtk_dialog_add_action_widget (GTK_DIALOG (login), b_ok, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (b_ok, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (login, login, "login"); GLADE_HOOKUP_OBJECT_NO_REF (login, dialog_vbox8, "dialog_vbox8"); GLADE_HOOKUP_OBJECT (login, frame99, "frame99"); GLADE_HOOKUP_OBJECT (login, alignment83, "alignment83"); GLADE_HOOKUP_OBJECT (login, table9, "table9"); GLADE_HOOKUP_OBJECT (login, label165, "label165"); GLADE_HOOKUP_OBJECT (login, t_user, "t_user"); GLADE_HOOKUP_OBJECT (login, t_password, "t_password"); GLADE_HOOKUP_OBJECT (login, label164, "label164"); GLADE_HOOKUP_OBJECT_NO_REF (login, dialog_action_area8, "dialog_action_area8"); GLADE_HOOKUP_OBJECT (login, b_ok, "b_ok"); GLADE_HOOKUP_OBJECT (login, b_cancel, "b_cancel"); /* Ok button events */ gtk_signal_connect (GTK_OBJECT (b_ok), "clicked", GTK_SIGNAL_FUNC (login_ok_clicked), log_t); /* Cancel button events */ gtk_signal_connect (GTK_OBJECT (b_cancel), "clicked", GTK_SIGNAL_FUNC (login_cancel_clicked), log_t); /* Close window button events */ gtk_signal_connect (GTK_OBJECT (login), "delete_event", GTK_SIGNAL_FUNC (delete_event), log_t); gtk_signal_connect (GTK_OBJECT (login), "destroy", GTK_SIGNAL_FUNC (gtk_main_quit), NULL); log_t->username = t_user; log_t->password = t_password; log_t->user = log_t->pwd = NULL; log_t->mainwnd = login; gtk_widget_show_all (login); gtk_main (); }