/** * Create and run preferences dialog. * * The preferences dialog contains a GtkNoteBook, which is used to group * the various configuration parts/modules (General, Modules, Interfaces, ...). * Each configuration part can contain several subgroups that are managed * by the module itself. As an example, consider the "Modules" tab which * could have the following sub-groups: General, List View, Map View and so on. * The tabs of the notebook are invisible, instead a vertical icon list * placed on the left of the notebook is used to navigate through the * notebook pages. The icon list is actually impemented using pixmap buttons * in a button box. Using something like the GtkIconView would have been better * but that seems to be rather useless when packed into a box. */ void sat_pref_run() { GtkWidget *nbook; /* notebook widget */ GtkWidget *hbox; /* horizontal box */ GtkWidget *butbox; GtkWidget *genbut, *modbut, *ifbut, *predbut; gchar *iconfile; gint response; /* Create notebook and add individual pages. The individual pages will need the GKeyFile */ nbook = gtk_notebook_new(); gtk_notebook_append_page(GTK_NOTEBOOK(nbook), sat_pref_general_create(), gtk_label_new(_("General"))); gtk_notebook_append_page(GTK_NOTEBOOK(nbook), sat_pref_modules_create(NULL), gtk_label_new(_("Modules"))); gtk_notebook_append_page(GTK_NOTEBOOK(nbook), sat_pref_interfaces_create(), gtk_label_new(_("Interfaces"))); gtk_notebook_append_page(GTK_NOTEBOOK(nbook), sat_pref_predict_create(), gtk_label_new(_("Predict"))); gtk_notebook_set_show_tabs(GTK_NOTEBOOK(nbook), FALSE); gtk_notebook_set_show_border(GTK_NOTEBOOK(nbook), FALSE); /* create a button box and add the buttons one by one */ genbut = gpredict_vpixmap_button("gpredict-sat-pref.png", _("General"), NULL); gtk_button_set_relief(GTK_BUTTON(genbut), GTK_RELIEF_NONE); g_object_set_data(G_OBJECT(genbut), "page", GINT_TO_POINTER(NBOOK_PAGE_GENERAL)); g_signal_connect(G_OBJECT(genbut), "clicked", G_CALLBACK(button_press_cb), nbook); modbut = gpredict_vpixmap_button("gpredict-sat-list.png", _("Modules"), NULL); gtk_button_set_relief(GTK_BUTTON(modbut), GTK_RELIEF_NONE); g_object_set_data(G_OBJECT(modbut), "page", GINT_TO_POINTER(NBOOK_PAGE_MODULES)); g_signal_connect(G_OBJECT(modbut), "clicked", G_CALLBACK(button_press_cb), nbook); ifbut = gpredict_vpixmap_button("gpredict-oscilloscope.png", _("Interfaces"), NULL); gtk_button_set_relief(GTK_BUTTON(ifbut), GTK_RELIEF_NONE); g_object_set_data(G_OBJECT(ifbut), "page", GINT_TO_POINTER(NBOOK_PAGE_INTERFACE)); g_signal_connect(G_OBJECT(ifbut), "clicked", G_CALLBACK(button_press_cb), nbook); predbut = gpredict_vpixmap_button("gpredict-calendar.png", _("Predict"), NULL); gtk_button_set_relief(GTK_BUTTON(predbut), GTK_RELIEF_NONE); g_object_set_data(G_OBJECT(predbut), "page", GINT_TO_POINTER(NBOOK_PAGE_PREDICT)); g_signal_connect(G_OBJECT(predbut), "clicked", G_CALLBACK(button_press_cb), nbook); butbox = gtk_vbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(butbox), GTK_BUTTONBOX_START); gtk_container_add(GTK_CONTAINER(butbox), genbut); gtk_container_add(GTK_CONTAINER(butbox), modbut); gtk_container_add(GTK_CONTAINER(butbox), ifbut); gtk_container_add(GTK_CONTAINER(butbox), predbut); /* create horizontal box which will contain the icon list on the left side and the notebook on the right side. */ hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), butbox, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), nbook, TRUE, TRUE, 0); gtk_widget_show_all(hbox); /* create and display preferences window */ window = gtk_dialog_new_with_buttons(_("Gpredict Preferences :: General"), GTK_WINDOW(app), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); iconfile = icon_file_name("gpredict-sat-pref.png"); gtk_window_set_icon_from_file(GTK_WINDOW(window), iconfile, NULL); g_free(iconfile); gtk_box_pack_start(GTK_BOX (gtk_dialog_get_content_area(GTK_DIALOG(window))), hbox, TRUE, TRUE, 0); gtk_box_set_spacing(GTK_BOX (gtk_dialog_get_content_area(GTK_DIALOG(window))), 10); gtk_button_clicked(GTK_BUTTON(genbut)); response = gtk_dialog_run(GTK_DIALOG(window)); switch (response) { case GTK_RESPONSE_ACCEPT: sat_pref_general_ok(); sat_pref_modules_ok(NULL); sat_pref_interfaces_ok(); sat_pref_predict_ok(); sat_cfg_save(); break; default: sat_pref_general_cancel(); sat_pref_modules_cancel(NULL); sat_pref_interfaces_cancel(); sat_pref_predict_cancel(); break; } gtk_widget_destroy(window); }
static void git_repository_selector_init (GitRepositorySelector *self) { GtkWidget *button_hbox; GtkWidget *remote_hbox; GtkWidget *label; self->priv = g_new0 (GitRepositorySelectorPriv, 1); /* Mode selector buttons. Allows the user to use a selected remote or * enter a URL. */ button_hbox = gtk_hbox_new (TRUE, 0); /* Remote toggle button */ self->priv->remote_toggle = gtk_radio_button_new_with_label (NULL, _("Remote")); g_object_set (G_OBJECT (self->priv->remote_toggle), "draw-indicator", FALSE, NULL); gtk_box_pack_start (GTK_BOX (button_hbox), self->priv->remote_toggle, TRUE, TRUE, 0); g_object_set_data (G_OBJECT (self->priv->remote_toggle), "mode", GINT_TO_POINTER (GIT_REPOSITORY_SELECTOR_REMOTE)); g_signal_connect (G_OBJECT (self->priv->remote_toggle), "toggled", G_CALLBACK (on_mode_button_toggled), self); /* URL toggle button */ self->priv->url_toggle = gtk_radio_button_new_with_label (gtk_radio_button_get_group (GTK_RADIO_BUTTON (self->priv->remote_toggle)), _("URL")); g_object_set (G_OBJECT (self->priv->url_toggle), "draw-indicator", FALSE, NULL); gtk_box_pack_start (GTK_BOX (button_hbox), self->priv->url_toggle, TRUE, TRUE, 0); g_object_set_data (G_OBJECT (self->priv->url_toggle), "mode", GINT_TO_POINTER (GIT_REPOSITORY_SELECTOR_URL)); g_signal_connect (G_OBJECT (self->priv->url_toggle), "toggled", G_CALLBACK (on_mode_button_toggled), self); gtk_box_pack_start (GTK_BOX (self), button_hbox, FALSE, FALSE, 0); /* Selected remote label */ remote_hbox = gtk_hbox_new (FALSE, 2); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), _("<b>Selected Remote:</b>")); gtk_box_pack_start (GTK_BOX (remote_hbox), label, FALSE, FALSE, 0); self->priv->selected_remote_label = gtk_label_new (NULL); g_object_set (G_OBJECT (self->priv->selected_remote_label), "xalign", 0.0f, NULL); gtk_box_pack_start (GTK_BOX (remote_hbox), self->priv->selected_remote_label, TRUE, TRUE, 0); /* URL entry */ self->priv->url_entry = gtk_entry_new (); /* Notebook */ self->priv->notebook = gtk_notebook_new (); gtk_notebook_set_show_border (GTK_NOTEBOOK (self->priv->notebook), FALSE); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (self->priv->notebook), FALSE); gtk_notebook_append_page (GTK_NOTEBOOK (self->priv->notebook), remote_hbox, NULL); gtk_notebook_append_page (GTK_NOTEBOOK (self->priv->notebook), self->priv->url_entry, NULL); gtk_box_pack_start (GTK_BOX (self), self->priv->notebook, TRUE, TRUE, 0); /* Set the selected repository label to a resonable default. */ git_repository_selector_set_remote (self, NULL); /* Allow focusing */ gtk_widget_set_can_focus (GTK_WIDGET (self), TRUE); gtk_widget_show_all (GTK_WIDGET (self)); }
static void main_window_fill_panes(void) { GtkWidget *box; GtkWidget *box2; GtkWidget *chkOnlyCurFileFuncs; GtkCellRenderer *renderer; GtkTreeViewColumn *column; //Commented out as panes aren't used yet AJ 2003-01-21 TODO: replace old style code with new main_window.* code /*notebook_manager = gtk_notebook_new (); gtk_widget_show (notebook_manager); gtk_paned_pack1 (GTK_PANED (hpaned1), notebook_manager, FALSE, TRUE); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook_manager), GTK_POS_BOTTOM); gtk_widget_set_usize(notebook_manager,200,400);*/ box = gtk_vbox_new(FALSE, 0); gtk_widget_show(box); gtk_paned_pack1 (GTK_PANED (main_window.main_horizontal_pane), box, FALSE, TRUE); //add checkbox to show only current file's classes //the signals to be checked for the check box are onclick of the checkbox //and the on change of the file. //Close button for the side bar GtkWidget *hbox; hbox = gtk_hbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(hbox), 0); main_window.close_image = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU); gtk_misc_set_padding(GTK_MISC(main_window.close_image), 0, 0); main_window.close_sidebar_button = gtk_button_new(); gtk_widget_set_tooltip_text(main_window.close_sidebar_button, _("Close class Browser")); gtk_button_set_image(GTK_BUTTON(main_window.close_sidebar_button), main_window.close_image); gtk_button_set_relief(GTK_BUTTON(main_window.close_sidebar_button), GTK_RELIEF_NONE); gtk_button_set_focus_on_click(GTK_BUTTON(main_window.close_sidebar_button), FALSE); gtk_signal_connect(GTK_OBJECT(main_window.close_sidebar_button), "clicked", G_CALLBACK (classbrowser_show_hide),NULL); gtk_widget_show(main_window.close_image); gtk_widget_show(main_window.close_sidebar_button); // main_window.chkOnlyCurFileFuncs = gtk_check_button_new_with_label(_("Parse only current file")); gtk_widget_show (main_window.chkOnlyCurFileFuncs); gtk_box_pack_start(GTK_BOX(hbox), main_window.chkOnlyCurFileFuncs, FALSE, FALSE, 10); // gtk_box_pack_start(GTK_BOX(box), main_window.chkOnlyCurFileFuncs, FALSE, FALSE, 10); gtk_box_pack_start(GTK_BOX(hbox), main_window.close_sidebar_button, FALSE, FALSE, 0); gtk_widget_show(hbox); gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 10); g_signal_connect (G_OBJECT (main_window.chkOnlyCurFileFuncs), "clicked", G_CALLBACK (on_parse_current_click), NULL); main_window.scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (main_window.scrolledwindow3); gtk_box_pack_start(GTK_BOX(box), main_window.scrolledwindow3, TRUE, TRUE, 0); gtk_paned_pack1 (GTK_PANED (main_window.main_horizontal_pane), main_window.scrolledwindow3, FALSE, TRUE); box2 = gtk_hbox_new(FALSE, 0); gtk_widget_show(box2); main_window.treeviewlabel = gtk_label_new(_("FILE: ")); gtk_label_set_justify(GTK_LABEL(main_window.treeviewlabel), GTK_JUSTIFY_LEFT); gtk_widget_show(main_window.treeviewlabel); gtk_box_pack_start(GTK_BOX(box2), main_window.treeviewlabel, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(box), box2, FALSE, FALSE, 4); //gtk_container_add (GTK_CONTAINER (notebook_manager), main_window.scrolledwindow3); main_window.classtreestore = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT); //enable sorting of the columns classbrowser_set_sortable(main_window.classtreestore); main_window.classtreeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (main_window.classtreestore)); gtk_widget_show (main_window.classtreeview); gtk_container_add (GTK_CONTAINER (main_window.scrolledwindow3), main_window.classtreeview); main_window.classtreeselect = gtk_tree_view_get_selection (GTK_TREE_VIEW (main_window.classtreeview)); gtk_tree_selection_set_mode (main_window.classtreeselect, GTK_SELECTION_SINGLE); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Name"), renderer, "text", NAME_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (main_window.classtreeview), column); /*label1 = gtk_label_new ("Functions"); gtk_widget_show (label1); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook_manager), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook_manager), 0), label1); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); notebook_manager_functions_page = gtk_vbox_new (FALSE, 0); gtk_widget_show (notebook_manager_functions_page); gtk_container_add (GTK_CONTAINER (notebook_manager), notebook_manager_functions_page); label2 = gtk_label_new ("Files"); gtk_widget_show (label2); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook_manager), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook_manager), 1), label2); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); notebook_manager_files_page = gtk_vbox_new (FALSE, 0); gtk_widget_show (notebook_manager_files_page); gtk_container_add (GTK_CONTAINER (notebook_manager), notebook_manager_files_page); label3 = gtk_label_new ("Help"); gtk_widget_show (label3); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook_manager), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook_manager), 2), label3); gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT); */ main_window.scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL); gtk_paned_pack2 (GTK_PANED (main_window.main_vertical_pane), main_window.scrolledwindow1, FALSE, TRUE); main_window.lint_view = gtk_tree_view_new (); gtk_container_add (GTK_CONTAINER (main_window.scrolledwindow1), main_window.lint_view); main_window.lint_renderer = gtk_cell_renderer_text_new (); main_window.lint_column = gtk_tree_view_column_new_with_attributes (_("Syntax Check Output"), main_window.lint_renderer, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (main_window.lint_view), main_window.lint_column); //gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (main_window.lint_view), FALSE); gtk_widget_set_usize(main_window.lint_view,80,80); main_window.lint_select = gtk_tree_view_get_selection (GTK_TREE_VIEW (main_window.lint_view)); gtk_tree_selection_set_mode (main_window.lint_select, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (main_window.lint_select), "changed", G_CALLBACK (lint_row_activated), NULL); main_window.notebook_editor = gtk_notebook_new (); gtk_notebook_set_scrollable(GTK_NOTEBOOK(main_window.notebook_editor), TRUE); //GTK_WIDGET_UNSET_FLAGS (main_window.notebook_editor, GTK_CAN_FOCUS | GTK_RECEIVES_DEFAULT); // Fix to scrollable list of tabs, however it then messes up grabbing of focus // Hence the focus-tab event (which GTK doesn't seem to recognise GTK_WIDGET_UNSET_FLAGS (main_window.notebook_editor, GTK_RECEIVES_DEFAULT); gtk_widget_show (main_window.notebook_editor); gtk_paned_pack2 (GTK_PANED (main_window.main_horizontal_pane), main_window.notebook_editor, TRUE, TRUE); gtk_widget_set_usize(main_window.notebook_editor,400,400); g_signal_connect (G_OBJECT (main_window.notebook_editor), "switch_page", GTK_SIGNAL_FUNC (on_notebook_switch_page), NULL); g_signal_connect (G_OBJECT (main_window.notebook_editor), "focus-tab", GTK_SIGNAL_FUNC (on_notebook_focus_tab), NULL); }
GtkWidget* ctk_display_device_new(NvCtrlAttributeHandle *handle, CtkConfig *ctk_config, CtkEvent *ctk_event, CtkEvent *ctk_event_gpu, char *name, char *typeBaseName, ParsedAttribute *p) { GObject *object; CtkDisplayDevice *ctk_object; GtkWidget *banner; GtkWidget *hbox, *tmpbox; GtkWidget *alignment; GtkWidget *notebook; GtkWidget *nbox; GtkWidget *align; GtkWidget *label; GtkWidget *hseparator; GtkWidget *button; gchar *str; int i; object = g_object_new(CTK_TYPE_DISPLAY_DEVICE, NULL); if (!object) return NULL; ctk_object = CTK_DISPLAY_DEVICE(object); ctk_object->handle = handle; ctk_object->ctk_event = ctk_event; ctk_object->ctk_event_gpu = ctk_event_gpu; ctk_object->ctk_config = ctk_config; ctk_object->name = g_strdup(name); ctk_object->color_correction_available = FALSE; gtk_box_set_spacing(GTK_BOX(object), 10); /* Banner */ if (strcmp(typeBaseName, "CRT") == 0) { banner = ctk_banner_image_new(BANNER_ARTWORK_CRT); } else { banner = ctk_banner_image_new(BANNER_ARTWORK_DFP); } gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0); /* Create tabbed notebook for widget */ notebook = gtk_notebook_new(); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP); gtk_box_pack_start(GTK_BOX(object), notebook, TRUE, TRUE, 0); /* Create first tab for device info */ nbox = gtk_vbox_new(FALSE, FRAME_PADDING); gtk_container_set_border_width(GTK_CONTAINER(nbox), FRAME_PADDING); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), nbox, gtk_label_new("Information")); /* Device info */ hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(nbox), hbox, FALSE, FALSE, 0); label = gtk_label_new("Display Device Information"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hseparator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5); /* create the hbox to store device info */ hbox = gtk_hbox_new(FALSE, FRAME_PADDING); gtk_box_pack_start(GTK_BOX(nbox), hbox, FALSE, FALSE, FRAME_PADDING); /* * insert a vbox between the frame and the widgets, so that the * widgets don't expand to fill all of the space within the * frame */ tmpbox = gtk_vbox_new(FALSE, FRAME_PADDING); gtk_container_set_border_width(GTK_CONTAINER(tmpbox), FRAME_PADDING); gtk_container_add(GTK_CONTAINER(hbox), tmpbox); /* Create and add the information widgets */ ctk_object->num_info_entries = ARRAY_LEN(__info_entry_data); ctk_object->info_entries = calloc(ctk_object->num_info_entries, sizeof(InfoEntry)); if (!ctk_object->info_entries) { ctk_object->num_info_entries = 0; } for (i = 0; i < ctk_object->num_info_entries; i++) { InfoEntryData *entryData = __info_entry_data+i; InfoEntry *entry = ctk_object->info_entries+i; gchar *str; entry->ctk_object = ctk_object; str = g_strconcat(entryData->str, ":", NULL); entry->label = gtk_label_new(str); g_free(str); entry->txt = gtk_label_new(""); gtk_misc_set_alignment(GTK_MISC(entry->label), 0.0f, 0.5f); gtk_misc_set_alignment(GTK_MISC(entry->txt), 0.0f, 0.5f); ctk_config_set_tooltip(ctk_config, entry->label, *(entryData->tooltip)); ctk_config_set_tooltip(ctk_config, entry->txt, *(entryData->tooltip)); entry->hbox = gtk_hbox_new(FALSE, FRAME_PADDING); gtk_box_pack_start(GTK_BOX(entry->hbox), entry->label, FALSE, TRUE, FRAME_PADDING); gtk_box_pack_start(GTK_BOX(entry->hbox), entry->txt, FALSE, TRUE, FRAME_PADDING); gtk_box_pack_start(GTK_BOX(tmpbox), entry->hbox, FALSE, FALSE, 0); } /* pack the EDID button */ ctk_object->edid = ctk_edid_new(ctk_object->handle, ctk_object->ctk_config, ctk_object->ctk_event, ctk_object->name); hbox = gtk_hbox_new(FALSE, 0); align = gtk_alignment_new(0, 1, 1, 1); gtk_container_add(GTK_CONTAINER(align), hbox); gtk_box_pack_end(GTK_BOX(nbox), align, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), ctk_object->edid, TRUE, TRUE, 0); /* * Create layout for second tab for controls but don't add the tab until we * make sure it's required */ nbox = gtk_vbox_new(FALSE, FRAME_PADDING); gtk_container_set_border_width(GTK_CONTAINER(nbox), FRAME_PADDING); /* pack the reset button */ button = gtk_button_new_with_label("Reset Hardware Defaults"); str = ctk_help_create_reset_hardware_defaults_text(typeBaseName, name); ctk_config_set_tooltip(ctk_config, button, str); ctk_object->reset_button = button; alignment = gtk_alignment_new(1, 1, 0, 0); gtk_container_add(GTK_CONTAINER(alignment), button); gtk_box_pack_end(GTK_BOX(nbox), alignment, FALSE, FALSE, 0); /* pack the color controls */ ctk_object->color_controls = ctk_color_controls_new(handle, ctk_config, ctk_event, ctk_object->reset_button, name); if (ctk_object->color_controls) { gtk_box_pack_start(GTK_BOX(nbox), ctk_object->color_controls, FALSE, FALSE, 0); } /* pack the dithering controls */ ctk_object->dithering_controls = ctk_dithering_controls_new(handle, ctk_config, ctk_event, ctk_object->reset_button, name); if (ctk_object->dithering_controls) { gtk_box_pack_start(GTK_BOX(nbox), ctk_object->dithering_controls, FALSE, FALSE, 0); } /* pack the image sliders */ ctk_object->image_sliders = ctk_image_sliders_new(handle, ctk_config, ctk_event, ctk_object->reset_button, name); if (ctk_object->image_sliders) { gtk_box_pack_start(GTK_BOX(nbox), ctk_object->image_sliders, FALSE, FALSE, 0); } /* If no controls are created, don't add a controls tab */ if (ctk_object->color_controls || ctk_object->dithering_controls || ctk_object->image_sliders) { gtk_notebook_append_page(GTK_NOTEBOOK(notebook), nbox, gtk_label_new("Controls")); } /* * Show all widgets on this page so far. After this, the color correction * tab and other widgets can control their own visibility. */ gtk_widget_show_all(GTK_WIDGET(object)); /* add the color correction tab if RandR is available */ add_color_correction_tab(ctk_object, ctk_config, ctk_event, notebook, p); /* Update the GUI */ display_device_setup(ctk_object); /* Listen to events */ g_signal_connect(G_OBJECT(ctk_object->reset_button), "clicked", G_CALLBACK(reset_button_clicked), (gpointer) ctk_object); g_signal_connect(G_OBJECT(ctk_event_gpu), CTK_EVENT_NAME(NV_CTRL_ENABLED_DISPLAYS), G_CALLBACK(enabled_displays_received), (gpointer) ctk_object); for (i = 0; i < ctk_object->num_info_entries; i++) { InfoEntryData *entryData = __info_entry_data+i; InfoEntry *entry = ctk_object->info_entries+i; if (entryData->register_events_func) { entryData->register_events_func(entry); } } return GTK_WIDGET(object); } /* ctk_display_device_new() */
bool RunLinuxDialog() { GtkWidget *dialog; int return_value; /* Create the widgets */ dialog = gtk_dialog_new_with_buttons ( "GSdx Config", NULL, /* parent window*/ (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), "OK", GTK_RESPONSE_ACCEPT, // "Cancel", GTK_RESPONSE_REJECT, // Drop because it is too annoying to support call back this way NULL); // The main area for the whole dialog box. GtkWidget* main_box = gtk_vbox_new(false, 5); GtkWidget* central_box = gtk_vbox_new(false, 5); GtkWidget* advanced_box = gtk_vbox_new(false, 5); GtkWidget* debug_box = gtk_vbox_new(false, 5); // Grab a logo, to make things look nice. GdkPixbuf* logo_pixmap = gdk_pixbuf_from_pixdata(&gsdx_ogl_logo, false, NULL); GtkWidget* logo_image = gtk_image_new_from_pixbuf(logo_pixmap); gtk_box_pack_start(GTK_BOX(main_box), logo_image, true, true, 0); GtkWidget* main_table = CreateTableInBox(main_box , NULL , 2 , 2); GtkWidget* shader_table = CreateTableInBox(central_box , "Custom Shader Settings" , 9 , 2); GtkWidget* hw_table = CreateTableInBox(central_box , "Hardware Mode Settings" , 7 , 2); GtkWidget* sw_table = CreateTableInBox(central_box , "Software Mode Settings" , 2 , 2); GtkWidget* hack_table = CreateTableInBox(advanced_box, "Hacks" , 7 , 2); GtkWidget* gl_table = CreateTableInBox(advanced_box, "OpenGL Very Advanced Custom Settings" , 6 , 2); GtkWidget* record_table = CreateTableInBox(debug_box , "Recording Settings" , 4 , 3); GtkWidget* debug_table = CreateTableInBox(debug_box , "OpenGL / GSdx Debug Settings" , 6 , 3); // Populate all the tables populate_main_table(main_table); populate_shader_table(shader_table); populate_hw_table(hw_table); populate_sw_table(sw_table); populate_hack_table(hack_table); populate_gl_table(gl_table); populate_debug_table(debug_table); populate_record_table(record_table); // Handle some nice tab GtkWidget* notebook = gtk_notebook_new(); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), central_box , gtk_label_new("Global Settings")); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), advanced_box, gtk_label_new("Advanced Settings")); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), debug_box , gtk_label_new("Debug/Recording Settings")); // Put everything in the big box. gtk_container_add(GTK_CONTAINER(main_box), notebook); // Put the box in the dialog and show it to the world. gtk_container_add (GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), main_box); gtk_widget_show_all (dialog); return_value = gtk_dialog_run (GTK_DIALOG (dialog)); // Compatibility & not supported option int mode_width = theApp.GetConfig("ModeWidth", 640); int mode_height = theApp.GetConfig("ModeHeight", 480); theApp.SetConfig("ModeHeight", mode_height); theApp.SetConfig("ModeWidth", mode_width); theApp.SetConfig("msaa", 0); theApp.SetConfig("windowed", 1); gtk_widget_destroy (dialog); return (return_value == GTK_RESPONSE_ACCEPT); }
static void show_channel_editor(GtkWidget *widget, gpointer data) { GtkWidget *vbox, *hbox, *button, *pop_window, *channellist, *notebook; static int show = 0; char *list[2]; if (show) return; if (verbose) g_print("Showing channel editor\n"); show = 1; pop_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW(pop_window), "Linux Video Studio TV - Settings"); gtk_container_set_border_width (GTK_CONTAINER (pop_window), 5); vbox = gtk_vbox_new(FALSE, 10); notebook = gtk_notebook_new (); list[0] = "Channel Name"; list[1] = "Frequency"; channellist = gtk_clist_new_with_titles(2, list); hbox = get_channel_list_notebook_page(channellist); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), hbox, gtk_label_new("TV Channels")); gtk_widget_show(hbox); #ifdef HAVE_LIRC hbox = get_rc_button_selection_notebook_page(); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), hbox, gtk_label_new("Remote Control")); gtk_widget_show(hbox); #endif hbox = get_generic_options_notebook_page(); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), hbox, gtk_label_new("Options")); gtk_widget_show(hbox); gtk_box_pack_start(GTK_BOX (vbox), notebook, FALSE, FALSE, 0); gtk_widget_show(notebook); hbox = gtk_hbox_new(TRUE, 5); button = gtk_button_new_with_label("OK"); gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(save_list), GTK_CLIST(channellist)); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (pop_window)); gtk_box_pack_start(GTK_BOX (hbox), button, TRUE, TRUE, 15); gtk_widget_show(button); button = gtk_button_new_with_label("Apply"); gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(save_list), GTK_CLIST(channellist)); gtk_box_pack_start(GTK_BOX (hbox), button, TRUE, TRUE, 15); gtk_widget_show(button); button = gtk_button_new_with_label("Cancel"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (pop_window)); gtk_box_pack_start(GTK_BOX (hbox), button, TRUE, TRUE, 15); gtk_widget_show(button); gtk_box_pack_start(GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); gtk_container_add (GTK_CONTAINER (pop_window), vbox); gtk_widget_show(vbox); gtk_signal_connect(GTK_OBJECT(pop_window), "unrealize", GTK_SIGNAL_FUNC(options_window_unrealize), (gpointer)(&show)); gtk_window_set_policy(GTK_WINDOW(pop_window), 0, 0, 0); /* pffffffffft */ gtk_window_set_transient_for(GTK_WINDOW(pop_window), GTK_WINDOW(window)); /* ? */ gtk_widget_show(pop_window); }
//static void draw_to_image_file_total_area_cb (GtkSpinButton *spinbutton, gpointer *pass_along) gint a_uibuilder_properties_factory ( const gchar *dialog_name, GtkWindow *parent, VikLayerParam *params, guint16 params_count, gchar **groups, guint8 groups_count, gboolean (*setparam) (gpointer,guint16,VikLayerParamData,gpointer,gboolean), gpointer pass_along1, gpointer pass_along2, VikLayerParamData (*getparam) (gpointer,guint16,gboolean), gpointer pass_along_getparam, void (*changeparam) (GtkWidget*, ui_change_values) ) /* pass_along1 and pass_along2 are for set_param first and last params */ { guint16 i, j, widget_count = 0; gboolean must_redraw = FALSE; if ( ! params ) return 1; /* no params == no options, so all is good */ for ( i = 0; i < params_count; i++ ) if ( params[i].group != VIK_LAYER_NOT_IN_PROPERTIES ) widget_count++; if ( widget_count == 0) return 0; /* TODO -- should be one? */ else { /* create widgets and titles; place in table */ GtkWidget *dialog = gtk_dialog_new_with_buttons ( dialog_name, parent, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL ); gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT ); GtkWidget *response_w = NULL; #if GTK_CHECK_VERSION (2, 20, 0) response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT ); #endif gint resp; GtkWidget *table = NULL; GtkWidget **tables = NULL; /* for more than one group */ GtkWidget *notebook = NULL; GtkWidget **labels = g_malloc ( sizeof(GtkWidget *) * widget_count ); GtkWidget **widgets = g_malloc ( sizeof(GtkWidget *) * widget_count ); ui_change_values *change_values = g_malloc ( sizeof(ui_change_values) * widget_count ); if ( groups && groups_count > 1 ) { guint8 current_group; guint16 tab_widget_count; notebook = gtk_notebook_new (); // Switch to vertical notebook mode when many groups if ( groups_count > 4 ) gtk_notebook_set_tab_pos ( GTK_NOTEBOOK(notebook), GTK_POS_LEFT ); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), notebook, FALSE, FALSE, 0); tables = g_malloc ( sizeof(GtkWidget *) * groups_count ); for ( current_group = 0; current_group < groups_count; current_group++ ) { tab_widget_count = 0; for ( j = 0; j < params_count; j ++ ) if ( params[j].group == current_group ) tab_widget_count++; if ( tab_widget_count ) { tables[current_group] = gtk_table_new ( tab_widget_count, 1, FALSE ); gtk_notebook_append_page ( GTK_NOTEBOOK(notebook), tables[current_group], gtk_label_new(groups[current_group]) ); } } } else { table = gtk_table_new( widget_count, 1, FALSE ); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), table, FALSE, FALSE, 0); } for ( i = 0, j = 0; i < params_count; i++ ) { if ( params[i].group != VIK_LAYER_NOT_IN_PROPERTIES ) { if ( tables ) table = tables[MAX(0, params[i].group)]; /* round up NOT_IN_GROUP, that's not reasonable here */ widgets[j] = a_uibuilder_new_widget ( &(params[i]), getparam ( pass_along_getparam, i, FALSE ) ); if ( widgets[j] ) { labels[j] = gtk_label_new(_(params[i].title)); gtk_table_attach ( GTK_TABLE(table), labels[j], 0, 1, j, j+1, 0, 0, 0, 0 ); gtk_table_attach ( GTK_TABLE(table), widgets[j], 1, 2, j, j+1, GTK_EXPAND | GTK_FILL, 0, 2, 2 ); if ( changeparam ) { change_values[j][UI_CHG_LAYER] = pass_along1; change_values[j][UI_CHG_PARAM] = ¶ms[i]; change_values[j][UI_CHG_PARAM_ID] = GINT_TO_POINTER((gint)i); change_values[j][UI_CHG_WIDGETS] = widgets; change_values[j][UI_CHG_LABELS] = labels; switch ( params[i].widget_type ) { // Change conditions for other widget types can be added when needed case VIK_LAYER_WIDGET_COMBOBOX: g_signal_connect ( G_OBJECT(widgets[j]), "changed", G_CALLBACK(changeparam), change_values[j] ); break; case VIK_LAYER_WIDGET_CHECKBUTTON: g_signal_connect ( G_OBJECT(widgets[j]), "toggled", G_CALLBACK(changeparam), change_values[j] ); break; default: break; } } } j++; } } // Repeat run through to force changeparam callbacks now that the widgets have been created // This primarily so the widget sensitivities get set up if ( changeparam ) { for ( i = 0, j = 0; i < params_count; i++ ) { if ( params[i].group != VIK_LAYER_NOT_IN_PROPERTIES ) { if ( widgets[j] ) { changeparam ( widgets[j], change_values[j] ); } j++; } } } if ( response_w ) gtk_widget_grab_focus ( response_w ); gtk_widget_show_all ( dialog ); resp = gtk_dialog_run (GTK_DIALOG (dialog)); if ( resp == GTK_RESPONSE_ACCEPT ) { for ( i = 0, j = 0; i < params_count; i++ ) { if ( params[i].group != VIK_LAYER_NOT_IN_PROPERTIES ) { if ( setparam ( pass_along1, i, a_uibuilder_widget_get_value ( widgets[j], &(params[i]) ), pass_along2, FALSE ) ) must_redraw = TRUE; j++; } } g_free ( widgets ); g_free ( labels ); g_free ( change_values ); if ( tables ) g_free ( tables ); gtk_widget_destroy ( dialog ); /* hide before redrawing. */ return must_redraw ? 2 : 3; /* user clicked OK */ } g_free ( widgets ); g_free ( labels ); g_free ( change_values ); if ( tables ) g_free ( tables ); gtk_widget_destroy ( dialog ); return 0; } }
void create_screen_dialog(void) { GtkWidget* screen_dialog; GtkWidget *main_widget; GtkWidget* screen_notebook; GtkWidget* video_note; GtkWidget* chip_note; GtkWidget* timing_note; GtkWidget *confirm_widget; GtkWidget *ok_button; GtkWidget *cancel_button; uninstall_idle_process(); screen_dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(screen_dialog), "Screen option"); gtk_window_set_position(GTK_WINDOW(screen_dialog), GTK_WIN_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(screen_dialog), TRUE); gtk_window_set_resizable(GTK_WINDOW(screen_dialog), FALSE); gtk_container_set_border_width(GTK_CONTAINER(screen_dialog), 5); g_signal_connect(GTK_OBJECT(screen_dialog), "destroy", G_CALLBACK(dialog_destroy), NULL); main_widget = gtk_vbox_new(FALSE, 0); gtk_widget_show(main_widget); gtk_container_add(GTK_CONTAINER(screen_dialog), main_widget); screen_notebook = gtk_notebook_new(); gtk_widget_show(screen_notebook); gtk_box_pack_start(GTK_BOX(main_widget),screen_notebook, TRUE, TRUE, 0); /* "Video" note */ video_note = create_video_note(); gtk_notebook_append_page(GTK_NOTEBOOK(screen_notebook), video_note, gtk_label_new("Video")); /* "Chip" note */ chip_note = create_chip_note(); gtk_notebook_append_page(GTK_NOTEBOOK(screen_notebook), chip_note, gtk_label_new("Chip")); /* "Timing" note */ timing_note = create_timing_note(); gtk_notebook_append_page(GTK_NOTEBOOK(screen_notebook), timing_note, gtk_label_new("Timing")); /* * OK, Cancel button */ confirm_widget = gtk_hbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(confirm_widget), 2); gtk_widget_show(confirm_widget); gtk_box_pack_start(GTK_BOX(main_widget), confirm_widget, TRUE, TRUE, 0); cancel_button = gtk_button_new_from_stock(GTK_STOCK_CANCEL); gtk_widget_show(cancel_button); gtk_box_pack_end(GTK_BOX(confirm_widget),cancel_button,FALSE, FALSE, 0); gtk_widget_set_can_default(cancel_button, FALSE); g_signal_connect_swapped(GTK_OBJECT(cancel_button), "clicked", G_CALLBACK(gtk_widget_destroy), GTK_OBJECT(screen_dialog)); ok_button = gtk_button_new_from_stock(GTK_STOCK_OK); gtk_widget_show(ok_button); gtk_box_pack_end(GTK_BOX(confirm_widget), ok_button, FALSE, FALSE, 0); g_signal_connect(GTK_OBJECT(ok_button), "clicked", G_CALLBACK(ok_button_clicked), (gpointer)screen_dialog); gtk_widget_set_can_default(ok_button, TRUE); gtk_widget_has_default(ok_button); gtk_widget_grab_default(ok_button); gtk_widget_show_all(screen_dialog); }
int main (int argc, char *argv[]) { ClutterActor *stage0, *stage1, *stage2, *tex1, *tex2; GtkWidget *window, *clutter0, *clutter1, *clutter2; GtkWidget *notebook, *vbox; ClutterColor col0 = { 0xdd, 0xff, 0xdd, 0xff }; ClutterColor col1 = { 0xff, 0xff, 0xff, 0xff }; ClutterColor col2 = { 0, 0, 0, 0xff }; if (gtk_clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) g_error ("Unable to initialize GtkClutter"); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); notebook = gtk_notebook_new (); gtk_container_add (GTK_CONTAINER (window), notebook); clutter0 = gtk_clutter_embed_new (); gtk_widget_set_size_request (clutter0, 320, 320); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), clutter0, gtk_label_new ("One stage")); stage0 = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (clutter0)); clutter_stage_set_color (CLUTTER_STAGE (stage0), &col0); vbox = gtk_vbox_new (FALSE, 6); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, gtk_label_new ("Two stages")); clutter1 = gtk_clutter_embed_new (); gtk_widget_set_size_request (clutter1, 320, 240); stage1 = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (clutter1)); clutter_stage_set_color (CLUTTER_STAGE(stage1), &col1); tex1 = gtk_clutter_texture_new (); gtk_clutter_texture_set_from_stock (GTK_CLUTTER_TEXTURE (tex1), clutter1, GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG, NULL); clutter_actor_set_anchor_point (tex1, clutter_actor_get_width (tex1) / 2, clutter_actor_get_height (tex1) / 2); clutter_actor_set_position (tex1, 160, 120); clutter_stage_add (stage1, tex1); clutter_actor_show (tex1); gtk_container_add (GTK_CONTAINER (vbox), clutter1); clutter2 = gtk_clutter_embed_new (); gtk_widget_set_size_request (clutter2, 320, 120); stage2 = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (clutter2)); clutter_stage_set_color (CLUTTER_STAGE(stage2), &col2); tex2 = gtk_clutter_texture_new (); gtk_clutter_texture_set_from_icon_name (GTK_CLUTTER_TEXTURE (tex2), clutter1, "user-info", GTK_ICON_SIZE_BUTTON, NULL); clutter_actor_set_anchor_point (tex2, clutter_actor_get_width (tex2) / 2, clutter_actor_get_height (tex2) / 2); clutter_actor_set_position (tex2, 160, 60); clutter_stage_add (stage2, tex2); gtk_container_add (GTK_CONTAINER (vbox), clutter2); g_signal_connect (stage2, "allocation-changed", G_CALLBACK (on_stage2_allocation_changed), tex2); gtk_widget_show_all (window); gtk_main(); return 0; }
static int show_console(void) { GtkWidget *hbox; GtkWidget *wbox; GtkWidget *notebook; GtkWidget *sw; GtkWidget *bbox, *hbbox, *add, *removew, *reloadw; char *modtitles[3] = { "Module", "Description", "Use Count" }; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); statusbar = gtk_statusbar_new(); gtk_widget_show(statusbar); gtk_signal_connect(GTK_OBJECT(window), "delete_event", GTK_SIGNAL_FUNC (exit_nicely), window); gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC (exit_now), window); gtk_container_set_border_width(GTK_CONTAINER(window), 10); quit = gtk_button_new_with_label("Quit Asterisk"); gtk_signal_connect(GTK_OBJECT(quit), "clicked", GTK_SIGNAL_FUNC (exit_completely), window); gtk_widget_show(quit); closew = gtk_button_new_with_label("Close Window"); gtk_signal_connect(GTK_OBJECT(closew), "clicked", GTK_SIGNAL_FUNC (exit_nicely), window); gtk_widget_show(closew); notebook = gtk_notebook_new(); verb = gtk_clist_new(1); gtk_clist_columns_autosize(GTK_CLIST(verb)); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_container_add(GTK_CONTAINER(sw), verb); gtk_widget_show(verb); gtk_widget_show(sw); gtk_widget_set_usize(verb, 640, 400); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), sw, gtk_label_new("Verbose Status")); modules = gtk_clist_new_with_titles(3, modtitles); gtk_clist_columns_autosize(GTK_CLIST(modules)); gtk_clist_set_column_auto_resize(GTK_CLIST(modules), 0, TRUE); gtk_clist_set_column_auto_resize(GTK_CLIST(modules), 1, TRUE); gtk_clist_set_column_auto_resize(GTK_CLIST(modules), 2, TRUE); gtk_clist_set_sort_column(GTK_CLIST(modules), 0); gtk_clist_set_auto_sort(GTK_CLIST(modules), TRUE); gtk_clist_column_titles_passive(GTK_CLIST(modules)); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_container_add(GTK_CONTAINER(sw), modules); gtk_clist_set_selection_mode(GTK_CLIST(modules), GTK_SELECTION_BROWSE); gtk_widget_show(modules); gtk_widget_show(sw); add = gtk_button_new_with_label("Load..."); gtk_widget_show(add); removew = gtk_button_new_with_label("Unload"); gtk_widget_show(removew); reloadw = gtk_button_new_with_label("Reload"); gtk_widget_show(reloadw); gtk_signal_connect(GTK_OBJECT(removew), "clicked", GTK_SIGNAL_FUNC (remove_module), window); gtk_signal_connect(GTK_OBJECT(add), "clicked", GTK_SIGNAL_FUNC (add_module), window); gtk_signal_connect(GTK_OBJECT(reloadw), "clicked", GTK_SIGNAL_FUNC (reload_module), window); bbox = gtk_vbox_new(FALSE, 5); gtk_widget_show(bbox); gtk_widget_set_usize(bbox, 100, -1); gtk_box_pack_start(GTK_BOX(bbox), add, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(bbox), removew, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(bbox), reloadw, FALSE, FALSE, 5); hbbox = gtk_hbox_new(FALSE, 5); gtk_widget_show(hbbox); gtk_box_pack_start(GTK_BOX(hbbox), sw, TRUE, TRUE, 5); gtk_box_pack_start(GTK_BOX(hbbox), bbox, FALSE, FALSE, 5); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), hbbox, gtk_label_new("Module Information")); gtk_widget_show(notebook); wbox = gtk_hbox_new(FALSE, 5); gtk_widget_show(wbox); gtk_box_pack_end(GTK_BOX(wbox), quit, FALSE, FALSE, 5); gtk_box_pack_end(GTK_BOX(wbox), closew, FALSE, FALSE, 5); hbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(hbox); /* Command line */ cli = gtk_entry_new(); gtk_widget_show(cli); gtk_signal_connect(GTK_OBJECT(cli), "activate", GTK_SIGNAL_FUNC (cli_activate), NULL); gtk_box_pack_start(GTK_BOX(hbox), notebook, TRUE, TRUE, 5); gtk_box_pack_start(GTK_BOX(hbox), wbox, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), cli, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), statusbar, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(window), hbox); gtk_window_set_title(GTK_WINDOW(window), "Asterisk Console"); gtk_widget_grab_focus(cli); ast_pthread_create(&console_thread, NULL, consolethread, NULL); /* XXX Okay, seriously fix me! XXX */ usleep(100000); ast_register_verbose(verboser); gtk_clist_freeze(GTK_CLIST(verb)); ast_loader_register(mod_update); gtk_clist_thaw(GTK_CLIST(verb)); gdk_input_add(clipipe[0], GDK_INPUT_READ, cliinput, NULL); mod_update(); update_statusbar("Asterisk Console Ready"); return 0; }
static GtkWidget *create_window(void) { // Basic window stwidgets.startwin = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(stwidgets.startwin), apptitle); // NOTE: use global app title gtk_window_set_position(GTK_WINDOW(stwidgets.startwin), GTK_WIN_POS_CENTER); gtk_window_set_resizable(GTK_WINDOW(stwidgets.startwin), FALSE); gtk_window_set_type_hint(GTK_WINDOW(stwidgets.startwin), GDK_WINDOW_TYPE_HINT_DIALOG); // Horizontal layout of banner and controls stwidgets.hlayout = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(stwidgets.startwin), stwidgets.hlayout); // banner { GdkPixbuf *pixbuf = load_banner(); stwidgets.banner = gtk_image_new_from_pixbuf(pixbuf); g_object_unref((gpointer)pixbuf); } gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.banner, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(stwidgets.banner), 0.5, 0); // Vertical layout of tab control and start+cancel buttons stwidgets.vlayout = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.vlayout, TRUE, TRUE, 0); // Tab control stwidgets.tabs = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.tabs, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.tabs), 4); // layout table of config page stwidgets.configtlayout = gtk_table_new(6, 3, FALSE); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.configtlayout); // 3D video mode LabelText stwidgets.vmode3dlabel = gtk_label_new_with_mnemonic("_Video mode:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.vmode3dlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 0,1, GTK_FILL, 0, 4, 0); // 3D video mode combo { GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); GtkCellRenderer *cell; stwidgets.vmode3dcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 0,1, GTK_EXPAND | GTK_FILL, 0, 4, 0); // Fullscreen checkbox stwidgets.displayvlayout = gtk_vbox_new(TRUE, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.displayvlayout, 2,3, 0,1, GTK_FILL, 0, 4, 0); stwidgets.fullscreencheck = gtk_check_button_new_with_mnemonic("_Fullscreen"); gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.fullscreencheck, FALSE, FALSE, 0); #ifdef POLYMER // Polymer checkbox stwidgets.polymercheck = gtk_check_button_new_with_mnemonic("_Polymer"); gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.polymercheck, FALSE, FALSE, 0); #endif // Input devices LabelText stwidgets.inputdevlabel = gtk_label_new_with_mnemonic("_Input devices:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.inputdevlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevlabel, 0,1, 1,2, GTK_FILL, 0, 4, 0); // Input devices combo { GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING); GtkCellRenderer *cell; stwidgets.inputdevcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevcombo, 1,2, 1,2, GTK_EXPAND | GTK_FILL, 0, 4, 0); // Custom mod LabelText stwidgets.custommodlabel = gtk_label_new_with_mnemonic("Custom _game:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.custommodlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodlabel, 0,1, 2,3, GTK_FILL, 0, 4, 7); // Custom mod combo { GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING); GtkCellRenderer *cell; stwidgets.custommodcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodcombo, 1,2, 2,3, GTK_EXPAND | GTK_FILL, 0, 4, 7); // Empty horizontal layout stwidgets.emptyhlayout = gtk_hbox_new(TRUE, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.emptyhlayout, 0,3, 3,4, 0, GTK_EXPAND | GTK_FILL, 4, 0); // Autoload checkbox stwidgets.autoloadcheck = gtk_check_button_new_with_mnemonic("_Enable \"autoload\" folder"); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.autoloadcheck, 0,3, 4,5, GTK_FILL, 0, 2, 2); // Always show config checkbox stwidgets.alwaysshowcheck = gtk_check_button_new_with_mnemonic("_Always show this window at startup"); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.alwaysshowcheck, 0,3, 5,6, GTK_FILL, 0, 2, 2); // Configuration tab stwidgets.configtab = gtk_label_new("Configuration"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 0), stwidgets.configtab); // Game data layout stwidgets.gamevlayout = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.gamevlayout); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.gamevlayout), 4); // Game data field LabelText stwidgets.gamelabel = gtk_label_new_with_mnemonic("_Game:"); gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamelabel, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(stwidgets.gamelabel), 0, 0.5); // Game data scrollable area stwidgets.gamescroll = gtk_scrolled_window_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamescroll, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_SHADOW_IN); // Game data list { GtkListStore *list = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); GtkCellRenderer *cell; GtkTreeViewColumn *col; gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(list), 0, name_sorter, NULL, NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(list), 0, GTK_SORT_ASCENDING); stwidgets.gamelist = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes("Game", cell, "text", 0, NULL); gtk_tree_view_column_set_expand(col, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col); col = gtk_tree_view_column_new_with_attributes("GRP file", cell, "text", 1, NULL); gtk_tree_view_column_set_min_width(col, 64); gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col); } gtk_container_add(GTK_CONTAINER(stwidgets.gamescroll), stwidgets.gamelist); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(stwidgets.gamelist), FALSE); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(stwidgets.gamelist), FALSE); // Game tab stwidgets.gametab = gtk_label_new("Game"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 1), stwidgets.gametab); // Messages scrollable area stwidgets.messagesscroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.messagesscroll); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); // Messages text area stwidgets.messagestext = gtk_text_view_new(); gtk_container_add(GTK_CONTAINER(stwidgets.messagesscroll), stwidgets.messagestext); gtk_text_view_set_editable(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(stwidgets.messagestext), GTK_WRAP_WORD); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2); // Messages tab stwidgets.messagestab = gtk_label_new("Messages"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 2), stwidgets.messagestab); // Dialogue box buttons layout stwidgets.buttons = gtk_hbutton_box_new(); gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.buttons, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.buttons), 3); gtk_button_box_set_layout(GTK_BUTTON_BOX(stwidgets.buttons), GTK_BUTTONBOX_END); // Cancel button stwidgets.cancelbutton = gtk_button_new(); gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.cancelbutton); GTK_WIDGET_SET_FLAGS(stwidgets.cancelbutton, GTK_CAN_DEFAULT); stwidgets.cancelbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(stwidgets.cancelbutton), stwidgets.cancelbuttonalign); stwidgets.cancelbuttonlayout = gtk_hbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(stwidgets.cancelbuttonalign), stwidgets.cancelbuttonlayout); stwidgets.cancelbuttonicon = gtk_image_new_from_stock("gtk-cancel", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonicon, FALSE, FALSE, 0); stwidgets.cancelbuttonlabel = gtk_label_new_with_mnemonic("_Cancel"); gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonlabel, FALSE, FALSE, 0); // Start button stwidgets.startbutton = gtk_button_new(); gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.startbutton); GTK_WIDGET_SET_FLAGS(stwidgets.startbutton, GTK_CAN_DEFAULT); gtk_window_set_default(GTK_WINDOW(stwidgets.startwin), stwidgets.startbutton); stwidgets.startbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(stwidgets.startbutton), stwidgets.startbuttonalign); stwidgets.startbuttonlayout = gtk_hbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(stwidgets.startbuttonalign), stwidgets.startbuttonlayout); stwidgets.startbuttonicon = gtk_image_new_from_stock("gtk-execute", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonicon, FALSE, FALSE, 0); stwidgets.startbuttonlabel = gtk_label_new_with_mnemonic("_Start"); gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonlabel, FALSE, FALSE, 0); // Wire up the signals g_signal_connect((gpointer) stwidgets.startwin, "delete_event", G_CALLBACK(on_startwin_delete_event), NULL); g_signal_connect((gpointer) stwidgets.vmode3dcombo, "changed", G_CALLBACK(on_vmode3dcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.fullscreencheck, "toggled", G_CALLBACK(on_fullscreencheck_toggled), NULL); #ifdef POLYMER g_signal_connect((gpointer) stwidgets.polymercheck, "toggled", G_CALLBACK(on_polymercheck_toggled), NULL); #endif g_signal_connect((gpointer) stwidgets.inputdevcombo, "changed", G_CALLBACK(on_inputdevcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.custommodcombo, "changed", G_CALLBACK(on_custommodcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.autoloadcheck, "toggled", G_CALLBACK(on_autoloadcheck_toggled), NULL); g_signal_connect((gpointer) stwidgets.alwaysshowcheck, "toggled", G_CALLBACK(on_alwaysshowcheck_toggled), NULL); g_signal_connect((gpointer) stwidgets.cancelbutton, "clicked", G_CALLBACK(on_cancelbutton_clicked), NULL); g_signal_connect((gpointer) stwidgets.startbutton, "clicked", G_CALLBACK(on_startbutton_clicked), NULL); { GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(stwidgets.gamelist)); gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE); g_signal_connect((gpointer) sel, "changed", G_CALLBACK(on_gamelist_selection_changed), NULL); } // Associate labels with their controls gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.vmode3dlabel), stwidgets.vmode3dcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.inputdevlabel), stwidgets.inputdevcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.custommodlabel), stwidgets.custommodcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.gamelabel), stwidgets.gamelist); return stwidgets.startwin; }
static void gdict_sidebar_init (GdictSidebar *sidebar) { GdictSidebarPrivate *priv; GtkWidget *hbox; GtkWidget *select_hbox; GtkWidget *select_button; GtkWidget *close_button; GtkWidget *arrow; sidebar->priv = priv = GDICT_SIDEBAR_GET_PRIVATE (sidebar); /* we store all the pages inside the list, but we keep * a pointer inside the hash table for faster look up * times; what's inside the table will be destroyed with * the list, so there's no need to supply the destroy * functions for keys and values. */ priv->pages = NULL; priv->pages_by_id = g_hash_table_new (g_str_hash, g_str_equal); /* top option menu */ hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (sidebar), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); priv->hbox = hbox; select_button = gtk_toggle_button_new (); gtk_button_set_relief (GTK_BUTTON (select_button), GTK_RELIEF_NONE); g_signal_connect (select_button, "button-press-event", G_CALLBACK (gdict_sidebar_select_button_press_cb), sidebar); g_signal_connect (select_button, "key-press-event", G_CALLBACK (gdict_sidebar_select_key_press_cb), sidebar); priv->select_button = select_button; select_hbox = gtk_hbox_new (FALSE, 0); priv->label = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (priv->label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (select_hbox), priv->label, FALSE, FALSE, 0); gtk_widget_show (priv->label); arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE); gtk_box_pack_end (GTK_BOX (select_hbox), arrow, FALSE, FALSE, 0); gtk_widget_show (arrow); gtk_container_add (GTK_CONTAINER (select_button), select_hbox); gtk_widget_show (select_hbox); gtk_box_pack_start (GTK_BOX (hbox), select_button, TRUE, TRUE, 0); gtk_widget_show (select_button); close_button = gtk_button_new (); gtk_button_set_relief (GTK_BUTTON (close_button), GTK_RELIEF_NONE); gtk_button_set_image (GTK_BUTTON (close_button), gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_SMALL_TOOLBAR)); g_signal_connect (close_button, "clicked", G_CALLBACK (gdict_sidebar_close_clicked_cb), sidebar); gtk_box_pack_end (GTK_BOX (hbox), close_button, FALSE, FALSE, 0); gtk_widget_show (close_button); priv->close_button = close_button; sidebar->priv->menu = gtk_menu_new (); g_signal_connect (sidebar->priv->menu, "deactivate", G_CALLBACK (gdict_sidebar_menu_deactivate_cb), sidebar); gtk_menu_attach_to_widget (GTK_MENU (sidebar->priv->menu), GTK_WIDGET (sidebar), gdict_sidebar_menu_detach_cb); gtk_widget_show (sidebar->priv->menu); sidebar->priv->notebook = gtk_notebook_new (); gtk_notebook_set_show_border (GTK_NOTEBOOK (sidebar->priv->notebook), FALSE); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (sidebar->priv->notebook), FALSE); gtk_box_pack_start (GTK_BOX (sidebar), sidebar->priv->notebook, TRUE, TRUE, 6); gtk_widget_show (sidebar->priv->notebook); }
int main( int argc, char *argv[] ) { /* GtkWidget is the storage type for widgets */ GtkWidget *window; GtkWidget *menubar; time_t now; struct tm *tm; GThread *gth = NULL; /* thread id */ gboolean run_flag = TRUE; /* used as exit flag for threads */ int i; putenv("UBUNTU_MENUPROXY="); //init_trees(); gdk_color_parse("#FFFF00", &color_yellow); gdk_color_parse("#FFFFFF", &color_white); gdk_color_parse("#404040", &color_grey); gdk_color_parse("#00FF00", &color_green); gdk_color_parse("#007700", &color_darkgreen); gdk_color_parse("#0000FF", &color_blue); gdk_color_parse("#FF0000", &color_red); gdk_color_parse("#770000", &color_darkred); gdk_color_parse("#000000", &color_black); font = pango_font_description_from_string("Sans bold 12"); #ifdef WIN32 installation_dir = g_win32_get_package_installation_directory_of_module(NULL); #else gbr_init(NULL); installation_dir = gbr_find_prefix(NULL); #endif program_path = argv[0]; current_directory[0] = 0; if (current_directory[0] == 0) strcpy(current_directory, "."); conffile = g_build_filename(g_get_user_data_dir(), "judoproxy.ini", NULL); /* create video download dir */ video_dir = g_build_filename(g_get_home_dir(), "rpivideos", NULL); g_print("Video dir = %s\n", video_dir); g_mkdir_with_parents(video_dir, 0755); keyfile = g_key_file_new(); g_key_file_load_from_file(keyfile, conffile, 0, NULL); now = time(NULL); tm = localtime(&now); current_year = tm->tm_year+1900; srand(now); //srandom(now); my_address = now + getpid()*10000; gtk_init (&argc, &argv); main_window = window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(main_window), "JudoProxy"); gtk_widget_set_size_request(window, FRAME_WIDTH, FRAME_HEIGHT); gchar *iconfile = g_build_filename(installation_dir, "etc", "judoproxy.png", NULL); gtk_window_set_default_icon_from_file(iconfile, NULL); g_free(iconfile); g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (delete_event), NULL); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy), NULL); gtk_container_set_border_width (GTK_CONTAINER (window), 10); main_vbox = gtk_grid_new(); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 1); gtk_container_add (GTK_CONTAINER (window), main_vbox); gtk_widget_show(main_vbox); /* menubar */ menubar = get_menubar_menu(window); gtk_widget_show(menubar); gtk_grid_attach(GTK_GRID(main_vbox), menubar, 0, 0, 1, 1); gtk_widget_set_hexpand(menubar, TRUE); /* judoka info */ //name_box = gtk_label_new("?"); //gtk_box_pack_start(GTK_BOX(main_vbox), name_box, FALSE, TRUE, 0); //GtkWidget *hbox = gtk_hbox_new(FALSE, 0); //gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, TRUE, 0); notebook = gtk_notebook_new(); gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE); gtk_widget_set_hexpand(notebook, TRUE); //gtk_widget_set_vexpand(notebook, TRUE); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP); /* GtkWidget *camera_table = gtk_grid_new(); gtk_grid_set_column_spacing(GTK_GRID(camera_table), 10); gtk_grid_set_row_spacing(GTK_GRID(camera_table), 10); */ for (i = 0; i < NUM_TATAMIS; i++) { gchar buf[32]; GtkWidget *data_table = gtk_grid_new(); connections[i].scrolled_window = data_table; //connections[i].scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(connections[i].scrolled_window), 10); snprintf(buf, sizeof(buf), "T%d [--]", i+1); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), connections[i].scrolled_window, gtk_label_new(buf)); gtk_grid_attach(GTK_GRID(data_table), gtk_label_new(_("Camera")), 0, 0, 2, 1); gtk_grid_attach(GTK_GRID(data_table), gtk_label_new(_("JudoTimer")), 4, 0, 2, 1); GtkWidget *reload = gtk_button_new_with_label(_("Reload")); gtk_grid_attach(GTK_GRID(data_table), reload, 0, 1, 1, 1); connections[i].in_addr = gtk_entry_new(); connections[i].out_addr = gtk_entry_new(); gtk_entry_set_width_chars(GTK_ENTRY(connections[i].in_addr), 15); gtk_entry_set_width_chars(GTK_ENTRY(connections[i].out_addr), 15); gtk_grid_attach(GTK_GRID(data_table), connections[i].in_addr, 2, 0, 2, 1); gtk_grid_attach(GTK_GRID(data_table), connections[i].out_addr, 6, 0, 2, 1); gtk_grid_attach(GTK_GRID(data_table), gtk_label_new(" "), 0, 1, 1, 1); //gtk_container_add(GTK_CONTAINER(connections[i].scrolled_window), data_table); g_signal_connect (connections[i].out_addr, "activate", G_CALLBACK(enter_callback), gint_to_ptr(i)); g_signal_connect (connections[i].in_addr, "activate", G_CALLBACK(camera_ip_enter_callback), gint_to_ptr(i)); #ifdef WEBKIT g_signal_connect (reload, "clicked", G_CALLBACK(reload_web), gint_to_ptr(i)); #else g_signal_connect (reload, "clicked", G_CALLBACK(select_camera_video), gint_to_ptr(i)); #endif } gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0); gtk_grid_attach_next_to(GTK_GRID(main_vbox), notebook, NULL, GTK_POS_BOTTOM, 1, 1); progress_bar = gtk_progress_bar_new(); gtk_grid_attach_next_to(GTK_GRID(main_vbox), progress_bar, NULL, GTK_POS_BOTTOM, 1, 1); GtkWidget *w = GTK_WIDGET(gtk_scrolled_window_new(NULL, NULL)); #ifdef WEBKIT web_view = WEBKIT_WEB_VIEW(webkit_web_view_new()); webkit_web_view_set_transparent(web_view, TRUE); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(web_view)); gtk_widget_set_vexpand(GTK_WIDGET(web_view), TRUE); WebKitWebSettings *web_settings = webkit_web_settings_new(); //g_object_set(G_OBJECT(web_settings), "enable-java-applet", FALSE, NULL); //g_object_set(G_OBJECT(web_settings), "enable-plugins", FALSE, NULL); webkit_web_view_set_settings(web_view, web_settings); gtk_grid_attach_next_to(GTK_GRID(main_vbox), GTK_WIDGET(w), NULL, GTK_POS_BOTTOM, 1, 1); gtk_widget_grab_focus(GTK_WIDGET(web_view)); //webkit_web_view_load_uri(web_view, "http://www.hs.fi"); webkit_web_view_load_uri(web_view, "http://www.quirksmode.org/html5/tests/video.html"); g_signal_connect(web_view, "download-requested", G_CALLBACK(download_req), NULL); //g_signal_connect(web_view, "load-changed", G_CALLBACK(load_changed), NULL); #else /* HTML page */ html_page = create_html_page(); gtk_grid_attach_next_to(GTK_GRID(main_vbox), GTK_WIDGET(html_page), NULL, GTK_POS_BOTTOM, 1, 1); /* Video display */ camera_image = gtk_image_new(); gtk_widget_set_size_request(GTK_WIDGET(camera_image), 640, 360); GtkWidget *event_box = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(event_box), camera_image); gtk_widget_set_events(event_box, gtk_widget_get_events(event_box) | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | /*GDK_POINTER_MOTION_MASK |*/ GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_MOTION_MASK); g_signal_connect(G_OBJECT(event_box), "button_press_event", G_CALLBACK(button_press_callback), camera_image); g_signal_connect(G_OBJECT(event_box), "button_release_event", G_CALLBACK(button_release_callback), camera_image); g_signal_connect(G_OBJECT(event_box), "motion-notify-event", G_CALLBACK(button_notify_callback), camera_image); gtk_widget_show(camera_image); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(event_box)); gtk_widget_set_vexpand(GTK_WIDGET(event_box), TRUE); gtk_widget_set_hexpand(GTK_WIDGET(event_box), TRUE); gtk_widget_set_vexpand(GTK_WIDGET(camera_image), TRUE); gtk_widget_set_hexpand(GTK_WIDGET(camera_image), TRUE); gtk_grid_attach_next_to(GTK_GRID(main_vbox), GTK_WIDGET(w), NULL, GTK_POS_BOTTOM, 1, 1); #endif /* timers */ timer = g_timer_new(); gtk_widget_show_all(window); set_preferences(); change_language(NULL, NULL, gint_to_ptr(language)); open_comm_socket(); scan_interfaces(); /* Create a bg thread using glib */ gpointer proxy_ssdp_thread(gpointer args); g_snprintf(ssdp_id, sizeof(ssdp_id), "JudoProxy"); static gint run[NUM_CONNECTIONS]; for (i = 0; i < NUM_CONNECTIONS; i++) { char tname[16]; run[i] = i; sprintf(tname, "Connection%d", i); gth = g_thread_new(tname, (GThreadFunc)connection_thread, &run[i]); } gth = g_thread_new("SSDP", (GThreadFunc)proxy_ssdp_thread, (gpointer)&run_flag); gth = g_thread_new("CameraVideo", camera_video, (gpointer)&run_flag); gth = gth; // make compiler happy gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS); cursor = gdk_cursor_new(GDK_HAND2); //gdk_window_set_cursor(GTK_WIDGET(main_window)->window, cursor); //g_timeout_add(100, timeout_ask_for_data, NULL); g_timeout_add(1000, check_table, NULL); g_timeout_add(100, show_camera_video, NULL); //g_idle_add(show_camera_video, NULL); /* All GTK applications must have a gtk_main(). Control ends here * and waits for an event to occur (like a key press or * mouse event). */ gtk_main(); for (i = 0; i < NUM_CONNECTIONS; i++) run[i] = -1; run_flag = FALSE; /* flag threads to stop and exit */ //g_thread_join(gth); /* wait for thread to exit */ return 0; }
void sp_quick_align_dialog (void) { if (!dlg) { GtkWidget *nb, *vb, *om, *t, *l; GtkTooltips * tt = gtk_tooltips_new (); gchar title[500]; sp_ui_dialog_title_string (SP_VERB_DIALOG_ALIGN_DISTRIBUTE, title); dlg = sp_window_new (title, TRUE); if (x == -1000 || y == -1000) { x = prefs_get_int_attribute (prefs_path, "x", 0); y = prefs_get_int_attribute (prefs_path, "y", 0); } if (w ==0 || h == 0) { w = prefs_get_int_attribute (prefs_path, "w", 0); h = prefs_get_int_attribute (prefs_path, "h", 0); } if (x != 0 || y != 0) gtk_window_move ((GtkWindow *) dlg, x, y); else gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER); if (w && h) gtk_window_resize ((GtkWindow *) dlg, w, h); sp_transientize (dlg); wd.win = dlg; wd.stop = 0; g_signal_connect (G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_transientize_callback), &wd); gtk_signal_connect (GTK_OBJECT (dlg), "event", GTK_SIGNAL_FUNC (sp_dialog_event_handler), dlg); gtk_signal_connect (GTK_OBJECT (dlg), "destroy", G_CALLBACK (sp_quick_align_dialog_destroy), dlg); gtk_signal_connect (GTK_OBJECT (dlg), "delete_event", G_CALLBACK (sp_align_dialog_delete), dlg); g_signal_connect (G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_align_dialog_delete), dlg); nb = gtk_notebook_new (); gtk_container_add (GTK_CONTAINER (dlg), nb); /* Align */ vb = gtk_vbox_new (FALSE, 4); gtk_container_set_border_width (GTK_CONTAINER (vb), 4); om = gtk_option_menu_new (); gtk_box_pack_start (GTK_BOX (vb), om, FALSE, FALSE, 0); gtk_option_menu_set_menu (GTK_OPTION_MENU (om), sp_align_dialog_create_base_menu ()); t = gtk_table_new (2, 5, TRUE); gtk_box_pack_start (GTK_BOX (vb), t, FALSE, FALSE, 0); sp_align_add_button (t, 0, 0, G_CALLBACK (sp_align_arrange_clicked), aligns[SP_ALIGN_LEFT_OUT], "al_left_out", _("Right side of aligned objects to left side of anchor"), tt); sp_align_add_button (t, 1, 0, G_CALLBACK (sp_align_arrange_clicked), aligns[SP_ALIGN_LEFT_IN], "al_left_in", _("Left side of aligned objects to left side of anchor"), tt); sp_align_add_button (t, 2, 0, G_CALLBACK (sp_align_arrange_clicked), aligns[SP_ALIGN_CENTER_HOR], "al_center_hor", _("Center horizontally"), tt); sp_align_add_button (t, 3, 0, G_CALLBACK (sp_align_arrange_clicked), aligns[SP_ALIGN_RIGHT_IN], "al_right_in", _("Right side of aligned objects to right side of anchor"), tt); sp_align_add_button (t, 4, 0, G_CALLBACK (sp_align_arrange_clicked), aligns[SP_ALIGN_RIGHT_OUT], "al_right_out", _("Left side of aligned objects to right side of anchor"), tt); sp_align_add_button (t, 0, 1, G_CALLBACK (sp_align_arrange_clicked), aligns[SP_ALIGN_TOP_OUT], "al_top_out", _("Bottom of aligned objects to top of anchor"), tt); sp_align_add_button (t, 1, 1, G_CALLBACK (sp_align_arrange_clicked), aligns[SP_ALIGN_TOP_IN], "al_top_in", _("Top of aligned objects to top of anchor"), tt); sp_align_add_button (t, 2, 1, G_CALLBACK (sp_align_arrange_clicked), aligns[SP_ALIGN_CENTER_VER], "al_center_ver", _("Center vertically"), tt); sp_align_add_button (t, 3, 1, G_CALLBACK (sp_align_arrange_clicked), aligns[SP_ALIGN_BOTTOM_IN], "al_bottom_in", _("Bottom of aligned objects to bottom of anchor"), tt); sp_align_add_button (t, 4, 1, G_CALLBACK (sp_align_arrange_clicked), aligns[SP_ALIGN_BOTTOM_OUT], "al_bottom_out", _("Top of aligned objects to bottom of anchor"), tt); l = gtk_label_new (_("Align")); gtk_widget_show (l); gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l); /* Distribute */ vb = gtk_vbox_new (FALSE, 4); gtk_container_set_border_width (GTK_CONTAINER (vb), 4); om = gtk_option_menu_new (); gtk_box_pack_start (GTK_BOX (vb), om, FALSE, FALSE, 0); gtk_option_menu_set_menu (GTK_OPTION_MENU (om), sp_align_dialog_create_base_menu ()); gtk_widget_set_sensitive (om, FALSE); t = gtk_table_new (2, 4, TRUE); gtk_box_pack_start (GTK_BOX (vb), t, FALSE, FALSE, 0); sp_align_add_button (t, 0, 0, G_CALLBACK (sp_align_distribute_h_clicked), hdist[SP_DISTRIBUTE_LEFT], "distribute_left", _("Distribute left sides of objects at even distances"), tt); sp_align_add_button (t, 1, 0, G_CALLBACK (sp_align_distribute_h_clicked), hdist[SP_DISTRIBUTE_HCENTRE], "distribute_hcentre", _("Distribute centres of objects at even distances horizontally"), tt); sp_align_add_button (t, 2, 0, G_CALLBACK (sp_align_distribute_h_clicked), hdist[SP_DISTRIBUTE_RIGHT], "distribute_right", _("Distribute right sides of objects at even distances"), tt); sp_align_add_button (t, 3, 0, G_CALLBACK (sp_align_distribute_h_clicked), hdist[SP_DISTRIBUTE_HDIST], "distribute_hdist", _("Distribute horizontal distance between objects equally"), tt); sp_align_add_button (t, 0, 1, G_CALLBACK (sp_align_distribute_v_clicked), vdist[SP_DISTRIBUTE_TOP], "distribute_top", _("Distribute top sides of objects at even distances"), tt); sp_align_add_button (t, 1, 1, G_CALLBACK (sp_align_distribute_v_clicked), vdist[SP_DISTRIBUTE_VCENTRE], "distribute_vcentre", _("Distribute centres of objects at even distances vertically"), tt); sp_align_add_button (t, 2, 1, G_CALLBACK (sp_align_distribute_v_clicked), vdist[SP_DISTRIBUTE_BOTTOM], "distribute_bottom", _("Distribute bottom sides of objects at even distances"), tt); sp_align_add_button (t, 3, 1, G_CALLBACK (sp_align_distribute_v_clicked), vdist[SP_DISTRIBUTE_VDIST], "distribute_vdist", _("Distribute vertical distance between objects equally"), tt); l = gtk_label_new (_("Distribute")); gtk_widget_show (l); gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l); gtk_widget_show_all (nb); } gtk_window_present ((GtkWindow *) dlg); }
int main (int argc, char *argv []) { /*Running Shell*/ GError *error = NULL; python_shell_data = g_try_malloc (sizeof (ChildProcessData)); python_shell_data->argv = NULL; python_shell_data->slave_termios = g_try_malloc (sizeof (struct termios)); python_shell_data->current_dir = NULL; bash_loaded = ptyFork (python_shell_data, &error); gtk_init (&argc, &argv); python_shell_data->channel = g_io_channel_unix_new (python_shell_data->master_fd); g_io_add_watch (python_shell_data->channel, G_IO_IN, (GIOFunc)read_masterFd, &(python_shell_data->master_fd)); /**********/ /*Loading Options*/ if (g_file_test ("./options.inf", G_FILE_TEST_EXISTS)) load_options_from_file ("./options.inf"); else { options.indent_width = 4; options.tab_width = 4; options.is_code_completion = TRUE; options.is_code_folding = TRUE; options.show_line_numbers = TRUE; options.font_name = "Liberation Mono"; } /*************/ options.python_shell_path = "/usr/bin/python"; options.comment_out_str = "##"; options.indent_width_str = " "; options.tab_width_str = " "; env_python_path = ""; gchar **p = options.env_vars; if (p) { while (*p) { gchar *s = g_strstr_len (*p, -1, "PYTHONPATH="); if (s) { env_python_path = s + strlen ("PYTHONPATH="); break; } p++; } } /*Get sys.path*/ char *sys_path_argv[] = {"python", "./scripts/path.py", NULL}; g_spawn_sync (NULL, sys_path_argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, &sys_path_string, NULL, NULL, NULL); /***********/ char *_str = g_strconcat (sys_path_string, "\n", env_python_path, NULL); g_free (sys_path_string); sys_path_string = _str; file_monitor = file_monitor_new (file_monitor_changed); /*Setting Main Window*/ GtkWidget *navigate_bookmarks; builder = gtk_builder_new (); gtk_builder_add_from_file (builder, "./ui/main.ui", NULL); content_box = GTK_WIDGET (gtk_builder_get_object (builder, "content_box")); window = gtk_builder_get_object (builder, "main_window"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); path_browser = path_browser_new (); g_object_ref (path_browser); proj_notebook = project_notebook_new (); /**Setting proj_syms_tree_view**/ symbols_view = symbols_view_new (); g_object_ref (symbols_view); /*************************/ content_paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); g_object_ref (content_paned); status_bar = gtk_statusbar_new (); g_object_ref (status_bar); gtk_notebook_append_page (GTK_NOTEBOOK (proj_notebook), symbols_view, gtk_label_new ("Symbols")); gtk_notebook_append_page (GTK_NOTEBOOK (proj_notebook), path_browser, gtk_label_new ("Paths")); navigate_bookmarks = GTK_WIDGET (gtk_builder_get_object (builder, "navigate_bookmarks")); bookmarks_menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (navigate_bookmarks), bookmarks_menu); GtkAccelGroup *accelgroup = GTK_ACCEL_GROUP (gtk_builder_get_object (builder, "accelgroup")); /*Connecting menu item's signals*/ //For File Menu g_signal_connect (gtk_builder_get_object (builder, "file_new"), "activate", G_CALLBACK (file_new_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_new_tab"), "activate", G_CALLBACK (file_new_tab_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_open"), "activate", G_CALLBACK (file_open_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "recentchoosermenu"), "selection-done", G_CALLBACK (file_recent_menu_selection_done), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_save"), "activate", G_CALLBACK (file_save_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_save_as"), "activate", G_CALLBACK (file_save_as_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_save_copy_as"), "activate", G_CALLBACK (file_save_copy_as_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_save_all"), "activate", G_CALLBACK (file_save_all_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_close_tab"), "activate", G_CALLBACK (file_close_tab_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_close_all_tabs"), "activate", G_CALLBACK (file_close_all_tabs_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_quit"), "activate", G_CALLBACK (file_quit_activate), NULL); //For Edit Menu g_signal_connect (gtk_builder_get_object (builder, "edit_undo"), "activate", G_CALLBACK (edit_undo_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_redo"), "activate", G_CALLBACK (edit_redo_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_cut"), "activate", G_CALLBACK (edit_cut_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_copy"), "activate", G_CALLBACK (edit_copy_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_paste"), "activate", G_CALLBACK (edit_paste_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_delete"), "activate", G_CALLBACK (edit_delete_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_select_all"), "activate", G_CALLBACK (edit_select_all_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_select_function"), "activate", G_CALLBACK (edit_select_function_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_select_block"), "activate", G_CALLBACK (edit_select_block_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_fold_all_func"), "activate", G_CALLBACK (edit_fold_all_func_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_unfold_all_func"), "activate", G_CALLBACK (edit_unfold_all_func_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_fold_current_func"), "activate", G_CALLBACK (edit_fold_current_func_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_autocomplete"), "activate", G_CALLBACK (edit_autocomplete_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_matching_paranthesis"), "activate", G_CALLBACK (edit_matching_paranthesis_activate), NULL); //For Format Menu g_signal_connect (gtk_builder_get_object (builder, "format_inc_indent"), "activate", G_CALLBACK (format_inc_indent_activate), NULL); gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_inc_indent")), "activate", accelgroup, GDK_KEY_bracketright, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); g_signal_connect (gtk_builder_get_object (builder, "format_dec_indent"), "activate", G_CALLBACK (format_dec_indent_activate), NULL); gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_dec_indent")), "activate", accelgroup, GDK_KEY_bracketleft, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); g_signal_connect (gtk_builder_get_object (builder, "format_comment_out"), "activate", G_CALLBACK (format_comment_out_activate), NULL); gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_comment_out")), "activate", accelgroup, GDK_KEY_3, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); g_signal_connect (gtk_builder_get_object (builder, "format_uncomment_out"), "activate", G_CALLBACK (format_uncomment_out_activate), NULL); gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_uncomment_out")), "activate", accelgroup, GDK_KEY_4, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); g_signal_connect (gtk_builder_get_object (builder, "format_tabify_region"), "activate", G_CALLBACK (format_tabify_region_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "format_untabify_region"), "activate", G_CALLBACK (format_untabify_region_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "format_uppercase"), "activate", G_CALLBACK (format_uppercase_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "format_lowercase"), "activate", G_CALLBACK (format_lowercase_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "format_strip_spaces"), "activate", G_CALLBACK (format_strip_spaces_activate), NULL); //For Search Menu g_signal_connect (gtk_builder_get_object (builder, "search_find"), "activate", G_CALLBACK (search_find_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "search_find_next"), "activate", G_CALLBACK (search_find_next_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "search_find_prev"), "activate", G_CALLBACK (search_find_prev_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "search_find_replace"), "activate", G_CALLBACK (search_find_replace_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "search_find_selected"), "activate", G_CALLBACK (search_find_selected_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "search_find_in_text"), "activate", G_CALLBACK (search_find_in_text_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "search_find_file"), "activate", G_CALLBACK (search_find_file_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "search_replace_file"), "activate", G_CALLBACK (search_replace_file_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "search_reg_exp"), "activate", G_CALLBACK (search_reg_exp_activate), NULL); //For Navigation Menu g_signal_connect (gtk_builder_get_object (builder, "navigate_back"), "activate", G_CALLBACK (navigate_back_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_forward"), "activate", G_CALLBACK (navigate_forward_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_first_line"), "activate", G_CALLBACK (navigate_first_line_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_last_line"), "activate", G_CALLBACK (navigate_last_line_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_line_history"), "select", G_CALLBACK (navigate_line_history_select), NULL); g_signal_connect (gtk_builder_get_object (builder, "naviagate_add_bookmark"), "activate", G_CALLBACK (naviagate_add_bookmark_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "naviagate_clear_bookmarks"), "activate", G_CALLBACK (naviagate_clear_bookmarks_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_prev_bookmarks"), "activate", G_CALLBACK (navigate_prev_bookmarks_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_next_bookmark"), "activate", G_CALLBACK (navigate_next_bookmark_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_bookmarks"), "activate", G_CALLBACK (navigate_bookmarks_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_line"), "activate", G_CALLBACK (navigate_go_to_line_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_block_start"), "activate", G_CALLBACK (navigate_go_to_block_start_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_func_def"), "activate", G_CALLBACK (navigate_go_to_func_def_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_next_func"), "activate", G_CALLBACK (navigate_go_to_next_func_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_prev_func"), "activate", G_CALLBACK (navigate_go_to_prev_func_activate), NULL); //For Project Menu g_signal_connect (gtk_builder_get_object (builder, "project_new"), "activate", G_CALLBACK (project_new_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "project_open"), "activate", G_CALLBACK (project_open_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "project_save"), "activate", G_CALLBACK (project_save_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "project_save_as"), "activate", G_CALLBACK (project_save_as_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "project_save_copy_as"), "activate", G_CALLBACK (project_save_copy_as_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "project_empty"), "activate", G_CALLBACK (project_empty_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "project_close"), "activate", G_CALLBACK (project_close_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "project_preferences"), "activate", G_CALLBACK (project_preferences_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "project_recent"), "activate", G_CALLBACK (project_recent_activate), NULL); //For Python Shell Menu g_signal_connect (gtk_builder_get_object (builder, "python_shell_open"), "activate", G_CALLBACK (python_shell_open_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "python_shell_restart"), "activate", G_CALLBACK (python_shell_restart_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "python_shell_close"), "activate", G_CALLBACK (python_shell_close_activate), NULL); //For Run Menu g_signal_connect (gtk_builder_get_object (builder, "run_run_script"), "activate", G_CALLBACK (run_run_script_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "run_debug_script"), "activate", G_CALLBACK (run_debug_script_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "run_run_project"), "activate", G_CALLBACK (run_run_project_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "run_debug_project"), "activate", G_CALLBACK (run_debug_project_activate), NULL); //For Debug Menu g_signal_connect (gtk_builder_get_object (builder, "debug_open_pdb_shell"), "activate", G_CALLBACK (debug_open_pdb_shell_activate), NULL); //For Tools Menu g_signal_connect (gtk_builder_get_object (builder, "tools_options"), "activate", G_CALLBACK (tools_options_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "tools_auto_indent"), "activate", G_CALLBACK (tools_auto_indent_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "tools_class_browser"), "activate", G_CALLBACK (tools_class_browser_activate), NULL); /*************************/ /**Connecting Toolbar's signals**/ g_signal_connect (gtk_builder_get_object (builder, "toolbar_new_menu"), "clicked", G_CALLBACK (toolbar_new_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_new_file"), "activate", G_CALLBACK (toolbar_new_file_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_new_project"), "activate", G_CALLBACK (toolbar_new_proj_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_menu"), "clicked", G_CALLBACK (toolbar_open_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_file"), "activate", G_CALLBACK (toolbar_open_file_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_project"), "activate", G_CALLBACK (toolbar_open_proj_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_menu"), "clicked", G_CALLBACK (toolbar_save_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_file"), "activate", G_CALLBACK (toolbar_save_file_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_project"), "activate", G_CALLBACK (toolbar_save_project_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_as"), "clicked", G_CALLBACK (toolbar_save_as_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_as_file"), "activate", G_CALLBACK (toolbar_save_as_file_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_as_project"), "activate", G_CALLBACK (toolbar_save_as_project_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_undo"), "clicked", G_CALLBACK (toolbar_undo_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_redo"), "clicked", G_CALLBACK (toolbar_redo_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_cut"), "clicked", G_CALLBACK (toolbar_cut_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_copy"), "clicked", G_CALLBACK (toolbar_copy_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_paste"), "clicked", G_CALLBACK (toolbar_cut_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_delete"), "clicked", G_CALLBACK (toolbar_delete_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_select_all"), "clicked", G_CALLBACK (toolbar_select_all_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_find"), "clicked", G_CALLBACK (toolbar_find_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_find_replace"), "clicked", G_CALLBACK (toolbar_find_replace_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_inc_indent"), "clicked", G_CALLBACK (toolbar_inc_indent_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_dec_indent"), "clicked", G_CALLBACK (toolbar_dec_indent_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_next_line"), "clicked", G_CALLBACK (navigate_forward_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_prev_line"), "clicked", G_CALLBACK (navigate_back_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_add_bookmark"), "clicked", G_CALLBACK (naviagate_add_bookmark_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_next_bookmark"), "clicked", G_CALLBACK (navigate_next_bookmark_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_prev_bookmark"), "clicked", G_CALLBACK (navigate_prev_bookmarks_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_clear_bookmark"), "clicked", G_CALLBACK (naviagate_clear_bookmarks_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_run"), "clicked", G_CALLBACK (toolbar_run), NULL); /*g_signal_connect (gtk_builder_get_object (builder, "toolbar_debug"), "clicked", G_CALLBACK (toolbar_dec_indent_clicked), NULL); */ g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_shell"), "clicked", G_CALLBACK (python_shell_open_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_options"), "clicked", G_CALLBACK (tools_options_activate), NULL); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_add_bookmark")), gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksadd.png",NULL))); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_next_bookmark")), gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksnext.png",NULL))); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_prev_bookmark")), gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksprev.png",NULL))); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_clear_bookmark")), gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksclear.png",NULL))); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_debug")), gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/debug.png",NULL))); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_open_shell")), gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/python_shell.png",NULL))); /*************************/ line_history_menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (gtk_builder_get_object (builder, "navigate_line_history")), line_history_menu); GtkRecentFilter *py_recent_filter = gtk_recent_filter_new (); gtk_recent_filter_set_name (py_recent_filter, "Python Files"); gtk_recent_filter_add_pattern (py_recent_filter, "*.py"); gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (gtk_builder_get_object (builder, "recentchoosermenu")), py_recent_filter); /* Connecting window's signals and events */ g_signal_connect (window, "delete-event", G_CALLBACK (delete_event), NULL); g_signal_connect (window, "destroy", G_CALLBACK (main_window_destroy), NULL); /********************************/ /*Other global variables*/ search_text = NULL; bookmark_array= NULL; bookmark_array_size = 0; current_bookmark_index = -1; /******************/ /*Initialize Regular Expressions*/ regex_class = g_regex_new ("[ \\ \\t]*\\bclass\\b\\s*\\w+\\s*\\(*.*\\)*:", 0, 0, NULL); regex_func = g_regex_new ("[ \\ \\t]*def\\s+[\\w\\d_]+\\s*\\(.+\\)\\:", 0, 0, NULL); /*Regex if you don't want to search imports with in indentation*/ /*regex_import = g_regex_new ("^import\\s+[\\w\\d_\\.]+", 0, 0, NULL); regex_import_as = g_regex_new ("^import\\s+[\\w\\d_\\.]+\\s+as\\s+[\\w\\d_]+", 0, 0, NULL);*/ regex_from_import = g_regex_new ("^from\\s+[\\w\\d_\\.]+\\s+import\\s+[\\w\\d_]+", 0, 0, NULL); regex_from_import_as = g_regex_new ("^from\\s+[\\w\\d_\\.]+\\s+import\\s+[\\w\\d_]+as\\s+[\\w\\d_]", 0, 0, NULL); regex_global_var = g_regex_new ("^[\\w\\d_]+\\s*=\\s*[\\w\\d_]+\\s*\\(.+\\)", 0, 0, NULL); regex_static_var = g_regex_new ("^\\s*[\\w\\d_]+\\s*=.+", 0, 0, NULL); regex_word = g_regex_new ("[self]*[\\w\\d_\\.]+$", 0, 0, NULL); regex_local_var = g_regex_new ("^\\s*[\\w\\d_\\.]+\\s*=.+", 0, 0, NULL); regex_self_var = g_regex_new ("^\\s+self\\.[\\w\\d_]+\\s*=.+", 0, 0, NULL); /*Regex if you want to search imports with in indentation*/ regex_import = g_regex_new ("^\\s*import\\s+[\\w\\d_\\.]+", 0, 0, NULL); regex_import_as = g_regex_new ("^\\s*import\\s+[\\w\\d_]+\\s+as\\s+[\\w\\d_]+", 0, 0, NULL); /***********************/ async_queue = g_async_queue_new (); //Creating code_widget_array //code_widget_array = g_malloc0 (1*sizeof (CodeWidget *)); //code_widget_array [0] = codewidget_new (); code_widget_array_size = 0; notebook = gtk_notebook_new (); g_object_ref (notebook); //gtk_notebook_append_page (GTK_NOTEBOOK (notebook), code_widget_array [0]->vbox, // gtk_label_new ("New File")); /*If bash is not loaded*/ if (!bash_loaded) { gchar *msg = g_strdup_printf ("Cannot run Python Shell (%s)", error->message); gtk_statusbar_push (GTK_STATUSBAR (status_bar), 0, msg); g_free (msg); g_error_free (error); } /****************/ GtkSettings *settings = gtk_settings_get_default (); g_object_set (settings, "gtk-application-prefer-dark-theme", TRUE, NULL); gtk_window_maximize (GTK_WINDOW (window)); gtk_widget_show_all (GTK_WIDGET (window)); gtk_main (); return 0; }
void gui_animate_dialog(void) { gpointer dialog; GtkWidget *window, *main_vbox, *table, *vbox, *hbox; GtkWidget *notebook, *page, *label, *entry, *scale; GList *list; /* prevent recording whilst in animation */ gui_mode_switch(FREE); /* dialog setup */ dialog = dialog_request(ANIM, "Animation and Rendering", NULL, NULL, NULL); if (!dialog) return; window = dialog_window(dialog); gtk_widget_set_size_request(window, 350, -1); /* notebook frame */ main_vbox = gtk_vbox_new(FALSE, PANEL_SPACING); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(window)->vbox), main_vbox); /* create notebook */ vbox = gui_frame_vbox(NULL, FALSE, FALSE, main_vbox); notebook = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(vbox),notebook,FALSE,TRUE,0); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP); gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), TRUE); /* page */ page = gtk_vbox_new(FALSE, PANEL_SPACING); label = gtk_label_new("Control"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label); vbox = gtk_vbox_new(FALSE, PANEL_SPACING); gtk_box_pack_start(GTK_BOX(page),vbox,FALSE,FALSE,0); /* format pulldown */ animate_phonons=FALSE; list = NULL; list = g_list_append(list, "Frames"); list = g_list_append(list, "Phonons"); hbox = gtk_hbox_new(FALSE, 0); label = gtk_label_new("Display "); gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0); entry = gui_pulldown_new(NULL, list, 0, hbox); g_list_free(list); g_signal_connect(GTK_OBJECT(entry), "changed", GTK_SIGNAL_FUNC(gui_animate_type_change), (gpointer) entry); gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0); /* phonon options */ box_phonon_options = gtk_vbox_new(FALSE, PANEL_SPACING); gtk_box_pack_start(GTK_BOX(vbox),box_phonon_options,FALSE,FALSE,0); gui_direct_spin("Phonon scaling ", &sysenv.render.phonon_scaling, 0.1, 9.9, 0.1, NULL, NULL, box_phonon_options); gui_direct_spin("Phonon resolution ", &sysenv.render.phonon_resolution, 10.0, 100.0, 1.0, NULL, NULL, box_phonon_options); gtk_box_pack_start(GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 0); /* CURRENT - FPS */ gui_direct_spin("Apparent FPS for animation ", &gui_animate_fps, 1, 50, 1, NULL, NULL, vbox); /* connectivity options */ gui_direct_check("Recalculate connectivity", &sysenv.render.connect_redo, NULL, NULL, vbox); /* gui_checkbox("Don't recalculate scale", NULL, vbox); gui_checkbox("Loop", NULL, vbox); */ /* actions at start of each cycle */ /* new_radio_group(0, vbox, FF); button = add_radio_button("Confine atoms to PBC", (gpointer) atom_pbc, data); if (data->anim_confine == PBC_CONFINE_ATOMS) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); button = add_radio_button("Confine mols to PBC", (gpointer) mol_pbc, data); if (data->anim_confine == PBC_CONFINE_MOLS) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); button = add_radio_button("Cell confinement off", (gpointer) no_pbc, data); if (data->anim_confine == PBC_CONFINE_NONE) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); */ /* page */ page = gtk_vbox_new(FALSE, PANEL_SPACING); label = gtk_label_new("Render"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label); vbox = gtk_vbox_new(FALSE, PANEL_SPACING); gtk_box_pack_start(GTK_BOX(page),vbox,FALSE,FALSE,0); gui_direct_spin("Width", &sysenv.render.width, 100, 2000, 100, NULL, NULL, vbox); gui_direct_spin("Height", &sysenv.render.height, 100, 2000, 100, NULL, NULL, vbox); gtk_box_pack_start(GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 0); gui_direct_check("Shadowless", &sysenv.render.shadowless, NULL, NULL, vbox); gui_direct_check("Create povray input then stop", &sysenv.render.no_povray_exec, NULL, NULL, vbox); gui_direct_check("Cleanup temporary files", &sysenv.render.no_keep_tempfiles, NULL, NULL, vbox); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0); gui_button(" Render ", gui_animate_render, NULL, hbox, TF); /* page */ page = gtk_vbox_new(FALSE, PANEL_SPACING); label = gtk_label_new("Movie"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label); vbox = gtk_vbox_new(FALSE, PANEL_SPACING); gtk_box_pack_start(GTK_BOX(page),vbox,FALSE,FALSE,0); table = gtk_table_new(4, 4, FALSE); gtk_box_pack_start(GTK_BOX(vbox),table,FALSE,FALSE,0); /* name label */ label = gtk_label_new("Filename"); gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,0,1); /* name entry */ /* entry = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(entry), sysenv.render.animate_file); */ entry = gui_text_entry(NULL, &sysenv.render.animate_file, TRUE, FALSE, NULL); gtk_table_attach_defaults(GTK_TABLE(table),entry,1,2,0,1); /* format label */ label = gtk_label_new("Format"); gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,1,2); /* format pulldown */ list=NULL; list = g_list_append(list, "mpg"); list = g_list_append(list, "mp4"); list = g_list_append(list, "flv"); list = g_list_append(list, "avi"); hbox = gtk_hbox_new(FALSE, 0); entry_movie_type = gui_pulldown_new(NULL, list, 0, hbox); g_list_free(list); g_signal_connect(GTK_OBJECT(entry_movie_type), "changed", GTK_SIGNAL_FUNC(gui_animate_movie_type_change), (gpointer) entry); gtk_table_attach_defaults(GTK_TABLE(table),hbox,1,2,1,2); /* update hook */ g_signal_connect(GTK_OBJECT(entry), "changed", GTK_SIGNAL_FUNC(event_render_modify), (gpointer) entry); g_object_set_data(G_OBJECT(entry), "id", (gpointer) ANIM_NAME); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0); gui_button(" Create ", gui_animate_movie, NULL, hbox, TF); /* slider for current frame */ vbox = gui_frame_vbox(NULL, FALSE, FALSE, main_vbox); scale = gtk_hscale_new_with_range(1.0, 100.0, 1.0); gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_CONTINUOUS); gtk_box_pack_start(GTK_BOX(vbox), scale, TRUE, TRUE, 0); g_signal_connect(GTK_OBJECT(scale), "value_changed", GTK_SIGNAL_FUNC(gui_animate_frame_select), NULL); gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE); /* animation limits */ vbox = gui_frame_vbox(NULL, FALSE, FALSE, main_vbox); gui_text_entry("First ", &entry_frame_start, TRUE, FALSE, vbox); gui_text_entry("Last ", &entry_frame_stop, TRUE, FALSE, vbox); gui_text_entry("Step ", &entry_frame_step, TRUE, FALSE, vbox); /* control buttons */ hbox = gtk_hbox_new(TRUE, PANEL_SPACING); gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, FALSE, 0); gui_icon_button("GDIS_REWIND", NULL, gui_animate_first, NULL, hbox); gui_icon_button("GDIS_STEP_BACKWARD", NULL, gui_animate_back, NULL, hbox); gui_icon_button("GDIS_PLAY", NULL, gui_animate_play, NULL, hbox); gui_icon_button("GDIS_PAUSE", NULL, gui_animate_stop, NULL, hbox); gui_icon_button("GDIS_STEP_FORWARD", NULL, gui_animate_next, NULL, hbox); gui_icon_button("GDIS_FASTFORWARD", NULL, gui_animate_last, NULL, hbox); gui_stock_button(GTK_STOCK_HELP, gui_help_show, "Animation and Rendering", GTK_DIALOG(window)->action_area); /* terminating button */ gui_stock_button(GTK_STOCK_CLOSE, dialog_destroy, dialog, GTK_DIALOG(window)->action_area); /* display the dialog */ gtk_widget_show_all(window); gtk_widget_hide(box_phonon_options); }
static void mp3_configure(void) { gint i; if (!configure_win) { configure_win = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_type_hint(GTK_WINDOW(configure_win), GDK_WINDOW_TYPE_HINT_DIALOG); g_signal_connect (configure_win, "destroy", (GCallback) gtk_widget_destroyed, & configure_win); gtk_window_set_title(GTK_WINDOW(configure_win), _("MP3 Configuration")); gtk_window_set_position(GTK_WINDOW(configure_win), GTK_WIN_POS_MOUSE); gtk_container_set_border_width(GTK_CONTAINER(configure_win), 5); vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_add(GTK_CONTAINER(configure_win), vbox); notebook = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0); /* Quality */ quality_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_set_border_width(GTK_CONTAINER(quality_vbox), 5); quality_hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_box_pack_start(GTK_BOX(quality_vbox), quality_hbox1, FALSE, FALSE, 0); /* Algorithm Quality */ alg_quality_frame = gtk_frame_new(_("Algorithm Quality:")); gtk_container_set_border_width(GTK_CONTAINER(alg_quality_frame), 5); gtk_box_pack_start(GTK_BOX(quality_hbox1), alg_quality_frame, FALSE, FALSE, 0); alg_quality_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_set_border_width(GTK_CONTAINER(alg_quality_hbox), 10); gtk_container_add(GTK_CONTAINER(alg_quality_frame), alg_quality_hbox); alg_quality_adj = (GtkAdjustment *) gtk_adjustment_new (5, 0, 9, 1, 1, 0); alg_quality_spin = gtk_spin_button_new(GTK_ADJUSTMENT(alg_quality_adj), 8, 0); gtk_box_pack_start(GTK_BOX(alg_quality_hbox), alg_quality_spin, TRUE, TRUE, 0); g_signal_connect (alg_quality_adj, "value-changed", (GCallback) algo_qual, NULL); gtk_spin_button_set_value(GTK_SPIN_BUTTON(alg_quality_spin), algo_quality_val); /* Output Samplerate */ samplerate_frame = gtk_frame_new(_("Output Samplerate:")); gtk_container_set_border_width(GTK_CONTAINER(samplerate_frame), 5); gtk_box_pack_start(GTK_BOX(quality_hbox1), samplerate_frame, FALSE, FALSE, 0); samplerate_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_set_border_width(GTK_CONTAINER(samplerate_hbox), 10); gtk_container_add(GTK_CONTAINER(samplerate_frame), samplerate_hbox); GtkWidget * combo = gtk_combo_box_text_new (); gtk_combo_box_text_append_text ((GtkComboBoxText *) combo, _("Auto")); if (! out_samplerate_val) gtk_combo_box_set_active ((GtkComboBox *) combo, 0); for (i = 0; i < G_N_ELEMENTS (available_samplerates); i ++) { gchar buf[10]; snprintf (buf, sizeof buf, "%d", available_samplerates[i]); gtk_combo_box_text_append_text ((GtkComboBoxText *) combo, buf); if (out_samplerate_val == available_samplerates[i]) gtk_combo_box_set_active ((GtkComboBox *) combo, 1 + i); } gtk_box_pack_start ((GtkBox *) samplerate_hbox, combo, FALSE, FALSE, 0); g_signal_connect (combo, "changed", (GCallback) samplerate_changed, NULL); samplerate_label = gtk_label_new(_("(Hz)")); gtk_misc_set_alignment(GTK_MISC(samplerate_label), 0, 0.5); gtk_box_pack_start(GTK_BOX(samplerate_hbox), samplerate_label, FALSE, FALSE, 0); /* Encoder Quality */ enc_quality_frame = gtk_frame_new(_("Bitrate / Compression ratio:")); gtk_container_set_border_width(GTK_CONTAINER(enc_quality_frame), 5); gtk_box_pack_start(GTK_BOX(quality_vbox), enc_quality_frame, FALSE, FALSE, 0); // vbox sorrounding hbox1 and hbox2 enc_quality_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_set_border_width(GTK_CONTAINER(enc_quality_vbox), 10); // pack vbox to frame gtk_container_add(GTK_CONTAINER(enc_quality_frame), enc_quality_vbox); // hbox1 for bitrate hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_add(GTK_CONTAINER(enc_quality_vbox), hbox1); // radio 1 enc_radio1 = gtk_radio_button_new(NULL); if (enc_toggle_val == 0) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enc_radio1), TRUE); gtk_box_pack_start(GTK_BOX(hbox1), enc_radio1, FALSE, FALSE, 0); // label 1 enc_quality_label1 = gtk_label_new(_("Bitrate (kbps):")); gtk_box_pack_start(GTK_BOX(hbox1), enc_quality_label1, FALSE, FALSE, 0); // bitrate menu combo = gtk_combo_box_text_new (); for (i = 0; i < G_N_ELEMENTS (available_bitrates); i ++) { gchar buf[10]; snprintf (buf, sizeof buf, "%d", available_bitrates[i]); gtk_combo_box_text_append_text ((GtkComboBoxText *) combo, buf); if (bitrate_val == available_bitrates[i]) gtk_combo_box_set_active ((GtkComboBox *) combo, i); } gtk_box_pack_start ((GtkBox *) hbox1, combo, FALSE, FALSE, 0); g_signal_connect (combo, "changed", (GCallback) bitrate_changed, NULL); // hbox2 for compression ratio hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_add(GTK_CONTAINER(enc_quality_vbox), hbox2); // radio 2 enc_radio2 = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(enc_radio1)); if (enc_toggle_val == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enc_radio2), TRUE); // pack radio 2 gtk_box_pack_start(GTK_BOX(hbox2), enc_radio2, FALSE, FALSE, 0); // label enc_quality_label2 = gtk_label_new(_("Compression ratio:")); gtk_box_pack_start(GTK_BOX(hbox2), enc_quality_label2, FALSE, FALSE, 0); // comp-ratio spin compression_adj = (GtkAdjustment *) gtk_adjustment_new (11, 0, 100, 1, 1, 0); compression_spin = gtk_spin_button_new(GTK_ADJUSTMENT(compression_adj), 8, 0); gtk_box_pack_end(GTK_BOX(hbox2), compression_spin, FALSE, FALSE, 0); g_signal_connect (compression_adj, "value-changed", (GCallback) compression_change, NULL); gtk_spin_button_set_value(GTK_SPIN_BUTTON(compression_spin), compression_val); // radio button signale connect g_signal_connect (enc_radio1, "toggled", (GCallback) encoding_toggle, GINT_TO_POINTER (0)); g_signal_connect (enc_radio2, "toggled", (GCallback) encoding_toggle, GINT_TO_POINTER (1)); /* Audio Mode */ mode_frame = gtk_frame_new(_("Audio Mode:")); gtk_container_set_border_width(GTK_CONTAINER(mode_frame), 5); gtk_box_pack_start(GTK_BOX(quality_vbox), mode_frame, FALSE, FALSE, 0); mode_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10); gtk_container_set_border_width(GTK_CONTAINER(mode_hbox), 10); gtk_container_add(GTK_CONTAINER(mode_frame), mode_hbox); combo = gtk_combo_box_text_new (); for (i = 0; i < MODES; i ++) { gtk_combo_box_text_append_text ((GtkComboBoxText *) combo, _(mode_names[i])); if (audio_mode_val == modes[i]) gtk_combo_box_set_active ((GtkComboBox *) combo, i); } gtk_box_pack_start ((GtkBox *) mode_hbox, combo, FALSE, FALSE, 0); g_signal_connect (combo, "changed", (GCallback) mode_changed, NULL); /* Misc */ misc_frame = gtk_frame_new(_("Misc:")); gtk_container_set_border_width(GTK_CONTAINER(misc_frame), 5); gtk_box_pack_start(GTK_BOX(quality_vbox), misc_frame, FALSE, FALSE, 0); misc_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_set_border_width(GTK_CONTAINER(misc_vbox), 5); gtk_container_add(GTK_CONTAINER(misc_frame), misc_vbox); enforce_iso_toggle = gtk_check_button_new_with_label (_("Enforce strict ISO complience")); gtk_box_pack_start(GTK_BOX(misc_vbox), enforce_iso_toggle, TRUE, TRUE, 2); g_signal_connect (enforce_iso_toggle, "toggled", (GCallback) toggle_enforce_iso, NULL); if (enforce_iso_val == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (enforce_iso_toggle), TRUE); error_protection_toggle = gtk_check_button_new_with_label(_("Error protection")); gtk_box_pack_start(GTK_BOX(misc_vbox), error_protection_toggle, TRUE, TRUE, 2); g_signal_connect (error_protection_toggle, "toggled", (GCallback) toggle_error_protect, NULL); if (error_protect_val == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (error_protection_toggle), TRUE); /* Add the Notebook */ gtk_notebook_append_page(GTK_NOTEBOOK(notebook), quality_vbox, gtk_label_new(_("Quality"))); /* VBR/ABR */ vbr_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_set_border_width(GTK_CONTAINER(vbr_vbox), 5); /* Toggle VBR */ vbr_toggle = gtk_check_button_new_with_label(_("Enable VBR/ABR")); gtk_box_pack_start(GTK_BOX(vbr_vbox), vbr_toggle, FALSE, FALSE, 2); g_signal_connect (vbr_toggle, "toggled", (GCallback) toggle_vbr, NULL); vbr_options_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_add(GTK_CONTAINER(vbr_vbox), vbr_options_vbox); gtk_widget_set_sensitive(vbr_options_vbox, FALSE); /* Choose VBR/ABR */ vbr_type_frame = gtk_frame_new(_("Type:")); gtk_container_set_border_width(GTK_CONTAINER(vbr_type_frame), 5); gtk_box_pack_start(GTK_BOX(vbr_options_vbox), vbr_type_frame, FALSE, FALSE, 2); vbr_type_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_set_border_width(GTK_CONTAINER(vbr_type_hbox), 5); gtk_container_add(GTK_CONTAINER(vbr_type_frame), vbr_type_hbox); vbr_type_radio1 = gtk_radio_button_new_with_label(NULL, "VBR"); gtk_box_pack_start(GTK_BOX(vbr_type_hbox), vbr_type_radio1, TRUE, TRUE, 2); if (vbr_type == 0) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (vbr_type_radio1), TRUE); vbr_type_radio2 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (vbr_type_radio1), "ABR"); gtk_box_pack_start(GTK_BOX(vbr_type_hbox), vbr_type_radio2, TRUE, TRUE, 2); if (vbr_type == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (vbr_type_radio2), TRUE); g_signal_connect (vbr_type_radio1, "toggled", (GCallback) vbr_abr_toggle, "VBR"); g_signal_connect (vbr_type_radio2, "toggled", (GCallback) vbr_abr_toggle, "ABR"); /* VBR Options */ vbr_frame = gtk_frame_new(_("VBR Options:")); gtk_container_set_border_width(GTK_CONTAINER(vbr_frame), 5); gtk_box_pack_start(GTK_BOX(vbr_options_vbox), vbr_frame, FALSE, FALSE, 2); vbr_options_vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_set_border_width(GTK_CONTAINER(vbr_options_vbox2), 5); gtk_container_add(GTK_CONTAINER(vbr_frame), vbr_options_vbox2); vbr_options_hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_set_border_width(GTK_CONTAINER(vbr_options_hbox1), 5); gtk_container_add(GTK_CONTAINER(vbr_options_vbox2), vbr_options_hbox1); vbr_min_label = gtk_label_new(_("Minimum bitrate (kbps):")); gtk_misc_set_alignment(GTK_MISC(vbr_min_label), 0, 0.5); gtk_box_pack_start(GTK_BOX(vbr_options_hbox1), vbr_min_label, TRUE, TRUE, 0); combo = gtk_combo_box_text_new (); for (i = 0; i < G_N_ELEMENTS (available_bitrates); i ++) { gchar buf[10]; snprintf (buf, sizeof buf, "%d", available_bitrates[i]); gtk_combo_box_text_append_text ((GtkComboBoxText *) combo, buf); if (vbr_min_val == available_bitrates[i]) gtk_combo_box_set_active ((GtkComboBox *) combo, i); } gtk_box_pack_start ((GtkBox *) vbr_options_hbox1, combo, FALSE, FALSE, 0); g_signal_connect (combo, "changed", (GCallback) vbr_min_changed, NULL); vbr_options_hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_set_border_width(GTK_CONTAINER(vbr_options_hbox2), 5); gtk_container_add(GTK_CONTAINER(vbr_options_vbox2), vbr_options_hbox2); vbr_max_label = gtk_label_new(_("Maximum bitrate (kbps):")); gtk_misc_set_alignment(GTK_MISC(vbr_max_label), 0, 0.5); gtk_box_pack_start(GTK_BOX(vbr_options_hbox2), vbr_max_label, TRUE, TRUE, 0); combo = gtk_combo_box_text_new (); for (i = 0; i < G_N_ELEMENTS (available_bitrates); i ++) { gchar buf[10]; snprintf (buf, sizeof buf, "%d", available_bitrates[i]); gtk_combo_box_text_append_text ((GtkComboBoxText *) combo, buf); if (vbr_max_val == available_bitrates[i]) gtk_combo_box_set_active ((GtkComboBox *) combo, i); } gtk_box_pack_start ((GtkBox *) vbr_options_hbox2, combo, FALSE, FALSE, 0); g_signal_connect (combo, "changed", (GCallback) vbr_max_changed, NULL); enforce_min_toggle = gtk_check_button_new_with_label (_("Strictly enforce minimum bitrate")); gtk_box_pack_start(GTK_BOX(vbr_options_vbox2), enforce_min_toggle, FALSE, FALSE, 2); g_signal_connect (enforce_min_toggle, "toggled", (GCallback) toggle_enforce_min, NULL); if (enforce_min_val == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (enforce_min_toggle), TRUE); /* ABR Options */ abr_frame = gtk_frame_new(_("ABR Options:")); gtk_container_set_border_width(GTK_CONTAINER(abr_frame), 5); gtk_box_pack_start(GTK_BOX(vbr_options_vbox), abr_frame, FALSE, FALSE, 2); gtk_widget_set_sensitive(abr_frame, FALSE); abr_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_set_border_width(GTK_CONTAINER(abr_hbox), 5); gtk_container_add(GTK_CONTAINER(abr_frame), abr_hbox); abr_label = gtk_label_new(_("Average bitrate (kbps):")); gtk_misc_set_alignment(GTK_MISC(abr_label), 0, 0.5); gtk_box_pack_start(GTK_BOX(abr_hbox), abr_label, TRUE, TRUE, 0); combo = gtk_combo_box_text_new (); for (i = 0; i < G_N_ELEMENTS (available_bitrates); i ++) { gchar buf[10]; snprintf (buf, sizeof buf, "%d", available_bitrates[i]); gtk_combo_box_text_append_text ((GtkComboBoxText *) combo, buf); if (abr_val == available_bitrates[i]) gtk_combo_box_set_active ((GtkComboBox *) combo, i); } gtk_box_pack_start ((GtkBox *) abr_hbox, combo, FALSE, FALSE, 0); g_signal_connect (combo, "changed", (GCallback) abr_changed, NULL); /* Quality Level */ vbr_options_hbox3 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_set_border_width(GTK_CONTAINER(vbr_options_hbox3), 5); gtk_container_add(GTK_CONTAINER(vbr_options_vbox), vbr_options_hbox3); vbr_quality_label = gtk_label_new(_("VBR quality level:")); gtk_misc_set_alignment(GTK_MISC(vbr_quality_label), 0, 0.5); gtk_box_pack_start(GTK_BOX(vbr_options_hbox3), vbr_quality_label, TRUE, TRUE, 0); vbr_quality_adj = (GtkAdjustment *) gtk_adjustment_new (4, 0, 9, 1, 1, 0); vbr_quality_spin = gtk_spin_button_new(GTK_ADJUSTMENT(vbr_quality_adj), 8, 0); gtk_box_pack_start(GTK_BOX(vbr_options_hbox3), vbr_quality_spin, TRUE, TRUE, 0); g_signal_connect (vbr_quality_adj, "value-changed", (GCallback) vbr_qual, NULL); gtk_spin_button_set_value(GTK_SPIN_BUTTON(vbr_quality_spin), vbr_quality_val); /* Xing Header */ xing_header_toggle = gtk_check_button_new_with_label(_("Don't write Xing VBR header")); gtk_box_pack_start(GTK_BOX(vbr_options_vbox), xing_header_toggle, FALSE, FALSE, 2); g_signal_connect (xing_header_toggle, "toggled", (GCallback) toggle_xing, NULL); if (toggle_xing_val == 0) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (xing_header_toggle), TRUE); /* Add the Notebook */ gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbr_vbox, gtk_label_new(_("VBR/ABR"))); /* Tags */ tags_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_set_border_width(GTK_CONTAINER(tags_vbox), 5); /* Frame Params */ tags_frames_frame = gtk_frame_new(_("Frame params:")); gtk_container_set_border_width(GTK_CONTAINER(tags_frames_frame), 5); gtk_box_pack_start(GTK_BOX(tags_vbox), tags_frames_frame, FALSE, FALSE, 2); tags_frames_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_set_border_width(GTK_CONTAINER(tags_frames_hbox), 5); gtk_container_add(GTK_CONTAINER(tags_frames_frame), tags_frames_hbox); tags_copyright_toggle = gtk_check_button_new_with_label(_("Mark as copyright")); gtk_box_pack_start(GTK_BOX(tags_frames_hbox), tags_copyright_toggle, FALSE, FALSE, 2); g_signal_connect (tags_copyright_toggle, "toggled", (GCallback) toggle_copyright, NULL); if (mark_copyright_val == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (tags_copyright_toggle), TRUE); tags_original_toggle = gtk_check_button_new_with_label(_("Mark as original")); gtk_box_pack_start(GTK_BOX(tags_frames_hbox), tags_original_toggle, FALSE, FALSE, 2); g_signal_connect (tags_original_toggle, "toggled", (GCallback) toggle_original, NULL); if (mark_original_val == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (tags_original_toggle), TRUE); /* ID3 Params */ tags_id3_frame = gtk_frame_new(_("ID3 params:")); gtk_container_set_border_width(GTK_CONTAINER(tags_id3_frame), 5); gtk_box_pack_start(GTK_BOX(tags_vbox), tags_id3_frame, FALSE, FALSE, 2); tags_id3_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_set_border_width(GTK_CONTAINER(tags_id3_vbox), 5); gtk_container_add(GTK_CONTAINER(tags_id3_frame), tags_id3_vbox); tags_force_id3v2_toggle = gtk_check_button_new_with_label (_("Force addition of version 2 tag")); gtk_box_pack_start(GTK_BOX(tags_id3_vbox), tags_force_id3v2_toggle, FALSE, FALSE, 2); g_signal_connect (tags_force_id3v2_toggle, "toggled", (GCallback) force_v2_toggle, NULL); tags_id3_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_add(GTK_CONTAINER(tags_id3_vbox), tags_id3_hbox); tags_only_v1_toggle = gtk_check_button_new_with_label(_("Only add v1 tag")); gtk_box_pack_start(GTK_BOX(tags_id3_hbox), tags_only_v1_toggle, FALSE, FALSE, 2); g_signal_connect (tags_only_v1_toggle, "toggled", (GCallback) id3_only_version, "v1"); tags_only_v2_toggle = gtk_check_button_new_with_label(_("Only add v2 tag")); gtk_box_pack_start(GTK_BOX(tags_id3_hbox), tags_only_v2_toggle, FALSE, FALSE, 2); g_signal_connect (tags_only_v2_toggle, "toggled", (GCallback) id3_only_version, "v2"); if (force_v2_val == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (tags_force_id3v2_toggle), TRUE); if (only_v1_val == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (tags_only_v1_toggle), TRUE); if (only_v2_val == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (tags_only_v2_toggle), TRUE); /* Add the Notebook */ gtk_notebook_append_page(GTK_NOTEBOOK(notebook), tags_vbox, gtk_label_new(_("Tags"))); /* The Rest */ /* Buttons */ configure_bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); gtk_button_box_set_layout(GTK_BUTTON_BOX(configure_bbox), GTK_BUTTONBOX_END); gtk_box_pack_start(GTK_BOX(vbox), configure_bbox, FALSE, FALSE, 0); configure_cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL); g_signal_connect_swapped (configure_cancel, "clicked", (GCallback) gtk_widget_destroy, configure_win); gtk_box_pack_start(GTK_BOX(configure_bbox), configure_cancel, TRUE, TRUE, 0); configure_ok = gtk_button_new_from_stock(GTK_STOCK_OK); g_signal_connect (configure_ok, "clicked", (GCallback) configure_ok_cb, NULL); gtk_box_pack_start(GTK_BOX(configure_bbox), configure_ok, TRUE, TRUE, 0); gtk_widget_show(configure_ok); /* Set States */ if (vbr_on == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(vbr_toggle), TRUE); else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(vbr_toggle), FALSE); /* Show it! */ gtk_widget_show_all(configure_win); } }
int main (int argc, char **argv) { progdata *pdat; GtkWidget *window, *button, *bar; // boxes GtkWidget *vbox1, *topbox, *midbox, *setbox, *datbox, *drawbox, *noteb, *notebp1, *optnbox; //frames GtkWidget *dtbfrm, *drwfrm; pdat = calloc (1, sizeof (progdata)); strcpy (pdat->val, "value= "); gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (window), 720, 576); gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER); ///////////////////////////////////////////////////////////////////////////////////////////// vbox1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox1); topbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX(vbox1), topbox, FALSE, TRUE, 0); midbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX(vbox1), midbox, TRUE, TRUE, 0); setbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_end (GTK_BOX(vbox1), setbox, FALSE, FALSE, 0); datbox = gtk_vbox_new (FALSE, 0); gtk_box_pack_end (GTK_BOX(midbox), datbox, FALSE, FALSE, 0); dtbfrm = gtk_frame_new ("Opções"); gtk_box_pack_start (GTK_BOX (datbox), dtbfrm, TRUE, TRUE,0); drawbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX(midbox), drawbox, TRUE, TRUE, 0); drwfrm = gtk_frame_new ("main"); gtk_container_add (GTK_CONTAINER (drawbox), drwfrm); notebp1 = gtk_vbox_new(FALSE, 0); optnbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(dtbfrm),optnbox); ///////////////////////////////////////////////////////////////////////////////////////////// pdat->adj = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0); bar = gtk_hscale_new (GTK_ADJUSTMENT (pdat->adj)); gtk_box_pack_start (GTK_BOX (optnbox), bar, FALSE, TRUE, 0); pdat->lbl = gtk_label_new (pdat->val); gtk_box_pack_start (GTK_BOX (topbox), pdat->lbl, TRUE, TRUE, 0); noteb = gtk_notebook_new(); gtk_notebook_append_page (GTK_NOTEBOOK(noteb),notebp1,NULL); gtk_box_pack_start(GTK_BOX(setbox),noteb, TRUE, TRUE, 0); button = gtk_button_new_with_label("\treset\t"); gtk_box_pack_start(GTK_BOX(optnbox), button, FALSE, FALSE ,20); ///////////////////////////////////////////////////////////////////////////////////////////// g_signal_connect_swapped (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (set_val), pdat); g_signal_connect (G_OBJECT (pdat->adj), "value-changed", G_CALLBACK (upd_txt), pdat); gtk_widget_show_all(window); gtk_main (); return 0; }
bool RunLinuxDialog() { GtkWidget *dialog; int return_value; /* Create the widgets */ dialog = gtk_dialog_new_with_buttons ( "GSdx Config", NULL, /* parent window*/ (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), "OK", GTK_RESPONSE_ACCEPT, // "Cancel", GTK_RESPONSE_REJECT, // Drop because it is too annoying to support call back this way NULL); // The main area for the whole dialog box. GtkWidget* main_box = gtk_vbox_new(false, 5); GtkWidget* central_box = gtk_vbox_new(false, 5); GtkWidget* advanced_box = gtk_vbox_new(false, 5); GtkWidget* debug_box = gtk_vbox_new(false, 5); GtkWidget* osd_box = gtk_vbox_new(false, 5); // Grab a logo, to make things look nice. GResource * resources = GSdx_res_get_resource(); GInputStream * ogl_stream=g_resource_open_stream(resources,"/GSdx/res/logo-ogl.bmp",G_RESOURCE_LOOKUP_FLAGS_NONE,NULL); GdkPixbuf * ogl_logo = gdk_pixbuf_new_from_stream(ogl_stream,NULL,NULL); g_object_unref(ogl_stream); GtkWidget* logo_image = gtk_image_new_from_pixbuf(ogl_logo); gtk_box_pack_start(GTK_BOX(main_box), logo_image, true, true, 0); GtkWidget* main_table = CreateTableInBox(main_box , NULL , 2 , 2); GtkWidget* hw_table = CreateTableInBox(central_box , "Hardware Mode Settings" , 7 , 2); GtkWidget* sw_table = CreateTableInBox(central_box , "Software Mode Settings" , 2 , 2); GtkWidget* hack_table = CreateTableInBox(advanced_box, "Hacks" , 7 , 2); GtkWidget* gl_table = CreateTableInBox(advanced_box, "OpenGL Very Advanced Custom Settings" , 6 , 2); GtkWidget* record_table = CreateTableInBox(debug_box , "Recording Settings" , 4 , 3); GtkWidget* debug_table = CreateTableInBox(debug_box , "OpenGL / GSdx Debug Settings" , 6 , 3); GtkWidget* shader_table = CreateTableInBox(osd_box , "Custom Shader Settings" , 9 , 2); GtkWidget* osd_table = CreateTableInBox(osd_box , "OSD" , 6 , 2); // Populate all the tables populate_main_table(main_table); populate_shader_table(shader_table); populate_hw_table(hw_table); populate_sw_table(sw_table); populate_hack_table(hack_table); populate_gl_table(gl_table); populate_debug_table(debug_table); populate_record_table(record_table); populate_osd_table(osd_table); // Handle some nice tab GtkWidget* notebook = gtk_notebook_new(); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), central_box , gtk_label_new("Renderer Settings")); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), advanced_box, gtk_label_new("Advanced Settings")); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), debug_box , gtk_label_new("Debug/Recording")); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), osd_box , gtk_label_new("Post-Processing/OSD")); // Put everything in the big box. gtk_container_add(GTK_CONTAINER(main_box), notebook); // Enable/disable hack frame based on enable option s_hack_frame = hack_table; gtk_widget_set_sensitive(s_hack_frame, theApp.GetConfigB("UserHacks")); // Put the box in the dialog and show it to the world. gtk_container_add (GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), main_box); gtk_widget_show_all (dialog); return_value = gtk_dialog_run (GTK_DIALOG (dialog)); // Compatibility & not supported option int mode_width = theApp.GetConfigI("ModeWidth"); int mode_height = theApp.GetConfigI("ModeHeight"); theApp.SetConfig("ModeHeight", mode_height); theApp.SetConfig("ModeWidth", mode_width); theApp.SetConfig("msaa", 0); theApp.SetConfig("windowed", 1); gtk_widget_destroy (dialog); return (return_value == GTK_RESPONSE_ACCEPT); }
GtkWidget * yank_app_new(EYank *yank) { yank_preferences *prefs; static GtkTargetEntry drop_types[] = { { "text/uri-list", 0, 1 }, }; static gint n_drop_types = sizeof (drop_types)/sizeof (drop_types [0]); gchar *treetitle[] = { _("NoteTree"), NULL }; gchar *todotitles[] = { _("Deadline"), _("Priority"), _("Complete"), _("Title"), NULL }; GtkWidget *app; GtkWidget *scrolledwindow1; GtkWidget *scrolledwindow2; GtkWidget *scrolledwindow3; GtkWidget *hbox; GtkWidget *hbox3; GtkWidget *vbox; GtkWidget *label; GdkFont *font; GtkObject *prio_adjust; /* gint got_crash; */ GtkWidget *b_toggle_ext_flags; GtkWidget *hbox_ext_flags; GtkWidget *hpaned; hpaned = app = yank->priv->hpaned; yank_main_app(app); sp->edit_tree = NULL; sp->title_entry =NULL; sp->todo_check =NULL; sp->prio_entry =NULL; sp->de_deadline =NULL; sp->ad_complete =NULL; sp->tlabel_created =NULL; sp->tlabel_changed =NULL; sp->label_changes =NULL; sp->tlabel_expire =NULL; sp->note_id_entry =NULL; sp->text_entry =NULL; sp->note_tree =NULL; sp->b_ok =NULL; sp->b_apply =NULL; sp->b_cancel =NULL; sp->todolist =NULL; sp->notebook =NULL; sp->status =NULL; sp->prio_date_box =NULL; sp->edit_tree=NULL; yank_root_win(GTK_WINDOW(app)); /* * main tree */ scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); /* gtk_widget_show will be called later */ /* gtk_container_add(GTK_CONTAINER(hpaned), scrolledwindow1); */ e_paned_add1(E_PANED(hpaned), scrolledwindow1); sp->note_tree = gtk_ctree_new_with_titles(1, 0, treetitle); gtk_widget_show(sp->note_tree); gtk_container_add(GTK_CONTAINER(scrolledwindow1), sp->note_tree); gtk_clist_set_column_width(GTK_CLIST(sp->note_tree), 0, 80); gtk_clist_set_column_auto_resize(GTK_CLIST(sp->note_tree), 0, TRUE); gtk_clist_set_row_height(GTK_CLIST(sp->note_tree), 19); gtk_clist_set_selection_mode(GTK_CLIST(sp->note_tree), GTK_SELECTION_EXTENDED); gtk_clist_set_reorderable(GTK_CLIST(sp->note_tree), TRUE); gtk_clist_set_use_drag_icons(GTK_CLIST(sp->note_tree), TRUE); gtk_clist_column_titles_show(GTK_CLIST(sp->note_tree)); gtk_signal_connect(GTK_OBJECT(sp->note_tree), "tree_select_row", GTK_SIGNAL_FUNC (note_tree_row_selected), NULL); gtk_signal_connect(GTK_OBJECT(sp->note_tree), "tree_unselect_row", GTK_SIGNAL_FUNC (note_tree_row_unselected), NULL); gtk_signal_connect(GTK_OBJECT(sp->note_tree), "click_column", GTK_SIGNAL_FUNC (cb_note_tree_col_selected), NULL); gtk_signal_connect(GTK_OBJECT(sp->note_tree), "drag_data_received", GTK_SIGNAL_FUNC(cb_note_tree_reordered), NULL); /* * FIXME: * dnd on the note-tree disables reordering of notes by dnd */ /* gtk_signal_connect(GTK_OBJECT(sp->note_tree), "drag_data_received", */ /* GTK_SIGNAL_FUNC(cb_note_tree_drop), NULL); */ /* gtk_drag_dest_set(sp->note_tree, GTK_DEST_DEFAULT_MOTION | */ /* GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, */ /* drop_types, n_drop_types, GDK_ACTION_COPY); */ sp->notebook = gtk_notebook_new(); gtk_notebook_set_show_tabs(GTK_NOTEBOOK(sp->notebook), FALSE); gtk_notebook_set_show_border(GTK_NOTEBOOK(sp->notebook), FALSE); gtk_widget_show(sp->notebook); /* gtk_container_add(GTK_CONTAINER(hpaned), sp->notebook); */ e_paned_add2(E_PANED(hpaned), sp->notebook); /* * todo-list */ scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show(scrolledwindow2); gtk_container_add(GTK_CONTAINER(sp->notebook), scrolledwindow2); sp->todolist = gtk_clist_new_with_titles(4, todotitles); gtk_signal_connect(GTK_OBJECT(sp->todolist), "select_row", GTK_SIGNAL_FUNC (cb_todo_row_selected), NULL); gtk_signal_connect(GTK_OBJECT(sp->todolist), "click_column", GTK_SIGNAL_FUNC (cb_todo_col_selected), NULL); gtk_signal_connect(GTK_OBJECT(sp->todolist), "drag_data_received", GTK_SIGNAL_FUNC(cb_todo_list_drop), NULL); gtk_drag_dest_set(sp->todolist, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, drop_types, n_drop_types, GDK_ACTION_COPY); gtk_widget_show(sp->todolist); gtk_container_add(GTK_CONTAINER(scrolledwindow2), sp->todolist); gtk_clist_column_titles_show(GTK_CLIST(sp->todolist)); gtk_clist_set_column_auto_resize(GTK_CLIST(sp->todolist), 0 , TRUE); gtk_clist_set_column_auto_resize(GTK_CLIST(sp->todolist), 3 , TRUE); gtk_clist_set_column_justification(GTK_CLIST(sp->todolist), 1, GTK_JUSTIFY_RIGHT); gtk_clist_set_column_justification(GTK_CLIST(sp->todolist), 2, GTK_JUSTIFY_RIGHT); /* * text/ data */ vbox = gtk_vbox_new(FALSE, 3); gtk_widget_show(vbox); gtk_container_add(GTK_CONTAINER (sp->notebook), vbox); hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3); sp->prio_date_box = gtk_vbox_new(FALSE, 3); gtk_widget_show(sp->prio_date_box); gtk_box_pack_start(GTK_BOX(vbox), sp->prio_date_box, FALSE, FALSE, 0); hbox_ext_flags = gui_ext_flags(); gtk_box_pack_start(GTK_BOX(vbox), hbox_ext_flags, FALSE, FALSE, 3); label = gtk_label_new(_("Title:")); font = gtk_widget_get_style(label)->font; gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); sp->title_entry = gtk_entry_new(); gtk_widget_set_usize(sp->title_entry, -1, gdk_string_height(font, "W") + 10); gtk_widget_show(sp->title_entry); gtk_box_pack_start(GTK_BOX(hbox), sp->title_entry, TRUE, TRUE, 5); sp->todo_check = gtk_check_button_new_with_label(_("Done")); gtk_widget_set_usize(sp->todo_check, -1, gdk_string_height(font, "W") + 10); gtk_widget_show(sp->todo_check); gtk_box_pack_start(GTK_BOX(hbox), sp->todo_check, FALSE, FALSE, 5); /* * button for extra flags& data */ b_toggle_ext_flags = gtk_button_new(); { GtkWidget *p_up; GtkWidget *p_down; GtkWidget *box; box = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(b_toggle_ext_flags), box); gtk_widget_show(box); p_up = gnome_stock_pixmap_widget_at_size( GTK_WIDGET(yank_root_win(NULL)), GNOME_STOCK_BUTTON_UP, 12, 14); p_down = gnome_stock_pixmap_widget_at_size( GTK_WIDGET(yank_root_win(NULL)), GNOME_STOCK_BUTTON_DOWN, 12, 14); gtk_widget_hide(p_up); gtk_widget_show(p_down); gtk_container_add(GTK_CONTAINER(box), p_up); gtk_container_add(GTK_CONTAINER(box), p_down); gtk_object_set_data(GTK_OBJECT(b_toggle_ext_flags), "up", p_up); gtk_object_set_data(GTK_OBJECT(b_toggle_ext_flags), "down", p_down); } gtk_widget_show(b_toggle_ext_flags); gtk_box_pack_start(GTK_BOX(hbox), b_toggle_ext_flags, FALSE, FALSE, 5); gtk_signal_connect(GTK_OBJECT(b_toggle_ext_flags), "clicked", GTK_SIGNAL_FUNC(cb_toggle_ext_flags), hbox_ext_flags); /* * deadline/ prio/ complete */ { GtkWidget *prio_hbox1; GtkWidget *prio_hbox2; GtkWidget *sc_complete; prio_hbox1 = gtk_hbox_new(FALSE, 0); gtk_widget_show(prio_hbox1); gtk_box_pack_start(GTK_BOX(sp->prio_date_box), prio_hbox1, FALSE, FALSE, 0); prio_hbox2 = gtk_hbox_new(FALSE, 0); gtk_widget_show(prio_hbox2); gtk_box_pack_start(GTK_BOX(sp->prio_date_box), prio_hbox2, FALSE, FALSE, 0); label = gtk_label_new(_("Deadline:")); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(prio_hbox1), label, FALSE, FALSE, 5); sp->de_deadline = gnome_date_edit_new(0, 1, 1); gnome_date_edit_set_popup_range(GNOME_DATE_EDIT(sp->de_deadline), 0, 23); gtk_widget_set_sensitive(GNOME_DATE_EDIT(sp->de_deadline)->date_entry, FALSE); gtk_widget_set_sensitive(GNOME_DATE_EDIT(sp->de_deadline)->time_entry, FALSE); gtk_widget_show(sp->de_deadline); gtk_box_pack_start(GTK_BOX(prio_hbox1), sp->de_deadline, FALSE, FALSE, 0); label = gtk_label_new(_("Priority:")); gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(prio_hbox1), label, FALSE, FALSE, 5); prio_adjust = gtk_adjustment_new(0, 0, 9999, 1, 10, 10); sp->prio_entry = gtk_spin_button_new(GTK_ADJUSTMENT(prio_adjust), 1, 0); /* NOTE: this is note 100% ok */ gtk_widget_set_usize(GTK_WIDGET(sp->prio_entry), gdk_string_width(font, "999999") + 10, gdk_string_height(font, "W") + 10); gtk_widget_show(sp->prio_entry); gtk_box_pack_start(GTK_BOX(prio_hbox1), sp->prio_entry, FALSE, FALSE, 0); label = gtk_label_new(_("Complete:")); gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(prio_hbox2), label, FALSE, FALSE, 5); sp->ad_complete = gtk_adjustment_new(0, 0, 101, 1, 1, 1); sc_complete = gtk_hscale_new(GTK_ADJUSTMENT(sp->ad_complete)); gtk_scale_set_digits(GTK_SCALE(sc_complete), 0); gtk_scale_set_value_pos(GTK_SCALE(sc_complete), GTK_POS_LEFT); gtk_widget_show(sc_complete); gtk_box_pack_start(GTK_BOX(prio_hbox2), sc_complete, TRUE, TRUE, 5); label = gtk_label_new(_("%")); gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(prio_hbox2), label, FALSE, FALSE, 5); } /* * additional note data */ sp->note_id_entry = gtk_entry_new(); /* gtk_widget_show(sp->note_id_entry); */ gtk_widget_hide(sp->note_id_entry); gtk_box_pack_start(GTK_BOX(hbox), sp->note_id_entry, FALSE, FALSE, 5); /* * note text */ scrolledwindow3 = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow3), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show(scrolledwindow3); gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow3, TRUE, TRUE, 0); sp->text_entry = gtk_text_new(NULL, NULL); gtk_text_set_editable(GTK_TEXT(sp->text_entry), TRUE); gtk_widget_show(sp->text_entry); gtk_container_add(GTK_CONTAINER(scrolledwindow3), sp->text_entry); /* text dnd */ gtk_signal_connect(GTK_OBJECT(sp->text_entry), "drag_data_received", GTK_SIGNAL_FUNC(cb_text_entry_drop), NULL); gtk_drag_dest_set(sp->text_entry, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, drop_types, n_drop_types, GDK_ACTION_COPY); hbox3 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox3); gtk_box_pack_start(GTK_BOX(vbox), hbox3, FALSE, FALSE, 3); sp->b_ok = gnome_stock_button(GNOME_STOCK_BUTTON_OK); gtk_widget_show(sp->b_ok); gtk_box_pack_start(GTK_BOX(hbox3), sp->b_ok, TRUE, FALSE, 5); gtk_signal_connect(GTK_OBJECT(sp->b_ok), "clicked", GTK_SIGNAL_FUNC(cb_b_ok), NULL); sp->b_apply = gnome_stock_button(GNOME_STOCK_BUTTON_APPLY); gtk_widget_show(sp->b_apply); gtk_box_pack_start(GTK_BOX(hbox3), sp->b_apply, TRUE, FALSE, 5); gtk_signal_connect(GTK_OBJECT(sp->b_apply), "clicked", GTK_SIGNAL_FUNC(cb_b_apply), NULL); sp->b_cancel = gnome_stock_button(GNOME_STOCK_BUTTON_CANCEL); gtk_widget_show(sp->b_cancel); gtk_box_pack_start(GTK_BOX(hbox3), sp->b_cancel, TRUE, FALSE, 5); gtk_signal_connect(GTK_OBJECT(sp->b_cancel), "clicked", GTK_SIGNAL_FUNC(cb_b_cancel), NULL); /* * a bit suboptimal */ gtk_signal_connect(GTK_OBJECT(sp->title_entry), "changed", GTK_SIGNAL_FUNC(note_changed), NULL); gtk_signal_connect(GTK_OBJECT(sp->de_deadline), "date-changed", GTK_SIGNAL_FUNC(note_changed), NULL); gtk_signal_connect(GTK_OBJECT(sp->de_deadline), "time-changed", GTK_SIGNAL_FUNC(note_changed), NULL); gtk_signal_connect(GTK_OBJECT(sp->tlabel_expire), "time_changed", GTK_SIGNAL_FUNC(note_changed), NULL); gtk_signal_connect(GTK_OBJECT(sp->prio_entry), "changed", GTK_SIGNAL_FUNC(note_changed), NULL); gtk_signal_connect(GTK_OBJECT(sp->ad_complete), "value_changed", GTK_SIGNAL_FUNC(note_changed), NULL); gtk_signal_connect(GTK_OBJECT(sp->ad_complete), "value_changed", GTK_SIGNAL_FUNC(cb_complete_updates_done), sp->todo_check); gtk_signal_connect(GTK_OBJECT(sp->todo_check), "toggled", GTK_SIGNAL_FUNC(note_changed), NULL); gtk_signal_connect(GTK_OBJECT(sp->text_entry), "changed", GTK_SIGNAL_FUNC(note_changed), NULL); /* * keyboard-control */ gtk_signal_connect(GTK_OBJECT(sp->title_entry), "activate", GTK_SIGNAL_FUNC(cb_finished_note), NULL); gtk_signal_connect(GTK_OBJECT(sp->text_entry), "activate", GTK_SIGNAL_FUNC(cb_finished_note), NULL); /* * create pixmaps */ pix_text_xpm = gnome_pixmap_new_from_xpm_d(text_xpm); gtk_widget_show(pix_text_xpm); pix_box_xpm = gnome_pixmap_new_from_xpm_d(box_xpm); gtk_widget_show(pix_box_xpm); pix_box2_xpm = gnome_pixmap_new_from_xpm_d(box2_xpm); gtk_widget_show(pix_box2_xpm); pix_circle_xpm = gnome_pixmap_new_from_xpm_d(circle_xpm); gtk_widget_show(pix_circle_xpm); pix_circle2_xpm = gnome_pixmap_new_from_xpm_d(circle2_xpm); gtk_widget_show(pix_circle2_xpm); /* * menus */ /* gnome_app_set_contents(GNOME_APP(app), hpaned); */ /* sp->status = gnome_appbar_new(FALSE, TRUE, GNOME_PREFERENCES_USER); */ /* gnome_app_set_statusbar(GNOME_APP(app), sp->status); */ /* yank_install_menus_and_toolbar(app); */ yank_tree_item_context_menu(sp->note_tree); yank_todo_item_context_menu(sp->todolist); yank_text_item_context_menu(sp->title_entry); yank_text_item_context_menu(sp->text_entry); /* gtk_signal_connect(GTK_OBJECT(app), "delete_event", */ /* GTK_SIGNAL_FUNC(cb_delete_event), NULL); */ /* * initialize preferences * also preloads plugins */ load_preferences(); prefs = get_preferences(); gtk_text_set_word_wrap(GTK_TEXT(sp->text_entry), prefs->wordwrap); gtk_text_set_line_wrap(GTK_TEXT(sp->text_entry), prefs->linewrap); /* if (prefs->yank_width * prefs->yank_height) */ /* { */ /* gtk_window_set_default_size(GTK_WINDOW(app), prefs->yank_width, */ /* prefs->yank_height); */ /* } */ /* else */ /* { */ /* gtk_window_set_default_size(GTK_WINDOW(app), 600, 400); */ /* } */ if (prefs->use_custom_font) { if (prefs->note_font) { set_note_font_str(prefs->note_font); } if (prefs->note_tree_font) { set_note_tree_font_str(prefs->note_tree_font); } if (prefs->todolist_font) { set_todolist_font_str(prefs->todolist_font); } } else { set_default_font(); } /* * parse geometry if given */ /* if (geometry != NULL) */ /* { */ /* gint x, y, w, h; */ /* if (gnome_parse_geometry(geometry, &x, &y, &w, &h )) */ /* { */ /* if (x != -1) */ /* { */ /* gtk_widget_set_uposition(app, x, y); */ /* } */ /* */ /* if (w != -1) */ /* { */ /* gtk_window_set_default_size(GTK_WINDOW(app), w, h); */ /* } */ /* } */ /* else */ /* { */ /* g_error(_("Could not parse geometry string `%s'"), geometry); */ /* } */ /* } */ /* */ /* if (prefs->note_tree_width) */ /* { */ /* gtk_widget_set_usize(scrolledwindow1, prefs->note_tree_width, -1); */ /* } */ /* else */ /* { */ /* gtk_widget_set_usize(scrolledwindow1, 200, -1); */ /* } */ /* gtk_widget_show(scrolledwindow1); */ /* * try to read files from killed sessions */ /* got_crash = get_crash_file(); */ /* * load file from the command-line */ /* if (file != NULL && ! got_crash) */ /* { */ /* load_notes_from_cli((gchar *)file, GTK_CTREE(sp->note_tree), NULL); */ /* } */ /* * read default file */ /* if (file == NULL && ! got_crash) */ /* { */ /* get_def_file(); */ /* } */ /* * register some signal-handlers */ /* if (signal(SIGTERM, handle_sigterm) == SIG_ERR) */ /* { */ /* g_warning("Can't handle SIGTERM"); */ /* } */ /* if (signal(SIGCHLD, handle_sigchild) == SIG_ERR) */ /* { */ /* g_warning("Can't handle SIGCHILD"); */ /* } */ /* if (signal(SIGPIPE, handle_sigpipe) == SIG_ERR) */ /* { */ /* g_warning("Can't handle SIGPIPE"); */ /* } */ /* * init autosave */ /* if (prefs->auto_save_minutes) */ /* { */ /* autosave_notes(NULL); */ /* } */ return (hpaned); }
int main(int argc, char **argv){ GtkWidget *pWindow; GtkWidget *pNotebook; GtkWidget *pScrollbar; int fd; //debug nbpaquetenqueue = 0; gtk_init(&argc,&argv); //reservation memoire des donnees des pages dpr = (data_page_rule_p)malloc(sizeof(data_page_rule_t)); dfp = (data_front_page_p)malloc(sizeof(data_front_page_t)); dpsr = (data_page_show_rule_p)malloc(sizeof(data_page_show_rule_p)); dw = (data_window_p)malloc(sizeof(data_window_t)); pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(pWindow), "VSPF"); gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 400); g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL); pScrollbar = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(pWindow),pScrollbar); // Creation du GtkNotebook // Position des onglets : en bas // mise dans la fenetre pNotebook = gtk_notebook_new(); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(pScrollbar), pNotebook); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pScrollbar), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); //on met les donnees de la window dans sa structure dw->pWindow = pWindow; dw->pNotebook = pNotebook; //deplacement ihm_t ihm; ihm_p = &ihm; signal(SIGINT, sigquit); signal(SIGTERM, sigquit); signal(SIGQUIT, sigquit); caract_list_p waiting_caract=caract_list_create(); printf("Etape -3\n"); ihm_p->wai_caract=waiting_caract; printf("Etape -2\n"); ihm_init(&ihm); printf("Initialisation finie\n"); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(pNotebook), GTK_POS_BOTTOM); //gtk_container_add(GTK_CONTAINER(pWindow), pScrollbar); //gtk_container_add(GTK_CONTAINER(pWindow), pNotebook); printf("Apres init\n"); //on cree la page frontale create_front_page(GTK_NOTEBOOK(pNotebook)); //on cree la page des règles et ses donnees ds dpr create_rule_page_base(GTK_NOTEBOOK(pNotebook)); //on cree la page d'affichage des regles create_show_rule_page(GTK_NOTEBOOK(pNotebook)); //Partie provenant de ihm.c printf("Ouverture de %s\n",FIFO_CORE_TO_IHM); ihm_p->core_to_ihm_fd = open(FIFO_CORE_TO_IHM, O_RDONLY| O_NDELAY); assert(ihm_p->core_to_ihm_fd >= 0); printf("Fichier %s ouvert\n",FIFO_CORE_TO_IHM); //fd = open("./fifo_test", O_RDONLY); //printf("Bibi %d\n", fd); printf("Etape 1\n"); gtk_widget_show_all(pWindow); printf("Etape 2\n"); pipe_tag = gdk_input_add( ihm_p->core_to_ihm_fd,GDK_INPUT_READ,input_callback,NULL); printf("Etape 3\n"); gtk_main(); printf("Etape 4\n"); return EXIT_SUCCESS; }
void show_about_window(void) { static GtkWidget *about_window = NULL; static GdkPixmap *xmms_logo_pmap = NULL, *xmms_logo_mask = NULL; GtkWidget *about_vbox, *about_notebook; GtkWidget *about_credits_logo_box, *about_credits_logo_frame; GtkWidget *about_credits_logo; GtkWidget *bbox, *close_btn; GtkWidget *label, *list; gchar *text; if (about_window) return; about_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(about_window), _("About XMMS")); gtk_window_set_policy(GTK_WINDOW(about_window), FALSE, TRUE, FALSE); gtk_container_set_border_width(GTK_CONTAINER(about_window), 10); gtk_signal_connect(GTK_OBJECT(about_window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &about_window); gtk_signal_connect(GTK_OBJECT(about_window), "key_press_event", util_dialog_keypress_cb, NULL); gtk_widget_realize(about_window); about_vbox = gtk_vbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(about_window), about_vbox); if (!xmms_logo_pmap) xmms_logo_pmap = gdk_pixmap_create_from_xpm_d(about_window->window, &xmms_logo_mask, NULL, xmms_logo); about_credits_logo_box = gtk_hbox_new(TRUE, 0); gtk_box_pack_start(GTK_BOX(about_vbox), about_credits_logo_box, FALSE, FALSE, 0); about_credits_logo_frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(about_credits_logo_frame), GTK_SHADOW_OUT); gtk_box_pack_start(GTK_BOX(about_credits_logo_box), about_credits_logo_frame, FALSE, FALSE, 0); about_credits_logo = gtk_pixmap_new(xmms_logo_pmap, xmms_logo_mask); gtk_container_add(GTK_CONTAINER(about_credits_logo_frame), about_credits_logo); text = g_strdup_printf(_("XMMS %s - Cross platform multimedia player"), VERSION); label = gtk_label_new(text); g_free(text); gtk_box_pack_start(GTK_BOX(about_vbox), label, FALSE, FALSE, 0); label = gtk_label_new(_("Copyright (C) 1997-2004 4Front Technologies " "and The XMMS Team")); gtk_box_pack_start(GTK_BOX(about_vbox), label, FALSE, FALSE, 0); about_notebook = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(about_vbox), about_notebook, TRUE, TRUE, 0); list = generate_credit_list(credit_text, TRUE); gtk_notebook_append_page(GTK_NOTEBOOK(about_notebook), list, gtk_label_new(_("Credits"))); list = generate_credit_list(translators, FALSE); gtk_notebook_append_page(GTK_NOTEBOOK(about_notebook), list, gtk_label_new(_("Translators"))); bbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5); gtk_box_pack_start(GTK_BOX(about_vbox), bbox, FALSE, FALSE, 0); close_btn = gtk_button_new_with_label(_("Close")); gtk_signal_connect_object(GTK_OBJECT(close_btn), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(about_window)); GTK_WIDGET_SET_FLAGS(close_btn, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(bbox), close_btn, TRUE, TRUE, 0); gtk_widget_grab_default(close_btn); gtk_widget_show_all(about_window); }
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); }
gu_window_t * gu_win_create(gtk_ui_t *gu, int all, prop_t *nav) { gu_window_t *gw = calloc(1, sizeof(gu_window_t)); LIST_INSERT_HEAD(&gu->gu_windows, gw, gw_link); gw->gw_gu = gu; gw->gw_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_events(gw->gw_window, GDK_FOCUS_CHANGE_MASK); gtk_window_set_title(GTK_WINDOW(gw->gw_window), "Showtime"); gtk_window_set_default_size(GTK_WINDOW(gw->gw_window), 640, 400); g_signal_connect(G_OBJECT(gw->gw_window), "delete_event", G_CALLBACK(gw_close), gw); g_signal_connect(G_OBJECT(gw->gw_window), "focus-in-event", G_CALLBACK(gw_focused), gw); gw->gw_vbox = gtk_vbox_new(FALSE, 1); gtk_container_add(GTK_CONTAINER(gw->gw_window), gw->gw_vbox); gtk_widget_show(gw->gw_vbox); gw->gw_view_toolbar = 1; if(all) { gw->gw_view_playdeck = 1; gw->gw_view_statusbar = 1; } /* Menubar */ gw->gw_menubar = gu_menubar_add(gw, gw->gw_vbox); gtk_widget_show_all(gw->gw_menubar); /* Notebook (that which contains tabs) */ gw->gw_notebook = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(gw->gw_vbox), gw->gw_notebook, TRUE, TRUE, 0); gtk_notebook_set_show_border(GTK_NOTEBOOK(gw->gw_notebook), 0); gtk_notebook_set_show_tabs(GTK_NOTEBOOK(gw->gw_notebook), 0); gtk_notebook_set_scrollable(GTK_NOTEBOOK(gw->gw_notebook), 1); gtk_widget_show(gw->gw_notebook); g_signal_connect(G_OBJECT(gw->gw_notebook), "switch-page", G_CALLBACK(tab_changed), gw); /* Playback controls */ gw->gw_playdeck = gu_playdeck_add(gw, gw->gw_vbox); if(gw->gw_view_playdeck) gtk_widget_show(gw->gw_playdeck); /* Statusbar */ gw->gw_statusbar = gu_statusbar_add(gw, gw->gw_vbox); if(gw->gw_view_statusbar) gtk_widget_show(gw->gw_statusbar); g_signal_connect(G_OBJECT(gw->gw_window), "key-press-event", G_CALLBACK(window_key_pressed), gw); g_signal_connect(G_OBJECT(gw->gw_window), "window-state-event", G_CALLBACK(window_state_event), gw); gu_tab_create(gw, 1, nav); gtk_widget_show(gw->gw_window); return gw; }
int main (int argc, char **argv) { GtkWidget *window; GtkWidget *collection; GError *err; clock_t start, end; GtkWidget *notebook; int i; bindtextdomain (GETTEXT_PACKAGE, MARCO_LOCALEDIR); textdomain(GETTEXT_PACKAGE); bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); run_position_expression_tests (); #if 0 run_position_expression_timings (); #endif gtk_init (&argc, &argv); if (g_getenv ("MARCO_DEBUG") != NULL) { meta_set_debugging (TRUE); meta_set_verbose (TRUE); } start = clock (); err = NULL; if (argc == 1) global_theme = meta_theme_load ("ClearlooksRe", &err); else if (argc == 2) global_theme = meta_theme_load (argv[1], &err); else { g_printerr (_("Usage: marco-theme-viewer [THEMENAME]\n")); exit (1); } end = clock (); if (global_theme == NULL) { g_printerr (_("Error loading theme: %s\n"), err->message); g_error_free (err); exit (1); } g_print (_("Loaded theme \"%s\" in %g seconds\n"), global_theme->name, (end - start) / (double) CLOCKS_PER_SEC); run_theme_benchmark (); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (window), 350, 350); if (strcmp (global_theme->name, global_theme->readable_name)==0) gtk_window_set_title (GTK_WINDOW (window), global_theme->readable_name); else { /* The theme directory name is different from the name the theme * gives itself within its file. Display both, directory name first. */ gchar *title = g_strconcat (global_theme->name, " - ", global_theme->readable_name, NULL); gtk_window_set_title (GTK_WINDOW (window), title); g_free (title); } g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_widget_realize (window); g_assert (window->style); g_assert (window->style->font_desc); notebook = gtk_notebook_new (); gtk_container_add (GTK_CONTAINER (window), notebook); collection = preview_collection (FONT_SIZE_NORMAL, window->style->font_desc); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), collection, gtk_label_new (_("Normal Title Font"))); collection = preview_collection (FONT_SIZE_SMALL, window->style->font_desc); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), collection, gtk_label_new (_("Small Title Font"))); collection = preview_collection (FONT_SIZE_LARGE, window->style->font_desc); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), collection, gtk_label_new (_("Large Title Font"))); collection = previews_of_button_layouts (); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), collection, gtk_label_new (_("Button Layouts"))); collection = benchmark_summary (); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), collection, gtk_label_new (_("Benchmark"))); i = 0; while (i < (int) G_N_ELEMENTS (previews)) { /* preview widget likes to be realized before its size request. * it's lame that way. */ gtk_widget_realize (previews[i]); ++i; } gtk_widget_show_all (window); gtk_main (); return 0; }
/** * Create integrated user interface */ void create_integrated_ui (void) { GtkWidget *window; GtkWidget *main_vbox; GtkWidget *hbox; GtkWidget *wrapbox; GtkWidget *menubar; GtkWidget *toolbar; GtkWidget *notebook; GtkWidget *statusbar; GtkAccelGroup *accel_group; GtkWidget *layer_view; #ifdef HAVE_GNOME window = gnome_app_new ("Dia", _("Diagram Editor")); #else window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_object_ref (window); gtk_window_set_title (GTK_WINDOW (window), "Dia v" VERSION); #endif /* hint to window manager on X so the wm can put the window in the same as it was when the application shut down */ gtk_window_set_role (GTK_WINDOW (window), DIA_MAIN_WINDOW); gtk_window_set_default_size (GTK_WINDOW (window), 146, 349); app_set_icon (GTK_WINDOW (window)); g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (toolbox_delete), window); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (toolbox_destroy), window); main_vbox = gtk_vbox_new (FALSE, 1); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 1); #ifdef HAVE_GNOME gnome_app_set_contents (GNOME_APP(window), main_vbox); #else gtk_container_add (GTK_CONTAINER (window), main_vbox); #endif gtk_widget_show (main_vbox); /* Applicatioon Statusbar */ statusbar = gtk_statusbar_new (); gtk_box_pack_end (GTK_BOX (main_vbox), statusbar, FALSE, TRUE, 0); /* HBox for everything below the menubar and toolbars */ hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_end (GTK_BOX (main_vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); /* Layer View */ layer_view = create_layer_view_widget (); gtk_box_pack_end (GTK_BOX (hbox), layer_view, FALSE, FALSE, 0); /* Diagram Notebook */ notebook = gtk_notebook_new (); gtk_box_pack_end (GTK_BOX (hbox), notebook, TRUE, TRUE, 0); gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); gtk_widget_show (notebook); /* Toolbox widget */ wrapbox = toolbox_create(); gtk_box_pack_start (GTK_BOX (hbox), wrapbox, FALSE, TRUE, 0); g_signal_connect (G_OBJECT (wrapbox), "drag_data_received", G_CALLBACK (dia_dnd_file_drag_data_received), NULL); /* userdata == NULL here intentionally */ /* setup the notebook to receive drops as well */ toolbox_setup_drag_dest (notebook); g_signal_connect (G_OBJECT (notebook), "drag_data_received", G_CALLBACK (dia_dnd_file_drag_data_received), NULL); /* userdata == NULL here intentionally */ /* menus -- initialised afterwards, because initing the display menus * uses the tool buttons*/ menus_get_integrated_ui_menubar(&menubar, &toolbar, &accel_group); gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); gtk_widget_show (menubar); #ifdef HAVE_GNOME gnome_app_set_menus (GNOME_APP (window), GTK_MENU_BAR (menubar)); #else # ifdef HAVE_MAC_INTEGRATION _create_mac_integration (menubar); # else gtk_box_pack_start (GTK_BOX (main_vbox), menubar, FALSE, TRUE, 0); # endif #endif /* Toolbar */ /* TODO: maybe delete set_style(toolbar,ICONS) */ gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS); gtk_box_pack_start (GTK_BOX (main_vbox), toolbar, FALSE, TRUE, 0); gtk_widget_show (toolbar); persistence_register_window(GTK_WINDOW(window)); ui.main_window = GTK_WINDOW (window); ui.toolbar = GTK_TOOLBAR (toolbar); ui.diagram_notebook = GTK_NOTEBOOK (notebook); ui.statusbar = GTK_STATUSBAR (statusbar); ui.layer_view = layer_view; /* NOTE: These functions use ui.xxx assignments above and so must come after * the user interface components are set. */ integrated_ui_toolbar_show (TRUE); integrated_ui_statusbar_show (TRUE); /* For access outside here: */ g_object_set_data (G_OBJECT (ui.main_window), DIA_MAIN_NOTEBOOK, notebook); /* TODO: Figure out what to do about toolbox_shell for integrated UI */ toolbox_shell = window; }
int main( int argc, char **argv ) { gtk_init( &argc, &argv ); GtkWidget *window = gtk_window_new( GTK_WINDOW_TOPLEVEL ); gtk_window_set_title( GTK_WINDOW( window ), "Using Multiple Containers" ); gtk_container_set_border_width( GTK_CONTAINER( window ), 10 ); gtk_widget_set_size_request( window, 640, 480 ); GtkWidget *notebook = gtk_notebook_new(); GtkWidget *one = gtk_label_new( "One" ); GtkWidget *two = gtk_label_new( "Two" ); GtkWidget *three = gtk_label_new( "Three" ); GtkWidget *four = gtk_label_new( "Four" ); GtkWidget *tag1 = gtk_label_new( "This is page one" ); GtkWidget *tag2 = gtk_label_new( "This is page TWO" ); GtkWidget *tag3 = gtk_label_new( "This is page THree" ); GtkWidget *tag4 = gtk_label_new( "This is page FouR" ); GtkWidget *next = gtk_button_new_with_label( "Next" ); GtkWidget *prev = gtk_button_new_with_label( "Prev" ); GtkWidget *exit = gtk_button_new_with_label( "Exit" ); GtkWidget *vpane = gtk_vpaned_new(); GtkWidget *hbox = gtk_hbox_new( TRUE, 10 ); GtkWidget *nvbox1 = gtk_vbox_new( TRUE, 5 ); GtkWidget *nvbox2 = gtk_vbox_new( TRUE, 5 ); GtkWidget *nvbox3 = gtk_vbox_new( TRUE, 5 ); GtkWidget *nvbox4 = gtk_vbox_new( TRUE, 5 ); GtkWidget *expander = gtk_expander_new_with_mnemonic( "click here to show _Next button" ); gtk_container_add( GTK_CONTAINER( expander ), next ); gtk_expander_set_expanded( GTK_EXPANDER( expander ), TRUE ); g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook ); gtk_box_pack_start( GTK_BOX( nvbox1 ), tag1, FALSE, FALSE, 5 ); gtk_box_pack_start( GTK_BOX( nvbox1 ), expander, FALSE, FALSE, 5 ); expander = gtk_expander_new_with_mnemonic( "click here to show _Next button" ); gtk_expander_set_expanded( GTK_EXPANDER( expander ), TRUE ); next = gtk_button_new_with_label( "Next" ); g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook ); gtk_container_add( GTK_CONTAINER( expander ), next ); gtk_box_pack_start( GTK_BOX( nvbox2 ), tag2, FALSE, FALSE, 5 ); gtk_box_pack_start( GTK_BOX( nvbox2 ), expander, FALSE, FALSE, 5 ); expander = gtk_expander_new_with_mnemonic( "click here to show _Next button" ); gtk_expander_set_expanded( GTK_EXPANDER( expander ), TRUE ); next = gtk_button_new_with_label( "Next" ); g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook ); gtk_container_add( GTK_CONTAINER( expander ), next ); gtk_box_pack_start( GTK_BOX( nvbox3 ), tag3, FALSE, FALSE, 5 ); gtk_box_pack_start( GTK_BOX( nvbox3 ), expander, FALSE, FALSE, 5 ); expander = gtk_expander_new_with_mnemonic( "click here to show _Next button" ); gtk_expander_set_expanded( GTK_EXPANDER( expander ), TRUE ); next = gtk_button_new_with_label( "Next" ); g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook ); gtk_container_add( GTK_CONTAINER( expander ), next ); gtk_box_pack_start( GTK_BOX( nvbox4 ), tag4, FALSE, FALSE, 5 ); gtk_box_pack_start( GTK_BOX( nvbox4 ), expander, FALSE, FALSE, 5 ); gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), nvbox1, one ); gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), nvbox2, two ); gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), nvbox3, three ); gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), nvbox4, four ); gtk_notebook_set_tab_pos( GTK_NOTEBOOK( notebook ), GTK_POS_TOP ); gtk_notebook_set_show_tabs( GTK_NOTEBOOK( notebook ), TRUE ); g_signal_connect( G_OBJECT( prev ), "clicked", G_CALLBACK( prev_pressed ), (gpointer) notebook ); g_signal_connect( G_OBJECT( exit ), "clicked", G_CALLBACK( exit_pressed ), NULL ); gtk_box_pack_end( GTK_BOX( hbox ), exit, TRUE, FALSE, 5 ); gtk_box_pack_end( GTK_BOX( hbox ), prev, TRUE, FALSE, 5 ); gtk_paned_pack1( GTK_PANED( vpane ), notebook, TRUE, FALSE ); gtk_paned_pack2( GTK_PANED( vpane ), hbox, TRUE, FALSE ); g_signal_connect( G_OBJECT( window ), "destroy", G_CALLBACK( destroy ), NULL ); gtk_container_add( GTK_CONTAINER( window ), vpane ); gtk_widget_show_all( window ); gtk_main(); return 0; }
static GtkWidget *create_window(void) { GtkWidget *startwin; GtkWidget *hlayout; GtkWidget *banner; GtkWidget *vlayout; GtkWidget *tabs; GtkWidget *configvlayout; GtkWidget *configlayout; GtkWidget *vmode3dlabel; GtkWidget *vmode3dcombo; GtkWidget *fullscreencheck; GtkWidget *alwaysshowcheck; GtkWidget *configtab; GtkWidget *messagesscroll; GtkWidget *messagestext; GtkWidget *messagestab; GtkWidget *buttons; GtkWidget *cancelbutton; GtkWidget *cancelbuttonalign; GtkWidget *cancelbuttonlayout; GtkWidget *cancelbuttonicon; GtkWidget *cancelbuttonlabel; GtkWidget *startbutton; GtkWidget *startbuttonalign; GtkWidget *startbuttonlayout; GtkWidget *startbuttonicon; GtkWidget *startbuttonlabel; GtkAccelGroup *accel_group; accel_group = gtk_accel_group_new (); // Basic window startwin = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (startwin), apptitle); // NOTE: use global app title gtk_window_set_position (GTK_WINDOW (startwin), GTK_WIN_POS_CENTER); gtk_window_set_resizable (GTK_WINDOW (startwin), FALSE); gtk_window_set_type_hint (GTK_WINDOW (startwin), GDK_WINDOW_TYPE_HINT_DIALOG); // Horizontal layout of banner and controls hlayout = gtk_hbox_new (FALSE, 0); gtk_widget_show (hlayout); gtk_container_add (GTK_CONTAINER (startwin), hlayout); // Banner { GdkPixbuf *pixbuf = load_banner(); banner = gtk_image_new_from_pixbuf(pixbuf); g_object_unref((gpointer)pixbuf); } gtk_widget_show (banner); gtk_box_pack_start (GTK_BOX (hlayout), banner, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (banner), 0.5, 0); // Vertical layout of tab control and start+cancel buttons vlayout = gtk_vbox_new (FALSE, 0); gtk_widget_show (vlayout); gtk_box_pack_start (GTK_BOX (hlayout), vlayout, TRUE, TRUE, 0); // Tab control tabs = gtk_notebook_new (); gtk_widget_show (tabs); gtk_box_pack_start (GTK_BOX (vlayout), tabs, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (tabs), 4); // Vertical layout of config page main body configvlayout = gtk_vbox_new (FALSE, 0); gtk_widget_show (configvlayout); gtk_container_add (GTK_CONTAINER (tabs), configvlayout); // Fixed-position layout of config page controls configlayout = gtk_fixed_new (); gtk_widget_show (configlayout); gtk_box_pack_start (GTK_BOX (configvlayout), configlayout, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (configlayout), 6); // 3D video mode label vmode3dlabel = gtk_label_new_with_mnemonic ("_Video mode:"); gtk_widget_show (vmode3dlabel); gtk_fixed_put (GTK_FIXED (configlayout), vmode3dlabel, 0, 0); gtk_widget_set_size_request (vmode3dlabel, 88, 29); gtk_misc_set_alignment (GTK_MISC (vmode3dlabel), 0, 0.5); // 3D video mode combo { GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); GtkCellRenderer *cell; vmode3dcombo = gtk_combo_box_new_with_model (GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(vmode3dcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(vmode3dcombo), cell, "text", 0, NULL); } gtk_widget_show (vmode3dcombo); gtk_fixed_put (GTK_FIXED (configlayout), vmode3dcombo, 88, 0); gtk_widget_set_size_request (vmode3dcombo, 150, 29); gtk_widget_add_accelerator (vmode3dcombo, "grab_focus", accel_group, GDK_V, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // Fullscreen checkbox fullscreencheck = gtk_check_button_new_with_mnemonic ("_Fullscreen"); gtk_widget_show (fullscreencheck); gtk_fixed_put (GTK_FIXED (configlayout), fullscreencheck, 248, 0); gtk_widget_set_size_request (fullscreencheck, 85, 29); gtk_widget_add_accelerator (fullscreencheck, "grab_focus", accel_group, GDK_F, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // Always show config checkbox alwaysshowcheck = gtk_check_button_new_with_mnemonic ("_Always show configuration on start"); gtk_widget_show (alwaysshowcheck); gtk_box_pack_start (GTK_BOX (configvlayout), alwaysshowcheck, FALSE, FALSE, 0); gtk_widget_add_accelerator (alwaysshowcheck, "grab_focus", accel_group, GDK_A, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // Configuration tab configtab = gtk_label_new ("Configuration"); gtk_widget_show (configtab); gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 0), configtab); // Messages scrollable area messagesscroll = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (messagesscroll); gtk_container_add (GTK_CONTAINER (tabs), messagesscroll); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); // Messages text area messagestext = gtk_text_view_new (); gtk_widget_show (messagestext); gtk_container_add (GTK_CONTAINER (messagesscroll), messagestext); gtk_text_view_set_editable (GTK_TEXT_VIEW (messagestext), FALSE); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (messagestext), GTK_WRAP_WORD); gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (messagestext), FALSE); gtk_text_view_set_left_margin (GTK_TEXT_VIEW (messagestext), 2); gtk_text_view_set_right_margin (GTK_TEXT_VIEW (messagestext), 2); // Messages tab messagestab = gtk_label_new ("Messages"); gtk_widget_show (messagestab); gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 1), messagestab); // Dialogue box buttons layout buttons = gtk_hbutton_box_new (); gtk_widget_show (buttons); gtk_box_pack_start (GTK_BOX (vlayout), buttons, FALSE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (buttons), 3); gtk_button_box_set_layout (GTK_BUTTON_BOX (buttons), GTK_BUTTONBOX_END); // Cancel button cancelbutton = gtk_button_new (); gtk_widget_show (cancelbutton); gtk_container_add (GTK_CONTAINER (buttons), cancelbutton); GTK_WIDGET_SET_FLAGS (cancelbutton, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (cancelbutton, "grab_focus", accel_group, GDK_C, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (cancelbutton, "clicked", accel_group, GDK_Escape, 0, GTK_ACCEL_VISIBLE); cancelbuttonalign = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (cancelbuttonalign); gtk_container_add (GTK_CONTAINER (cancelbutton), cancelbuttonalign); cancelbuttonlayout = gtk_hbox_new (FALSE, 2); gtk_widget_show (cancelbuttonlayout); gtk_container_add (GTK_CONTAINER (cancelbuttonalign), cancelbuttonlayout); cancelbuttonicon = gtk_image_new_from_stock ("gtk-cancel", GTK_ICON_SIZE_BUTTON); gtk_widget_show (cancelbuttonicon); gtk_box_pack_start (GTK_BOX (cancelbuttonlayout), cancelbuttonicon, FALSE, FALSE, 0); cancelbuttonlabel = gtk_label_new_with_mnemonic ("_Cancel"); gtk_widget_show (cancelbuttonlabel); gtk_box_pack_start (GTK_BOX (cancelbuttonlayout), cancelbuttonlabel, FALSE, FALSE, 0); // Start button startbutton = gtk_button_new (); gtk_widget_show (startbutton); gtk_container_add (GTK_CONTAINER (buttons), startbutton); GTK_WIDGET_SET_FLAGS (startbutton, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (startbutton, "grab_focus", accel_group, GDK_S, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (startbutton, "clicked", accel_group, GDK_Return, 0, GTK_ACCEL_VISIBLE); startbuttonalign = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (startbuttonalign); gtk_container_add (GTK_CONTAINER (startbutton), startbuttonalign); startbuttonlayout = gtk_hbox_new (FALSE, 2); gtk_widget_show (startbuttonlayout); gtk_container_add (GTK_CONTAINER (startbuttonalign), startbuttonlayout); startbuttonicon = gtk_image_new_from_stock ("gtk-execute", GTK_ICON_SIZE_BUTTON); gtk_widget_show (startbuttonicon); gtk_box_pack_start (GTK_BOX (startbuttonlayout), startbuttonicon, FALSE, FALSE, 0); startbuttonlabel = gtk_label_new_with_mnemonic ("_Start"); gtk_widget_show (startbuttonlabel); gtk_box_pack_start (GTK_BOX (startbuttonlayout), startbuttonlabel, FALSE, FALSE, 0); // Wire up the signals g_signal_connect ((gpointer) startwin, "delete_event", G_CALLBACK (on_startwin_delete_event), NULL); g_signal_connect ((gpointer) vmode3dcombo, "changed", G_CALLBACK (on_vmode3dcombo_changed), NULL); g_signal_connect ((gpointer) fullscreencheck, "toggled", G_CALLBACK (on_fullscreencheck_toggled), NULL); g_signal_connect ((gpointer) alwaysshowcheck, "toggled", G_CALLBACK (on_alwaysshowcheck_toggled), NULL); g_signal_connect ((gpointer) cancelbutton, "clicked", G_CALLBACK (on_cancelbutton_clicked), NULL); g_signal_connect ((gpointer) startbutton, "clicked", G_CALLBACK (on_startbutton_clicked), NULL); // Associate labels with their controls gtk_label_set_mnemonic_widget (GTK_LABEL (vmode3dlabel), vmode3dcombo); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (startwin, startwin, "startwin"); GLADE_HOOKUP_OBJECT (startwin, hlayout, "hlayout"); GLADE_HOOKUP_OBJECT (startwin, banner, "banner"); GLADE_HOOKUP_OBJECT (startwin, vlayout, "vlayout"); GLADE_HOOKUP_OBJECT (startwin, tabs, "tabs"); GLADE_HOOKUP_OBJECT (startwin, configvlayout, "configvlayout"); GLADE_HOOKUP_OBJECT (startwin, configlayout, "configlayout"); GLADE_HOOKUP_OBJECT (startwin, vmode3dlabel, "vmode3dlabel"); GLADE_HOOKUP_OBJECT (startwin, vmode3dcombo, "vmode3dcombo"); GLADE_HOOKUP_OBJECT (startwin, fullscreencheck, "fullscreencheck"); GLADE_HOOKUP_OBJECT (startwin, alwaysshowcheck, "alwaysshowcheck"); GLADE_HOOKUP_OBJECT (startwin, configtab, "configtab"); GLADE_HOOKUP_OBJECT (startwin, messagesscroll, "messagesscroll"); GLADE_HOOKUP_OBJECT (startwin, messagestext, "messagestext"); GLADE_HOOKUP_OBJECT (startwin, messagestab, "messagestab"); GLADE_HOOKUP_OBJECT (startwin, buttons, "buttons"); GLADE_HOOKUP_OBJECT (startwin, cancelbutton, "cancelbutton"); GLADE_HOOKUP_OBJECT (startwin, cancelbuttonalign, "cancelbuttonalign"); GLADE_HOOKUP_OBJECT (startwin, cancelbuttonlayout, "cancelbuttonlayout"); GLADE_HOOKUP_OBJECT (startwin, cancelbuttonicon, "cancelbuttonicon"); GLADE_HOOKUP_OBJECT (startwin, cancelbuttonlabel, "cancelbuttonlabel"); GLADE_HOOKUP_OBJECT (startwin, startbutton, "startbutton"); GLADE_HOOKUP_OBJECT (startwin, startbuttonalign, "startbuttonalign"); GLADE_HOOKUP_OBJECT (startwin, startbuttonlayout, "startbuttonlayout"); GLADE_HOOKUP_OBJECT (startwin, startbuttonicon, "startbuttonicon"); GLADE_HOOKUP_OBJECT (startwin, startbuttonlabel, "startbuttonlabel"); gtk_window_add_accel_group (GTK_WINDOW (startwin), accel_group); return startwin; }
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); }
/* returns TRUE if OK was pressed. */ static gboolean georef_layer_dialog ( VikGeorefLayer *vgl, gpointer vp, GtkWindow *w, gboolean have_apply_button ) { GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Layer Properties"), w, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL ); if ( have_apply_button ) gtk_dialog_add_button ( GTK_DIALOG(dialog), GTK_STOCK_APPLY, GTK_RESPONSE_APPLY ); gtk_dialog_add_button ( GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT ); /* Default to reject as user really needs to specify map file first */ gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_REJECT ); GtkWidget *response_w = NULL; #if GTK_CHECK_VERSION (2, 20, 0) response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_REJECT ); #endif GtkWidget *table, *wfp_hbox, *wfp_label, *wfp_button, *ce_label, *cn_label, *xlabel, *ylabel, *imagelabel; changeable_widgets cw; GtkBox *dgbox = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))); table = gtk_table_new ( 4, 2, FALSE ); gtk_box_pack_start ( dgbox, table, TRUE, TRUE, 0 ); wfp_hbox = gtk_hbox_new ( FALSE, 0 ); wfp_label = gtk_label_new ( _("World File Parameters:") ); wfp_button = gtk_button_new_with_label ( _("Load From File...") ); gtk_box_pack_start ( GTK_BOX(wfp_hbox), wfp_label, TRUE, TRUE, 0 ); gtk_box_pack_start ( GTK_BOX(wfp_hbox), wfp_button, FALSE, FALSE, 3 ); ce_label = gtk_label_new ( _("Corner pixel easting:") ); cw.ce_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, -15000000.0, 1500000.0, 1, 5, 0 ), 1, 4 ); gtk_widget_set_tooltip_text ( GTK_WIDGET(cw.ce_spin), _("the UTM \"easting\" value of the upper-left corner pixel of the map") ); cn_label = gtk_label_new ( _("Corner pixel northing:") ); cw.cn_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, -15000000.0, 15000000.0, 1, 5, 0 ), 1, 4 ); gtk_widget_set_tooltip_text ( GTK_WIDGET(cw.cn_spin), _("the UTM \"northing\" value of the upper-left corner pixel of the map") ); xlabel = gtk_label_new ( _("X (easting) scale (mpp): ")); ylabel = gtk_label_new ( _("Y (northing) scale (mpp): ")); cw.x_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, VIK_VIEWPORT_MIN_ZOOM, VIK_VIEWPORT_MAX_ZOOM, 1, 5, 0 ), 1, 8 ); gtk_widget_set_tooltip_text ( GTK_WIDGET(cw.x_spin), _("the scale of the map in the X direction (meters per pixel)") ); cw.y_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, VIK_VIEWPORT_MIN_ZOOM, VIK_VIEWPORT_MAX_ZOOM, 1, 5, 0 ), 1, 8 ); gtk_widget_set_tooltip_text ( GTK_WIDGET(cw.y_spin), _("the scale of the map in the Y direction (meters per pixel)") ); imagelabel = gtk_label_new ( _("Map Image:") ); cw.imageentry = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_OPEN, VF_FILTER_IMAGE, maybe_read_world_file, &cw); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.ce_spin), vgl->corner.easting ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.cn_spin), vgl->corner.northing ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.x_spin), vgl->mpp_easting ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.y_spin), vgl->mpp_northing ); if ( vgl->image ) vik_file_entry_set_filename ( VIK_FILE_ENTRY(cw.imageentry), vgl->image ); gtk_table_attach_defaults ( GTK_TABLE(table), imagelabel, 0, 1, 0, 1 ); gtk_table_attach_defaults ( GTK_TABLE(table), cw.imageentry, 1, 2, 0, 1 ); gtk_table_attach_defaults ( GTK_TABLE(table), wfp_hbox, 0, 2, 1, 2 ); gtk_table_attach_defaults ( GTK_TABLE(table), xlabel, 0, 1, 2, 3 ); gtk_table_attach_defaults ( GTK_TABLE(table), cw.x_spin, 1, 2, 2, 3 ); gtk_table_attach_defaults ( GTK_TABLE(table), ylabel, 0, 1, 3, 4 ); gtk_table_attach_defaults ( GTK_TABLE(table), cw.y_spin, 1, 2, 3, 4 ); cw.tabs = gtk_notebook_new(); GtkWidget *table_utm = gtk_table_new ( 3, 2, FALSE ); gtk_table_attach_defaults ( GTK_TABLE(table_utm), ce_label, 0, 1, 0, 1 ); gtk_table_attach_defaults ( GTK_TABLE(table_utm), cw.ce_spin, 1, 2, 0, 1 ); gtk_table_attach_defaults ( GTK_TABLE(table_utm), cn_label, 0, 1, 1, 2 ); gtk_table_attach_defaults ( GTK_TABLE(table_utm), cw.cn_spin, 1, 2, 1, 2 ); GtkWidget *utm_hbox = gtk_hbox_new ( FALSE, 0 ); cw.utm_zone_spin = gtk_spin_button_new ((GtkAdjustment*)gtk_adjustment_new( vgl->corner.zone, 1, 60, 1, 5, 0 ), 1, 0 ); gtk_box_pack_start ( GTK_BOX(utm_hbox), gtk_label_new(_("Zone:")), TRUE, TRUE, 0 ); gtk_box_pack_start ( GTK_BOX(utm_hbox), cw.utm_zone_spin, TRUE, TRUE, 0 ); gtk_box_pack_start ( GTK_BOX(utm_hbox), gtk_label_new(_("Letter:")), TRUE, TRUE, 0 ); cw.utm_letter_entry = gtk_entry_new (); gtk_entry_set_max_length ( GTK_ENTRY(cw.utm_letter_entry), 1 ); gtk_entry_set_width_chars ( GTK_ENTRY(cw.utm_letter_entry), 2 ); gchar tmp_letter[2]; tmp_letter[0] = vgl->corner.letter; tmp_letter[1] = '\0'; gtk_entry_set_text ( GTK_ENTRY(cw.utm_letter_entry), tmp_letter ); gtk_box_pack_start ( GTK_BOX(utm_hbox), cw.utm_letter_entry, TRUE, TRUE, 0 ); gtk_table_attach_defaults ( GTK_TABLE(table_utm), utm_hbox, 0, 2, 2, 3 ); // Lat/Lon GtkWidget *table_ll = gtk_table_new ( 5, 2, FALSE ); GtkWidget *lat_tl_label = gtk_label_new ( _("Upper left latitude:") ); cw.lat_tl_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new (0.0,-90,90.0,0.05,0.1,0), 0.1, 6 ); GtkWidget *lon_tl_label = gtk_label_new ( _("Upper left longitude:") ); cw.lon_tl_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new (0.0,-180,180.0,0.05,0.1,0), 0.1, 6 ); GtkWidget *lat_br_label = gtk_label_new ( _("Lower right latitude:") ); cw.lat_br_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new (0.0,-90,90.0,0.05,0.1,0), 0.1, 6 ); GtkWidget *lon_br_label = gtk_label_new ( _("Lower right longitude:") ); cw.lon_br_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new (0.0,-180.0,180.0,0.05,0.1,0), 0.1, 6 ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), lat_tl_label, 0, 1, 0, 1 ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), cw.lat_tl_spin, 1, 2, 0, 1 ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), lon_tl_label, 0, 1, 1, 2 ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), cw.lon_tl_spin, 1, 2, 1, 2 ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), lat_br_label, 0, 1, 2, 3 ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), cw.lat_br_spin, 1, 2, 2, 3 ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), lon_br_label, 0, 1, 3, 4 ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), cw.lon_br_spin, 1, 2, 3, 4 ); GtkWidget *calc_mpp_button = gtk_button_new_with_label ( _("Calculate MPP values from coordinates") ); gtk_widget_set_tooltip_text ( calc_mpp_button, _("Enter all corner coordinates before calculating the MPP values from the image size") ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), calc_mpp_button, 0, 2, 4, 5 ); VikCoord vc; vik_coord_load_from_utm (&vc, VIK_COORD_LATLON, &(vgl->corner)); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.lat_tl_spin), vc.north_south ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.lon_tl_spin), vc.east_west ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.lat_br_spin), vgl->ll_br.lat ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.lon_br_spin), vgl->ll_br.lon ); gtk_notebook_append_page(GTK_NOTEBOOK(cw.tabs), GTK_WIDGET(table_utm), gtk_label_new(_("UTM"))); gtk_notebook_append_page(GTK_NOTEBOOK(cw.tabs), GTK_WIDGET(table_ll), gtk_label_new(_("Latitude/Longitude"))); gtk_box_pack_start ( dgbox, cw.tabs, TRUE, TRUE, 0 ); GtkWidget *alpha_hbox = gtk_hbox_new ( FALSE, 0 ); // GTK3 => GtkWidget *alpha_scale = gtk_scale_new_with_range ( GTK_ORIENTATION_HORIZONTAL, 0, 255, 1 ); GtkWidget *alpha_scale = gtk_hscale_new_with_range ( 0, 255, 1 ); gtk_scale_set_digits ( GTK_SCALE(alpha_scale), 0 ); gtk_range_set_value ( GTK_RANGE(alpha_scale), vgl->alpha ); gtk_box_pack_start ( GTK_BOX(alpha_hbox), gtk_label_new(_("Alpha:")), TRUE, TRUE, 0 ); gtk_box_pack_start ( GTK_BOX(alpha_hbox), alpha_scale, TRUE, TRUE, 0 ); gtk_box_pack_start ( dgbox, alpha_hbox, TRUE, TRUE, 0 ); vgl->cw = cw; g_signal_connect ( G_OBJECT(vgl->cw.tabs), "switch-page", G_CALLBACK(switch_tab), vgl ); g_signal_connect ( G_OBJECT(calc_mpp_button), "clicked", G_CALLBACK(calculate_mpp_from_coords), vgl ); g_signal_connect_swapped ( G_OBJECT(wfp_button), "clicked", G_CALLBACK(georef_layer_dialog_load), &cw ); if ( response_w ) gtk_widget_grab_focus ( response_w ); gtk_widget_show_all ( dialog ); // Remember setting the notebook page must be done after the widget is visible. gint page_num = 0; if ( a_settings_get_integer ( VIK_SETTINGS_GEOREF_TAB, &page_num ) ) if ( page_num < 0 || page_num > 1 ) page_num = 0; gtk_notebook_set_current_page ( GTK_NOTEBOOK(cw.tabs), page_num ); gboolean answer = FALSE; gint resp = GTK_RESPONSE_APPLY; while ( resp == GTK_RESPONSE_APPLY ) { resp = gtk_dialog_run ( GTK_DIALOG(dialog) ); if ( resp == GTK_RESPONSE_ACCEPT || resp == GTK_RESPONSE_APPLY ) { align_coords ( vgl ); vgl->corner.easting = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(cw.ce_spin) ); vgl->corner.northing = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(cw.cn_spin) ); vgl->corner.zone = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(cw.utm_zone_spin) ); const gchar *letter = gtk_entry_get_text ( GTK_ENTRY(cw.utm_letter_entry) ); if (*letter) vgl->corner.letter = toupper(*letter); vgl->mpp_easting = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(cw.x_spin) ); vgl->mpp_northing = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(cw.y_spin) ); vgl->ll_br = get_ll_br (vgl); check_br_is_good_or_msg_user ( vgl ); // TODO check if image has changed otherwise no need to regenerate pixbuf if ( !vgl->pixbuf ) { if ( g_strcmp0 (vgl->image, vik_file_entry_get_filename(VIK_FILE_ENTRY(cw.imageentry)) ) != 0 ) { georef_layer_set_image ( vgl, vik_file_entry_get_filename(VIK_FILE_ENTRY(cw.imageentry)) ); georef_layer_load_image ( vgl, VIK_VIEWPORT(vp), FALSE ); } } vgl->alpha = (guint8) gtk_range_get_value ( GTK_RANGE(alpha_scale) ); if ( vgl->pixbuf && vgl->alpha <= 255 ) vgl->pixbuf = ui_pixbuf_set_alpha ( vgl->pixbuf, vgl->alpha ); if ( vgl->scaled && vgl->alpha <= 255 ) vgl->scaled = ui_pixbuf_set_alpha ( vgl->scaled, vgl->alpha ); a_settings_set_integer ( VIK_SETTINGS_GEOREF_TAB, gtk_notebook_get_current_page(GTK_NOTEBOOK(cw.tabs)) ); if ( resp == GTK_RESPONSE_APPLY ) { vik_layer_emit_update ( VIK_LAYER(vgl) ); answer = FALSE; } else answer = TRUE; } } gtk_widget_destroy ( GTK_WIDGET(dialog) ); return answer; }