/**
* 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;
}
