/* Sets whether the tabs must have all the same size or not. */
int
clip_GTK_NOTEBOOKSETHOMOGENEOUSTABS(ClipMachine * cm)
{
C_widget *cntb = _fetch_cw_arg(cm);
guint homogeneous = _clip_parl(cm,2);
CHECKCWID(cntb,GTK_IS_NOTEBOOK);
CHECKOPT(2,LOGICAL_t);
if (_clip_parinfo(cm,2)==UNDEF_t) homogeneous = TRUE;
gtk_notebook_set_homogeneous_tabs(GTK_NOTEBOOK(cntb->widget), homogeneous);
return 0;
err:
return 1;
}
void interface (gint argc, gchar *argv[])
{
GtkWidget *MenuBar;
GtkWidget *VBox;
GtkWidget *HandleBox;
gtk_set_locale();
gtk_init (&argc, &argv);
Settings = init_settings ();
MainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW(MainWindow), g_strconcat
(WELCOME_MSG, " ", APP_NAME, " ",
VERSION_NUMBER, NULL));
gtk_window_set_policy (GTK_WINDOW(MainWindow), TRUE, TRUE, FALSE);
gtk_widget_set_usize (MainWindow, MAIN_WINDOW_WIDTH, MAIN_WINDOW_HEIGHT);
gtk_signal_connect (GTK_OBJECT(MainWindow), "delete_event",
(GtkSignalFunc) quit, NULL);
gtk_signal_connect (GTK_OBJECT(MainWindow), "destroy",
(GtkSignalFunc) quit, NULL);
FileProperties = g_array_new (TRUE, FALSE, sizeof(t_fprops));
VBox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER(MainWindow), VBox);
HandleBox = gtk_handle_box_new();
gtk_container_set_border_width (GTK_CONTAINER(HandleBox), 2);
gtk_box_pack_start (GTK_BOX(VBox), HandleBox, FALSE, FALSE, 0);
init_toolbar (GTK_BOX(VBox));
MainNotebook = gtk_notebook_new ();
read_uedit_wordfile (WORDFILE);
editor_init();
MenuBar = menubar_new (MainWindow);
gtk_container_add (GTK_CONTAINER(HandleBox), MenuBar);
gtk_notebook_popup_enable (GTK_NOTEBOOK(MainNotebook));
gtk_notebook_set_homogeneous_tabs (GTK_NOTEBOOK(MainNotebook), TRUE);
gtk_notebook_set_scrollable (GTK_NOTEBOOK(MainNotebook), TRUE);
gtk_box_pack_start (GTK_BOX(VBox), MainNotebook, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT(MainNotebook), "switch_page",
(GtkSignalFunc) set_title, NULL);
init_msgbar (GTK_BOX(VBox));
print_msg ("You're the welcome...");
command_line (argc, argv);
autosave (AUTOSAVE_DELAY);
gtk_widget_show_all (MainWindow);
if (!MSGBAR_DISPLAY) hide_msgbar ();
if (!TOOLBAR_DISPLAY) hide_toolbar ();
gtk_timeout_add (80, (GtkFunction)display_line_column, NULL);
gtk_main ();
set_preferences_to_disk (&Settings, NULL);
gtk_item_factory_dump_rc (g_strconcat (g_get_home_dir (), PATH_SEP_STRING,
CONF_DIR, PATH_SEP_STRING,
"AccelRC", NULL), NULL, FALSE);
}
static gboolean dialog_select_source(int chan_num)
{
scope_vert_t *vert;
scope_chan_t *chan;
dialog_generic_t dialog;
gchar *title, msg[BUFLEN];
int next, n, initial_page, row, initial_row, max_row;
gchar *tab_label_text[3], *name;
GtkWidget *hbox, *label, *notebk, *button;
GtkAdjustment *adj;
hal_pin_t *pin;
hal_sig_t *sig;
hal_param_t *param;
vert = &(ctrl_usr->vert);
chan = &(ctrl_usr->chan[chan_num - 1]);
title = _("Select Channel Source");
snprintf(msg, BUFLEN - 1, _("Select a pin, signal, or parameter\n"
"as the source for channel %d."), chan_num);
/* create dialog window, disable resizing */
dialog.retval = 0;
dialog.window = gtk_dialog_new();
dialog.app_data = &chan_num;
/* set initial height of window */
gtk_widget_set_usize(GTK_WIDGET(dialog.window), -2, 300);
/* allow user to grow but not shrink the window */
gtk_window_set_policy(GTK_WINDOW(dialog.window), FALSE, TRUE, FALSE);
/* window should appear in center of screen */
gtk_window_set_position(GTK_WINDOW(dialog.window), GTK_WIN_POS_CENTER);
/* set title */
gtk_window_set_title(GTK_WINDOW(dialog.window), title);
/* display message */
label = gtk_label_new(msg);
gtk_misc_set_padding(GTK_MISC(label), 15, 5);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog.window)->vbox), label, FALSE,
TRUE, 0);
/* a separator */
gtk_hseparator_new_in_box(GTK_DIALOG(dialog.window)->vbox, 0);
/* create a notebook to hold pin, signal, and parameter lists */
notebk = gtk_notebook_new();
/* add the notebook to the dialog */
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog.window)->vbox), notebk, TRUE,
TRUE, 0);
/* set overall notebook parameters */
gtk_notebook_set_homogeneous_tabs(GTK_NOTEBOOK(notebk), TRUE);
gtk_signal_connect(GTK_OBJECT(notebk), "switch-page", GTK_SIGNAL_FUNC(change_page), &dialog);
/* text for tab labels */
tab_label_text[0] = _("Pins");
tab_label_text[1] = _("Signals");
tab_label_text[2] = _("Parameters");
/* loop to create three identical tabs */
for (n = 0; n < 3; n++) {
/* Create a scrolled window to display the list */
vert->windows[n] = gtk_scrolled_window_new(NULL, NULL);
vert->adjs[n] = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(vert->windows[n]));
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(vert->windows[n]),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_widget_show(vert->windows[n]);
/* create a list to hold the data */
vert->lists[n] = gtk_clist_new(1);
/* set up a callback for when the user selects a line */
gtk_signal_connect(GTK_OBJECT(vert->lists[n]), "select_row",
GTK_SIGNAL_FUNC(selection_made), &dialog);
gtk_signal_connect(GTK_OBJECT(vert->lists[n]), "key-press-event",
GTK_SIGNAL_FUNC(search_for_entry), &dialog);
/* It isn't necessary to shadow the border, but it looks nice :) */
gtk_clist_set_shadow_type(GTK_CLIST(vert->lists[n]), GTK_SHADOW_OUT);
/* set list for single selection only */
gtk_clist_set_selection_mode(GTK_CLIST(vert->lists[n]),
GTK_SELECTION_BROWSE);
/* put the list into the scrolled window */
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW
(vert->windows[n]), vert->lists[n]);
/* another way to do it - not sure which is better
gtk_container_add(GTK_CONTAINER(vert->windows[n]), vert->lists[n]); */
gtk_widget_show(vert->lists[n]);
/* create a box for the tab label */
hbox = gtk_hbox_new(TRUE, 0);
/* create a label for the page */
gtk_label_new_in_box(tab_label_text[n], hbox, TRUE, TRUE, 0);
gtk_widget_show(hbox);
/* add page to the notebook */
gtk_notebook_append_page(GTK_NOTEBOOK(notebk), vert->windows[n], hbox);
/* set tab attributes */
gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebk), hbox,
TRUE, TRUE, GTK_PACK_START);
}
/* determine initial page: pin, signal, or parameter */
if (( chan->data_source_type >= 0 ) && ( chan->data_source_type <= 2 )) {
initial_page = chan->data_source_type;
gtk_notebook_set_page(GTK_NOTEBOOK(notebk), initial_page);
} else {
initial_page = -1;
gtk_notebook_set_page(GTK_NOTEBOOK(notebk), 0);
}
gtk_widget_show(notebk);
/* populate the pin, signal, and parameter lists */
gtk_clist_clear(GTK_CLIST(vert->lists[0]));
gtk_clist_clear(GTK_CLIST(vert->lists[1]));
gtk_clist_clear(GTK_CLIST(vert->lists[2]));
rtapi_mutex_get(&(hal_data->mutex));
next = hal_data->pin_list_ptr;
initial_row = -1;
max_row = -1;
while (next != 0) {
pin = SHMPTR(next);
name = pin->name;
row = gtk_clist_append(GTK_CLIST(vert->lists[0]), &name);
if ( initial_page == 0 ) {
if ( strcmp(name, chan->name) == 0 ) {
initial_row = row;
}
max_row = row;
}
next = pin->next_ptr;
}
next = hal_data->sig_list_ptr;
while (next != 0) {
sig = SHMPTR(next);
name = sig->name;
row = gtk_clist_append(GTK_CLIST(vert->lists[1]), &name);
if ( initial_page == 1 ) {
if ( strcmp(name, chan->name) == 0 ) {
initial_row = row;
}
max_row = row;
}
next = sig->next_ptr;
}
next = hal_data->param_list_ptr;
while (next != 0) {
param = SHMPTR(next);
name = param->name;
row = gtk_clist_append(GTK_CLIST(vert->lists[2]), &name);
if ( initial_page == 2 ) {
if ( strcmp(name, chan->name) == 0 ) {
initial_row = row;
}
max_row = row;
}
next = param->next_ptr;
}
rtapi_mutex_give(&(hal_data->mutex));
if ( initial_row >= 0 ) {
/* highlight the currently selected name */
gtk_clist_select_row(GTK_CLIST(vert->lists[initial_page]), initial_row, -1);
/* set scrolling window to show the highlighted name */
/* FIXME - I can't seem to get this to work */
adj = vert->adjs[initial_page];
adj->value = adj->lower + (adj->upper - adj->lower)*((double)(initial_row)/(double)(max_row+1));
gtk_adjustment_value_changed(vert->adjs[initial_page]);
}
/* set up a callback function when the window is destroyed */
gtk_signal_connect(GTK_OBJECT(dialog.window), "destroy",
GTK_SIGNAL_FUNC(dialog_generic_destroyed), &dialog);
/* make Cancel button */
button = gtk_button_new_with_label(_("Cancel"));
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog.window)->action_area),
button, TRUE, TRUE, 4);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(dialog_generic_button2), &dialog);
/* make window transient and modal */
gtk_window_set_transient_for(GTK_WINDOW(dialog.window),
GTK_WINDOW(ctrl_usr->main_win));
gtk_window_set_modal(GTK_WINDOW(dialog.window), TRUE);
gtk_widget_show_all(dialog.window);
gtk_main();
/* we get here when the user makes a selection, hits Cancel, or closes
the window */
vert->lists[0] = NULL;
vert->lists[1] = NULL;
vert->lists[2] = NULL;
if ((dialog.retval == 0) || (dialog.retval == 2)) {
/* user either closed dialog, or hit cancel */
return FALSE;
}
/* user made a selection */
channel_changed();
return TRUE;
}
int main(int argc, char **argv) {
char buf[1024], *usage =
"usage: deepstripper-gtk [-d[ebug]] [-h[elp]] [-o[utput] <path>]\n"
" [-dps12|-dps16 <path>] [-e[xtract] <project>]\n";
GtkWidget *vbox, *men, *paned, *note, *frame, *scroll;
GtkItemFactory *fac;
GtkAccelGroup *acc;
int i, dps = -1;
for (i=1; i<argc; i++) {
if (strcmp(argv[i], "-d")==0) {
g_dbg = g_dbg<<1 | 1;
} else if (strncmp(argv[i], "-h", 2)==0) {
g_print("%s", usage);
return 0;
}
}
gtk_init(&argc, &argv);
g_main = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(g_main), 600, 400);
set_title("?", GETCWD(buf, sizeof(buf)), "");
g_signal_connect(G_OBJECT(g_main), "delete_event", G_CALLBACK(quit), NULL);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(g_main), vbox);
gtk_widget_show(vbox);
acc = gtk_accel_group_new();
fac = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<deepstripper-main>", acc);
gtk_item_factory_create_items(fac, MENU_SIZE, root_menu, 0);
men = gtk_item_factory_get_widget(fac, "<deepstripper-main>");
gtk_box_pack_start(GTK_BOX(vbox), men, FALSE, FALSE, 0);
gtk_window_add_accel_group(GTK_WINDOW(g_main), acc);
gtk_widget_show(men);
g_multi = gtk_item_factory_get_item(fac, "/Multi");
paned = gtk_hpaned_new();
gtk_container_set_border_width(GTK_CONTAINER(paned), 5);
gtk_box_pack_start(GTK_BOX(vbox), paned, TRUE, TRUE, 0);
gtk_widget_show(paned);
note = gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(note), GTK_POS_BOTTOM);
gtk_notebook_set_show_border(GTK_NOTEBOOK(note), TRUE);
gtk_notebook_set_homogeneous_tabs(GTK_NOTEBOOK(note), TRUE);
gtk_widget_set_size_request(note, 150, 200);
gtk_paned_pack1(GTK_PANED(paned), note, TRUE, FALSE);
gtk_widget_show(note);
for (i=0; i<N_TABS; i++) {
GtkWidget *l = gtk_label_new(g_tabs[i].tab);
gtk_widget_show(l);
gtk_notebook_append_page(GTK_NOTEBOOK(note),
make_list(g_tabs[i].data, i), l);
}
frame = gtk_frame_new("Item properties:");
gtk_widget_set_size_request(frame, 150, 200);
gtk_paned_pack2(GTK_PANED(paned), frame, TRUE, FALSE);
gtk_widget_show(frame);
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(frame), scroll);
gtk_widget_show(scroll);
g_info = gtk_label_new(DEFAULT_INFO);
gtk_label_set_justify(GTK_LABEL(g_info), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap(GTK_LABEL(g_info), FALSE);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), g_info);
gtk_widget_show(g_info);
g_stat = gtk_statusbar_new();
gtk_box_pack_end(GTK_BOX(vbox), g_stat, FALSE, FALSE, 0);
gtk_widget_show(g_stat);
set_status("status");
// Display everything
gtk_widget_show(g_main);
// Process all other command line switches
for (i=1; i<argc; i++) {
if (strncmp(argv[i], "-o", 2)==0) {
if (chdir(argv[++i]))
about_box("unable to change directory");
else
set_title(NULL, GETCWD(buf, sizeof(buf)), NULL);
} else if (strncmp(argv[i], "-dps", 4)==0) {
open_backup(argv[i], argv[i+1]);
if (strcmp(argv[i], "-dps12")==0)
dps = AOSP_DPS12;
else
dps = AOSP_DPS16;
++i;
} else if (strncmp(argv[i], "-e", 2)==0) {
if (dps<0)
about_box("No backup specified to extract from");
else {
open_project(dps, akaiosdisk_project_byname(&g_disk, argv[++i]));
select_tracks(MID_SELNOE);
extract_tracks();
}
} else if (strncmp(argv[i], "-d", 2)==0 ||
strncmp(argv[i], "-h", 2)==0) {
; // Skip earlier opts
} else {
about_box(usage);
}
}
// Run message pump..
gtk_main();
return 0;
}
void build_mainwindow(void)
{
guint ic;
uri_regex_count = G_N_ELEMENTS(uri_patterns);
uri_regex = g_new0(GRegex*, uri_regex_count);
for(ic = 0; ic < uri_regex_count; ++ic)
{
GError *error = NULL;
uri_regex[ic] = g_regex_new(uri_patterns[ic].pattern,
uri_patterns[ic].flags | G_REGEX_OPTIMIZE, 0, &error);
if(error)
{
g_message("%s", error->message);
g_error_free (error);
}
}
mainwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_app_paintable(mainwindow, TRUE);
gtk_widget_set_size_request(mainwindow, conf_get_width(), conf_get_height());
gtk_window_set_decorated(GTK_WINDOW(mainwindow), FALSE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(mainwindow), TRUE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(mainwindow), TRUE);
gtk_window_set_resizable(GTK_WINDOW(mainwindow), TRUE);
mainwindow_reset_position();
fullscreen = FALSE;
toggled = FALSE;
GtkAccelGroup* accel_group;
GClosure *new_tab, *delete_tab, *next_tab, *prev_tab, *delete_all,
*maximize, *copy, *paste;
GClosure *goto_tab_closure[10];
long i;
accel_group = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(mainwindow), accel_group);
maximize = g_cclosure_new_swap(G_CALLBACK(mainwindow_toggle_fullscreen),
NULL, NULL);
gtk_accel_group_connect(accel_group, GDK_F11, 0,
GTK_ACCEL_VISIBLE, maximize);
new_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_new_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, 't', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, new_tab);
delete_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_delete_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'w', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, delete_tab);
next_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_next_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, GDK_Page_Up, conf_get_key_mod(),
GTK_ACCEL_VISIBLE, next_tab);
prev_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_prev_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, GDK_Page_Down, conf_get_key_mod(),
GTK_ACCEL_VISIBLE, prev_tab);
delete_all = g_cclosure_new_swap(G_CALLBACK(mainwindow_destroy),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'q', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, delete_all);
/* tab hotkeys, inspired by Tilda -- thanks to castorinop for the patch */
for(i = 0; i < 10; i++)
{
goto_tab_closure[i] = g_cclosure_new_swap(G_CALLBACK(mainwindow_goto_tab),
(gpointer) i, NULL);
gtk_accel_group_connect(accel_group, '0' + ((i+1)%10), GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE, goto_tab_closure[i]);
}
copy = g_cclosure_new_swap(G_CALLBACK(mainwindow_copy),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'c', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, copy);
paste = g_cclosure_new_swap(G_CALLBACK(mainwindow_paste),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'v', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, paste);
activetab = -1;
tabcount = 0;
GtkVBox* mainbox = GTK_VBOX(gtk_vbox_new(FALSE, 0));
tabbar = GTK_NOTEBOOK(gtk_notebook_new());
g_signal_connect(G_OBJECT(tabbar), "switch-page",
G_CALLBACK(mainwindow_switch_tab), NULL);
if(conf_get_opacity() < 100)
{
GdkScreen *screen = gdk_screen_get_default();
GdkColormap *colormap = gdk_screen_get_rgba_colormap(screen);
screen_is_composited = (colormap != NULL
&& gdk_screen_is_composited(screen));
if(screen_is_composited)
{
gtk_widget_set_colormap(GTK_WIDGET(mainwindow), colormap);
gdk_screen_set_default_colormap(screen, colormap);
}
}
gtk_box_pack_start(GTK_BOX(mainbox), GTK_WIDGET(tabbar), TRUE, TRUE, 0);
mainwindow_create_tab();
gtk_widget_show_all(GTK_WIDGET(mainbox));
gtk_container_add(GTK_CONTAINER(mainwindow), GTK_WIDGET(mainbox));
int border = conf_get_border();
if(border == BORDER_THIN)
gtk_container_set_border_width(GTK_CONTAINER(mainwindow), 1);
else if(border == BORDER_THICK)
gtk_container_set_border_width(GTK_CONTAINER(mainwindow), 5);
if(border != BORDER_NONE)
g_signal_connect(G_OBJECT(mainwindow), "expose-event",
G_CALLBACK(mainwindow_expose_event), NULL);
if(conf_get_auto_hide())
g_signal_connect(G_OBJECT(mainwindow), "focus-out-event",
G_CALLBACK(mainwindow_focus_out_event), NULL);
g_signal_connect(G_OBJECT(mainwindow), "show", G_CALLBACK(mainwindow_show),
NULL);
g_signal_connect(G_OBJECT(mainwindow), "destroy",
G_CALLBACK(mainwindow_destroy), NULL);
g_signal_connect_after(G_OBJECT(tabbar), "button_press_event",
G_CALLBACK(mainwindow_notebook_clicked), NULL);
gtk_notebook_set_show_border(tabbar, FALSE);
gtk_notebook_set_scrollable(tabbar, TRUE);
if (conf_get_show_tab() == TABS_ONE|| conf_get_show_tab() == TABS_NEVER)
gtk_notebook_set_show_tabs(tabbar, FALSE);
gtk_notebook_set_tab_pos(tabbar, conf_get_tab_pos());
gtk_notebook_set_homogeneous_tabs(tabbar, FALSE);
XSetErrorHandler(handle_x_error);
init_key();
grab_key();
g_thread_new("stjerm", (GThreadFunc)wait_key, NULL);
// If stjerm has been started for the first time with --toggle, then
// show the window straight away. Make haste!
if(conf_get_toggled()) {
mainwindow_toggle(1);
}
}
