static void execute_widget_init(ExecuteWidget *ew)
{
ew->nes = NULL;
ew->execute_callback = NULL;
ew->step_callback = NULL;
ew->debug_disable_callback = NULL;
ew->running = FALSE;
ew->thread = NULL;
gtk_table_resize(GTK_TABLE(ew), EXECUTE_WIDGET_ROWS, EXECUTE_WIDGET_COLS);
gtk_table_set_homogeneous(GTK_TABLE(ew), TRUE);
ew->step_button = gtk_button_new_with_label("Step");
g_signal_connect(ew->step_button, "clicked", G_CALLBACK(on_step_button_clicked), ew);
gtk_table_attach_defaults(GTK_TABLE(ew), ew->step_button, 0, 1, 0, 1);
ew->execute_button = gtk_button_new_with_label("Execute");
g_signal_connect(ew->execute_button, "clicked", G_CALLBACK(on_execute_button_clicked), ew);
gtk_table_attach_defaults(GTK_TABLE(ew), ew->execute_button, 1, 2, 0, 1);
ew->start_button = gtk_button_new_with_label("Start");
g_signal_connect(ew->start_button, "clicked", G_CALLBACK(on_start_button_clicked), ew);
gtk_table_attach_defaults(GTK_TABLE(ew), ew->start_button, 2, 3, 0, 1);
ew->stop_button = gtk_button_new_with_label("Stop");
g_signal_connect(ew->stop_button, "clicked", G_CALLBACK(on_stop_button_clicked), ew);
gtk_widget_set_sensitive(GTK_WIDGET(ew->stop_button), FALSE);
gtk_table_attach_defaults(GTK_TABLE(ew), ew->stop_button, 3, 4, 0, 1);
}
/* Build the composite widget */
static void game_buildings_init(GameBuildings * gb)
{
GtkWidget *label;
GtkWidget *spin;
GtkObject *adjustment;
gint row;
gtk_table_resize(GTK_TABLE(gb), NUM_BUILD_TYPES - 1, 2);
gtk_table_set_row_spacings(GTK_TABLE(gb), 3);
gtk_table_set_col_spacings(GTK_TABLE(gb), 5);
gtk_table_set_homogeneous(GTK_TABLE(gb), TRUE);
for (row = 1; row < NUM_BUILD_TYPES; row++) {
label = gtk_label_new(gettext(building_names[row]));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach_defaults(GTK_TABLE(gb), label,
0, 1, row - 1, row);
adjustment = gtk_adjustment_new(0, 0, 100, 1, 5, 0);
spin =
gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0);
gtk_entry_set_alignment(GTK_ENTRY(spin), 1.0);
gtk_table_attach_defaults(GTK_TABLE(gb), spin,
1, 2, row - 1, row);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin), TRUE);
gb->num_buildings[row] = GTK_SPIN_BUTTON(spin);
}
}
static void
ekiga_dialpad_init (EkigaDialpad *dialpad)
{
unsigned i;
dialpad->priv = G_TYPE_INSTANCE_GET_PRIVATE (dialpad,
EKIGA_TYPE_DIALPAD,
EkigaDialpadPrivate);
gtk_table_set_col_spacings (GTK_TABLE (dialpad), 2);
gtk_table_set_row_spacings (GTK_TABLE (dialpad), 2);
gtk_table_set_homogeneous (GTK_TABLE (dialpad), TRUE);
/* Create the buttons */
for (i = 0; i < G_N_ELEMENTS (keys_info); i++) {
GtkWidget *box;
GtkWidget *label;
GtkWidget *button;
gchar *text;
GtkWidget *alignment;
box = gtk_hbox_new (FALSE, 2);
label = gtk_label_new (keys_info[i].number);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 1.0);
if (strlen (keys_info [i].letters) > 0) {
text = g_strdup_printf ("<sub><span size=\"small\">%s</span></sub>",
_(keys_info [i].letters));
gtk_label_set_markup (GTK_LABEL (label), text);
g_free (text);
}
gtk_box_pack_start (GTK_BOX (box), label, FALSE, TRUE, 0);
alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_container_add (GTK_CONTAINER (alignment), box);
button = gtk_button_new ();
gtk_container_set_border_width (GTK_CONTAINER (button), 0);
gtk_container_add (GTK_CONTAINER (button), alignment);
dialpad->priv->buttons[i] = button;
gtk_table_attach (GTK_TABLE (dialpad), button,
i % 3, i % 3 + 1,
i / 3, i / 3 + 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
0, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (on_dialpad_button_clicked), dialpad);
}
}
/* changes the homogenous property of table cells.
* Ie. whether all cells are an equal size or not. */
int
clip_GTK_TABLESETHOMOGENEOUS(ClipMachine *cm)
{
C_widget *ctbl = _fetch_cw_arg(cm);
gboolean homogeneous = BOOL_OPTION(cm,2,FALSE);
CHECKCWID(ctbl,GTK_IS_TABLE);
CHECKOPT(2,LOGICAL_t);
gtk_table_set_homogeneous(GTK_TABLE(ctbl->widget), homogeneous);
return 0;
err:
return 1;
}
extern GtkWidget *create_resv_entry(resv_desc_msg_t *resv_msg,
GtkTreeModel *model, GtkTreeIter *iter)
{
GtkScrolledWindow *window = create_scrolled_window();
GtkBin *bin = NULL;
GtkViewport *view = NULL;
GtkTable *table = NULL;
int i = 0, row = 0;
display_data_t *display_data = create_data_resv;
gtk_scrolled_window_set_policy(window,
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
bin = GTK_BIN(&window->container);
view = GTK_VIEWPORT(bin->child);
bin = GTK_BIN(&view->bin);
table = GTK_TABLE(bin->child);
gtk_table_resize(table, SORTID_CNT, 2);
gtk_table_set_homogeneous(table, FALSE);
for (i = 0; i < SORTID_CNT; i++) {
while (display_data++) {
if (display_data->id == -1)
break;
if (!display_data->name)
continue;
if (display_data->id != i)
continue;
display_admin_edit(
table, resv_msg, &row, model, iter,
display_data,
G_CALLBACK(_admin_edit_combo_box_resv),
G_CALLBACK(_admin_focus_out_resv),
_set_active_combo_resv);
break;
}
display_data = create_data_resv;
}
gtk_table_resize(table, row, 2);
return GTK_WIDGET(window);
}
static void
tictactoe_init (Tictactoe *ttt)
{
gint i,j;
gtk_table_resize (GTK_TABLE (ttt), 3, 3);
gtk_table_set_homogeneous (GTK_TABLE (ttt), TRUE);
for (i=0;i<3; i++)
for (j=0;j<3; j++) {
ttt->buttons[i][j] = gtk_toggle_button_new ();
gtk_table_attach_defaults (GTK_TABLE (ttt), ttt->buttons[i][j],
i, i+1, j, j+1);
g_signal_connect (ttt->buttons[i][j], "toggled",
G_CALLBACK (tictactoe_toggle), (gpointer) ttt);
gtk_widget_set_size_request (ttt->buttons[i][j], 20, 20);
gtk_widget_show (ttt->buttons[i][j]);
}
}
static void stack_widget_init(StackWidget *sw)
{
sw->ram_read_callback = NULL;
sw->read_sp_callback = NULL;
sw->cpu = NULL;
GtkWidget *entry = NULL;
gint i;
GtkAttachOptions attach_options;
gtk_table_set_homogeneous(GTK_TABLE(sw), FALSE);
g_signal_connect(sw, "scroll-event", G_CALLBACK(table_scroll_handler), sw);
attach_options = GTK_SHRINK;
/* Labels to the left */
for(i = 0; i < STACK_WIDGET_ROWS; i++)
{
char *str;
str = g_strdup_printf("0x%04X", 0x100 + i);
sw->left_locations[i] = gtk_label_new(str);
gtk_widget_modify_font(GTK_WIDGET(sw->left_locations[i]), pango_font_description_from_string("monospace"));
g_free(str);
gtk_table_attach(GTK_TABLE(sw), sw->left_locations[i], 0, 1, i, i + 1, attach_options, attach_options, 3, 0);
gtk_widget_show(sw->left_locations[i]);
}
/* The memory entries */
for(i = 0; i < STACK_WIDGET_ROWS; i++)
{
entry = gtk_entry_new();
sw->entries[i] = entry;
gtk_widget_modify_font(GTK_WIDGET(entry), pango_font_description_from_string("monospace"));
gtk_entry_set_max_length(GTK_ENTRY(entry), 2);
gtk_entry_set_width_chars(GTK_ENTRY(entry), 2);
gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
gtk_table_attach(GTK_TABLE(sw), entry, 1, 2, i, i + 1, attach_options, attach_options, 3, 0);
gtk_widget_show(entry);
}
stack_widget_update(sw);
}
static void
remmina_plugin_rdpset_table_init (RemminaPluginRdpsetTable *table)
{
GtkWidget *widget;
GtkCellRenderer *renderer;
gchar *s;
/* Create the table */
g_signal_connect (G_OBJECT (table), "destroy", G_CALLBACK (remmina_plugin_rdpset_table_destroy), NULL);
gtk_table_resize (GTK_TABLE (table), 8, 3);
gtk_table_set_homogeneous (GTK_TABLE (table), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 8);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
/* Create the content */
widget = gtk_label_new (_("Keyboard layout"));
gtk_widget_show (widget);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), widget, 0, 1, 0, 1);
table->keyboard_layout_store = gtk_list_store_new (2, G_TYPE_UINT, G_TYPE_STRING);
widget = gtk_combo_box_new_with_model (GTK_TREE_MODEL (table->keyboard_layout_store));
gtk_widget_show (widget);
gtk_table_attach_defaults (GTK_TABLE (table), widget, 1, 4, 0, 1);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (widget), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (widget), renderer, "text", 1);
table->keyboard_layout_combo = widget;
widget = gtk_label_new ("-");
gtk_widget_show (widget);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), widget, 1, 4, 1, 2);
table->keyboard_layout_label = widget;
remmina_plugin_rdpset_table_load_layout (table);
widget = gtk_check_button_new_with_label (_("Use client keyboard mapping"));
gtk_widget_show (widget);
gtk_table_attach_defaults (GTK_TABLE (table), widget, 1, 3, 2, 3);
table->use_client_keymap_check = widget;
s = remmina_plugin_service->pref_get_value ("rdp_use_client_keymap");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
s && s[0] == '1' ? TRUE : FALSE);
g_free (s);
widget = gtk_label_new (_("Quality option"));
gtk_widget_show (widget);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), widget, 0, 1, 3, 4);
table->quality_store = gtk_list_store_new (2, G_TYPE_UINT, G_TYPE_STRING);
widget = gtk_combo_box_new_with_model (GTK_TREE_MODEL (table->quality_store));
gtk_widget_show (widget);
gtk_table_attach_defaults (GTK_TABLE (table), widget, 1, 4, 3, 4);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (widget), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (widget), renderer, "text", 1);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (remmina_plugin_rdpset_quality_on_changed), table);
table->quality_combo = widget;
remmina_plugin_rdpset_table_load_quality (table);
widget = gtk_check_button_new_with_label (_("Wallpaper"));
gtk_widget_show (widget);
gtk_table_attach_defaults (GTK_TABLE (table), widget, 1, 2, 4, 5);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (remmina_plugin_rdpset_quality_option_on_toggled), table);
table->wallpaper_check = widget;
widget = gtk_check_button_new_with_label (_("Window drag"));
gtk_widget_show (widget);
gtk_table_attach_defaults (GTK_TABLE (table), widget, 2, 3, 4, 5);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (remmina_plugin_rdpset_quality_option_on_toggled), table);
table->windowdrag_check = widget;
widget = gtk_check_button_new_with_label (_("Menu animation"));
gtk_widget_show (widget);
gtk_table_attach_defaults (GTK_TABLE (table), widget, 1, 2, 5, 6);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (remmina_plugin_rdpset_quality_option_on_toggled), table);
table->menuanimation_check = widget;
widget = gtk_check_button_new_with_label (_("Theme"));
gtk_widget_show (widget);
gtk_table_attach_defaults (GTK_TABLE (table), widget, 2, 3, 5, 6);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (remmina_plugin_rdpset_quality_option_on_toggled), table);
table->theme_check = widget;
widget = gtk_check_button_new_with_label (_("Cursor shadow"));
gtk_widget_show (widget);
gtk_table_attach_defaults (GTK_TABLE (table), widget, 1, 2, 6, 7);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (remmina_plugin_rdpset_quality_option_on_toggled), table);
table->cursorshadow_check = widget;
widget = gtk_check_button_new_with_label (_("Cursor blinking"));
gtk_widget_show (widget);
gtk_table_attach_defaults (GTK_TABLE (table), widget, 2, 3, 6, 7);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (remmina_plugin_rdpset_quality_option_on_toggled), table);
table->cursorblinking_check = widget;
widget = gtk_check_button_new_with_label (_("Font smoothing"));
gtk_widget_show (widget);
gtk_table_attach_defaults (GTK_TABLE (table), widget, 1, 2, 7, 8);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (remmina_plugin_rdpset_quality_option_on_toggled), table);
table->fontsmoothing_check = widget;
widget = gtk_check_button_new_with_label (_("Composition"));
gtk_widget_show (widget);
gtk_table_attach_defaults (GTK_TABLE (table), widget, 2, 3, 7, 8);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (remmina_plugin_rdpset_quality_option_on_toggled), table);
table->composition_check = widget;
gtk_combo_box_set_active (GTK_COMBO_BOX (table->quality_combo), 0);
}
GtkWidget *gui_build_dialog_gtk_table(GSList * list, gint cols, gboolean use_progress)
{
GSList *listtmp = list;
GtkWidget *adv_vbox = NULL;
GtkWidget *adv_expander = NULL;
gint ielements = g_slist_position(list, g_slist_last(list));
gint rows = ((ielements + 1) / cols) + use_progress;
GtkWidget *tab = gtk_table_new(rows, cols, FALSE);
gint actC = 0, actR = 0;
GtkWidget *to_grab_focus = NULL;
gboolean need_advanced = FALSE;
gtk_container_set_border_width(GTK_CONTAINER(tab), 15);
/* remember to free adv_expander */
adv_vbox = gtk_vbox_new(FALSE, 5);
while (listtmp)
{
GGaduKeyValue *kv = (GGaduKeyValue *) listtmp->data;
GtkWidget *entry = NULL;
gboolean need_label = TRUE;
gboolean is_advanced = FALSE;
switch (kv->type)
{
case VAR_STR:
entry = gtk_entry_new();
if (kv->value)
gtk_entry_set_text(GTK_ENTRY(entry), g_strdup(kv->value));
gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
break;
case VAR_INT:
{
entry = gtk_spin_button_new_with_range(0, 999999999, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(entry), (gint) kv->value);
gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
}
break;
case VAR_INT_WITH_NEGATIVE:
{
entry = gtk_spin_button_new_with_range(-999999999, 999999999, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(entry), (gint) kv->value);
gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
}
break;
case VAR_BOOL:
need_label = FALSE;
entry = gtk_check_button_new_with_mnemonic(kv->description);
if (kv->value)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(entry), TRUE);
break;
case VAR_FILE_CHOOSER:
{
GtkWidget *txt_entry = NULL;
GtkWidget *button_entry = NULL;
entry = gtk_hbox_new(FALSE, 2);
txt_entry = gtk_entry_new();
if (kv->value)
gtk_entry_set_text(GTK_ENTRY(txt_entry), g_strdup(kv->value));
g_object_set_data(G_OBJECT(txt_entry), "kv", kv);
g_object_set_data(G_OBJECT(entry), "txt_entry", txt_entry);
button_entry = gtk_button_new_from_stock("gtk-open");
gtk_box_pack_start_defaults(GTK_BOX(entry), txt_entry);
gtk_box_pack_start_defaults(GTK_BOX(entry), button_entry);
g_signal_connect_swapped(button_entry, "clicked", G_CALLBACK(gui_dialog_show_filename), txt_entry);
}
break;
case VAR_FONT_CHOOSER:
{
GtkWidget *txt_entry = NULL;
GtkWidget *button_entry = NULL;
entry = gtk_hbox_new(FALSE, 2);
txt_entry = gtk_entry_new();
if (kv->value)
gtk_entry_set_text(GTK_ENTRY(txt_entry), g_strdup(kv->value));
g_object_set_data(G_OBJECT(txt_entry), "kv", kv);
g_object_set_data(G_OBJECT(entry), "txt_entry", txt_entry);
button_entry = gtk_button_new_from_stock("gtk-select-font");
gtk_box_pack_start_defaults(GTK_BOX(entry), txt_entry);
gtk_box_pack_start_defaults(GTK_BOX(entry), button_entry);
g_signal_connect_swapped(button_entry, "clicked", G_CALLBACK(gui_dialog_show_fontchooser), txt_entry);
}
break;
case VAR_COLOUR_CHOOSER:
{
GtkWidget *txt_entry = NULL;
GtkWidget *button_entry = NULL;
GdkColor color;
entry = gtk_hbox_new(FALSE, 2);
txt_entry = gtk_entry_new();
if (kv->value)
gtk_entry_set_text(GTK_ENTRY(txt_entry), g_strdup(kv->value));
gdk_color_parse(gtk_entry_get_text(GTK_ENTRY(txt_entry)), &color);
g_object_set_data(G_OBJECT(txt_entry), "kv", kv);
g_object_set_data(G_OBJECT(entry), "txt_entry", txt_entry);
button_entry = gtk_color_button_new_with_color(&color);
gtk_box_pack_start_defaults(GTK_BOX(entry), txt_entry);
gtk_box_pack_start_defaults(GTK_BOX(entry), button_entry);
g_signal_connect(G_OBJECT(button_entry), "color-set", G_CALLBACK(gui_dialog_show_colorchooser), txt_entry);
}
break;
case VAR_IMG:
need_label = FALSE;
entry = gtk_image_new_from_file(kv->value);
gtk_table_set_homogeneous(GTK_TABLE(tab), FALSE);
break;
case VAR_LIST:
{
GSList *selected = g_slist_nth((GSList *) kv->value, 0);
GSList *restlist = g_slist_nth((GSList *) kv->value, 1);
gint selected_index = 0;
gint i = -1;
entry = gtk_combo_box_new_text();
g_object_set_data(G_OBJECT(entry), "options-list", restlist);
while (restlist)
{
i++;
if (!g_strcasecmp(selected->data, restlist->data))
{
selected_index = i;
print_debug("############# %d %s", selected_index, selected->data);
}
gtk_combo_box_append_text(GTK_COMBO_BOX(entry), g_strdup(restlist->data));
restlist = restlist->next;
}
gtk_combo_box_set_active(GTK_COMBO_BOX(entry), selected_index);
}
break;
default:
break;
}
if ((kv->flag & VAR_FLAG_SENSITIVE) != 0)
{
gtk_widget_set_sensitive(GTK_WIDGET(entry), TRUE);
gtk_editable_set_editable(GTK_EDITABLE(entry), TRUE);
}
if ((kv->flag & VAR_FLAG_INSENSITIVE) != 0)
{
gtk_widget_set_sensitive(GTK_WIDGET(entry), FALSE);
gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
}
if ((kv->flag & VAR_FLAG_PASSWORD) != 0)
gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
if ((kv->flag & VAR_FLAG_FOCUS) != 0)
to_grab_focus = entry;
kv->user_data = (gpointer) entry;
if ((kv->flag & VAR_FLAG_ADVANCED) != 0)
{
GtkWidget *hbox = gtk_hbox_new(FALSE, 5);
GtkWidget *align;
GtkWidget *label;
need_advanced = TRUE;
is_advanced = TRUE;
gtk_box_pack_end_defaults(GTK_BOX(hbox), entry);
if (need_label)
{
align = gtk_alignment_new(0, 0.5, 0, 0);
label = gtk_label_new_with_mnemonic(kv->description);
gtk_container_add(GTK_CONTAINER(align), label);
gtk_box_pack_end_defaults(GTK_BOX(hbox), align);
}
gtk_box_pack_start_defaults(GTK_BOX(adv_vbox), hbox);
}
if (need_label && !is_advanced)
{
GtkWidget *align = gtk_alignment_new(0, 0.5, 0, 0);
GtkWidget *label = gtk_label_new_with_mnemonic(kv->description);
gtk_container_add(GTK_CONTAINER(align), label);
gtk_table_attach_defaults(GTK_TABLE(tab), align, 0, 1, actR, actR + 1);
if (entry)
gtk_table_attach_defaults(GTK_TABLE(tab), entry, 1, 2, actR, actR + 1);
}
else if (!is_advanced)
{
gtk_table_attach(GTK_TABLE(tab), entry, actC, actC + 2, actR, actR + 1, GTK_FILL, GTK_SHRINK, 0, 0);
}
if (!is_advanced)
{
if ((actC + 1) < cols)
actC++;
else
{
actC = 0;
actR++;
}
}
listtmp = listtmp->next;
}
if (need_advanced)
{
adv_expander = gtk_expander_new_with_mnemonic(_("_More options"));
gtk_container_add(GTK_CONTAINER(adv_expander), adv_vbox);
gtk_table_attach_defaults(GTK_TABLE(tab), adv_expander, 0, rows, actR, actR + 1);
}
else
{
gtk_widget_destroy(adv_vbox);
}
/* progress stuff */
if (use_progress)
{
GtkWidget *progress = gtk_progress_bar_new();
gtk_table_attach_defaults(GTK_TABLE(tab), progress, 0, rows, actR, actR + 1);
}
if (to_grab_focus)
gtk_widget_grab_focus(GTK_WIDGET(to_grab_focus));
return tab;
}
int main(int argc, char **argv)
{
GtkWidget *menubar = NULL;
GtkWidget *table = NULL;
GtkWidget *combo = NULL;
GtkBin *bin = NULL;
GtkViewport *view = NULL;
int i=0;
log_options_t lopts = LOG_OPTS_STDERR_ONLY;
if (!getenv("SLURM_BITSTR_LEN"))
setenv("SLURM_BITSTR_LEN", "128", 1); /* More array info */
slurm_conf_init(NULL);
log_init(argv[0], lopts, SYSLOG_FACILITY_USER, NULL);
load_defaults();
cluster_flags = slurmdb_setup_cluster_flags();
cluster_dims = slurmdb_setup_cluster_dims();
_init_pages();
sview_thread_init(NULL);
gdk_threads_init();
gdk_threads_enter();
/* Initialize GTK */
gtk_init (&argc, &argv);
sview_mutex_new(&sview_mutex);
sview_mutex_new(&grid_mutex);
sview_cond_new(&grid_cond);
/* make sure the system is up */
grid_window = GTK_WIDGET(create_scrolled_window());
bin = GTK_BIN(>K_SCROLLED_WINDOW(grid_window)->container);
view = GTK_VIEWPORT(bin->child);
bin = GTK_BIN(&view->bin);
main_grid_table = GTK_TABLE(bin->child);
gtk_table_set_homogeneous(main_grid_table, true);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(grid_window),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
/* fill in all static info for pages */
/* Make a window */
main_window = gtk_dialog_new();
g_signal_connect(G_OBJECT(main_window), "delete_event",
G_CALLBACK(_delete), NULL);
gtk_window_set_title(GTK_WINDOW(main_window), "Sview");
gtk_window_set_default_size(GTK_WINDOW(main_window),
working_sview_config.main_width,
working_sview_config.main_height);
gtk_container_set_border_width(
GTK_CONTAINER(GTK_DIALOG(main_window)->vbox), 1);
/* Create the main notebook, place the position of the tabs */
main_notebook = gtk_notebook_new();
g_signal_connect(G_OBJECT(main_notebook), "switch_page",
G_CALLBACK(_page_switched),
NULL);
table = gtk_table_new(1, 3, false);
gtk_table_set_homogeneous(GTK_TABLE(table), false);
gtk_container_set_border_width(GTK_CONTAINER(table), 1);
/* Create a menu */
menubar = _get_menubar_menu(main_window, main_notebook);
gtk_table_attach_defaults(GTK_TABLE(table), menubar, 0, 1, 0, 1);
if ((combo = _create_cluster_combo())) {
GtkWidget *label = gtk_label_new("Cluster ");
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1,
GTK_FILL, GTK_SHRINK, 0, 0);
gtk_table_attach(GTK_TABLE(table), combo, 2, 3, 0, 1,
GTK_FILL, GTK_SHRINK, 0, 0);
}
gtk_notebook_popup_enable(GTK_NOTEBOOK(main_notebook));
gtk_notebook_set_scrollable(GTK_NOTEBOOK(main_notebook), true);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(main_notebook),
working_sview_config.tab_pos);
main_statusbar = gtk_statusbar_new();
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(main_statusbar),
false);
/* Pack it all together */
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox),
table, false, false, 0);
table = gtk_table_new(1, 2, false);
gtk_table_attach(GTK_TABLE(table), grid_window, 0, 1, 0, 1,
GTK_SHRINK, GTK_EXPAND | GTK_FILL,
0, 0);
gtk_table_attach_defaults(GTK_TABLE(table), main_notebook, 1, 2, 0, 1);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox),
table, true, true, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox),
main_statusbar, false, false, 0);
in_process_cursor = gdk_cursor_new(GDK_WATCH);
for(i=0; i<PAGE_CNT; i++) {
if (main_display_data[i].id == -1)
break;
create_page(GTK_NOTEBOOK(main_notebook),
&main_display_data[i]);
}
/* tell signal we are done adding */
popup_list = list_create(destroy_popup_info);
signal_params_list = list_create(destroy_signal_params);
gtk_widget_show_all(main_window);
adding = 0;
/* apply default settings */
if (!working_sview_config.show_grid)
gtk_widget_hide(grid_window);
for(i=0; i<PAGE_CNT; i++) {
GtkWidget *visible_tab = NULL;
if (main_display_data[i].id == -1)
break;
visible_tab = gtk_notebook_get_nth_page(
GTK_NOTEBOOK(main_notebook), i);
if (working_sview_config.page_visible[i]
|| (i == working_sview_config.default_page)
|| (i == TAB_PAGE))
gtk_widget_show(visible_tab);
else
gtk_widget_hide(visible_tab);
}
/* Set the default page. This has to be done after the
* gtk_widget_show_all since it, for some reason always sets
* 0 to be the default page and will just overwrite this. */
/* Also if we already are set at the current page we need to
start up the page thread, so just call the _page_switched
function. If we aren't already there, then set the current
page which will inturn call the _page_switched. If the
pages is already this the signal doesn't happen so handle
it here.
*/
if (gtk_notebook_get_current_page(GTK_NOTEBOOK(main_notebook))
== working_sview_config.default_page)
_page_switched(GTK_NOTEBOOK(main_notebook), NULL,
working_sview_config.default_page, NULL);
else
gtk_notebook_set_current_page(GTK_NOTEBOOK(main_notebook),
working_sview_config.
default_page);
/* Finished! */
gtk_main ();
gdk_threads_leave();
return 0;
}
int main (int argc, char *argv[])
{
/* Vars */
GtkWidget *vbox;
GtkWidget *window;
GtkWidget *table;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *button;
GtkWidget* scrolled;
GtkWidget *menubar;
GtkWidget *filemenu;
GtkWidget *file;
GtkWidget *quit;
GtkWidget *reindexer;
/* Set default directory to index */
indexdir = ".";
/* Run the indexer */
reindex(NULL, NULL);
/* Create the search objects */
createSearch();
/* Make the GUI */
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
initialize_window(window);
/* Create a 10x5 table */
table = gtk_table_new (10, 5, FALSE);
gtk_container_add (GTK_CONTAINER (window), table);
/* create a new label. */
label = gtk_label_new ("Search Terms:" );
gtk_table_set_homogeneous(GTK_TABLE (table), TRUE);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 1, 2);
entry = gtk_entry_new ();
gtk_entry_set_max_length (GTK_ENTRY (entry),1000);
gtk_table_attach_defaults (GTK_TABLE (table), entry, 1, 3, 1, 2);
button = gtk_button_new_with_label ("OR Search");
gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (orsearch), (gpointer) entry);
gtk_table_attach_defaults (GTK_TABLE (table), button, 3, 4, 1, 2);
button = gtk_button_new_with_label ("AND Search");
gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (andsearch), (gpointer) entry);
gtk_table_attach_defaults (GTK_TABLE (table), button, 4, 5, 1, 2);
textview = gtk_text_view_new();
gtk_text_view_set_editable( GTK_TEXT_VIEW (textview), 0);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (textview), 0);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled), textview);
gtk_table_attach_defaults (GTK_TABLE (table), scrolled, 0, 5, 2, 10);
vbox = gtk_vbox_new(FALSE, 0);
gtk_table_attach_defaults (GTK_TABLE (table), vbox, 0, 5, 0, 1);
menubar = gtk_menu_bar_new();
filemenu = gtk_menu_new();
file = gtk_menu_item_new_with_label("File");
reindexer = gtk_menu_item_new_with_label("Reindex");
gtk_signal_connect (GTK_OBJECT (reindexer), "activate", G_CALLBACK(reindex), NULL);
quit = gtk_menu_item_new_with_label("Quit");
gtk_signal_connect (GTK_OBJECT (quit), "activate", G_CALLBACK(destroy), NULL);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), filemenu);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), reindexer);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quit);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file);
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3);
gtk_widget_show_all(window);
gtk_main ();
return 0;
}
extern int configure_defaults(void)
{
GtkScrolledWindow *window = create_scrolled_window();
GtkWidget *popup = gtk_dialog_new_with_buttons(
"Sview Defaults",
GTK_WINDOW(main_window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
NULL);
GtkWidget *label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_OK, GTK_RESPONSE_OK);
GtkBin *bin = NULL;
GtkViewport *view = NULL;
GtkTable *table = NULL;
int i = 0, row = 0;
char tmp_char[100];
char *tmp_char_ptr;
display_data_t *display_data = display_data_defaults;
sview_config_t tmp_config;
int response = 0;
int rc = SLURM_SUCCESS;
uint32_t width = 150;
uint32_t height = 700;
apply_hidden_change = TRUE;
memcpy(&tmp_config, &default_sview_config, sizeof(sview_config_t));
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
/*
for(i=0;; i++) {
if (main_popup_positioner[i].width == -1)
break;
if (strstr("Sview Defaults", main_popup_positioner[i].name)) {
pos_x = main_popup_positioner[i].width;
pos_y = main_popup_positioner[i].height;
break;
}
}
*/
gtk_window_set_default_size(GTK_WINDOW(popup), width, height);
snprintf(tmp_char, sizeof(tmp_char),
"Default Settings for Sview");
label = gtk_label_new(tmp_char);
gtk_scrolled_window_set_policy(window,
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
bin = GTK_BIN(&window->container);
view = GTK_VIEWPORT(bin->child);
bin = GTK_BIN(&view->bin);
table = GTK_TABLE(bin->child);
gtk_table_resize(table, SORTID_CNT, 2);
gtk_table_set_homogeneous(table, FALSE);
for (i = 0; i < SORTID_CNT; i++) {
while (display_data++) {
if (display_data->id == -1)
break;
if (!display_data->name)
continue;
if (display_data->id != i)
continue;
_local_display_admin_edit(
table, &tmp_config, &row,
display_data);
break;
}
display_data = display_data_defaults;
}
gtk_table_resize(table, row, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
label, FALSE, FALSE, 0);
if (window)
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
GTK_WIDGET(window), TRUE, TRUE, 0);
gtk_widget_show_all(popup);
response = gtk_dialog_run (GTK_DIALOG(popup));
if (response == GTK_RESPONSE_OK) {
tmp_char_ptr = g_strdup_printf(
"Defaults updated successfully");
if (global_edit_error)
tmp_char_ptr = global_edit_error_msg;
else if (!global_send_update_msg)
tmp_char_ptr = g_strdup_printf(
"No change detected.");
else {
int action = 0;
gdk_window_set_cursor(main_window->window,
in_process_cursor);
if (tmp_config.ruled_treeview
!= working_sview_config.ruled_treeview) {
/* get rid of each existing table */
cluster_change_block();
cluster_change_resv();
cluster_change_part();
cluster_change_job();
cluster_change_node();
cluster_change_front_end();
} else if (tmp_config.grid_topological !=
working_sview_config.grid_topological) {
apply_hidden_change = FALSE;
if (tmp_config.grid_topological) {
default_sview_config.grid_topological =
tmp_config.grid_topological;
if (!g_switch_nodes_maps)
rc = get_topo_conf();
if (rc != SLURM_SUCCESS) {
/*denied*/
tmp_char_ptr = g_strdup_printf(
"Valid topology not "
"detected");
tmp_config.grid_topological =
FALSE;
goto denied_change;
}
}
/*force fresh grid and
* node state check
* */
FREE_NULL_LIST(grid_button_list);
slurm_free_node_info_msg(g_node_info_ptr);
g_node_info_ptr = NULL;
}
/*apply change*/
memcpy(&default_sview_config, &tmp_config,
sizeof(sview_config_t));
memcpy(&working_sview_config, &tmp_config,
sizeof(sview_config_t));
/* set the current display to the default */
gtk_toggle_action_set_active(
default_sview_config.action_admin,
working_sview_config.admin_mode);
gtk_toggle_action_set_active(
default_sview_config.action_ruled,
working_sview_config.ruled_treeview);
gtk_toggle_action_set_active(
default_sview_config.action_grid,
working_sview_config.show_grid);
gtk_toggle_action_set_active(
default_sview_config.action_hidden,
working_sview_config.show_hidden);
apply_hidden_change = TRUE;
gtk_toggle_action_set_active(
default_sview_config.action_page_opts,
working_sview_config.save_page_opts);
#ifdef GTK2_USE_RADIO_SET
/* Since this value isn't a simple 0->n we
need to translate if we don't have the
newer gtk.
*/
action = working_sview_config.tab_pos;
#else
/* If using older gtk we need to translate the
tab position to that of the position in the
radio list.
*/
action = _trans_tab_pos(working_sview_config.tab_pos);
#endif
sview_radio_action_set_current_value(
default_sview_config.action_tab, action);
for (i=0; i<PAGE_CNT; i++) {
if (main_display_data[i].id == -1)
break;
if (!main_display_data[i].name
|| (i == TAB_PAGE))
continue;
toggle_tab_visiblity(NULL, main_display_data+i);
}
get_system_stats(main_grid_table);
/******************************************/
save_defaults(false);
}
denied_change:
display_edit_note(tmp_char_ptr);
g_free(tmp_char_ptr);
}
global_entry_changed = 0;
gtk_widget_destroy(popup);
if (main_window && main_window->window)
gdk_window_set_cursor(main_window->window, NULL);
return rc;
}
static void
saa_solid_manager_init (SaaSolidManager * mgr) {
GtkWidget * but_numero, * but_wythoff, * but_filename;
GtkWidget * image1, * image2, * image3;
GtkObject * sbut_numero_adj;
const gchar * filename_path;
gtk_table_resize(GTK_TABLE(mgr), 3, 5);
gtk_table_set_homogeneous(GTK_TABLE(mgr), FALSE);
gtk_table_set_row_spacings (GTK_TABLE (mgr), 5);
gtk_table_set_col_spacings (GTK_TABLE (mgr), 5);
gtk_container_set_border_width (GTK_CONTAINER (mgr), 5);
// Numero
mgr->radio_numero = gtk_radio_button_new_with_label_from_widget (NULL, _("Number:"));
gtk_widget_set_name(mgr->radio_numero, "numero-rad");
gtk_widget_show (mgr->radio_numero);
gtk_table_attach (GTK_TABLE (mgr), mgr->radio_numero, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
sbut_numero_adj = gtk_adjustment_new (1, 1, 80, 1, 10, 0);
mgr->spin_numero = gtk_spin_button_new (GTK_ADJUSTMENT (sbut_numero_adj), 1, 0);
gtk_widget_set_name(mgr->spin_numero, "numero-ent");
gtk_widget_show (mgr->spin_numero);
gtk_table_attach (GTK_TABLE (mgr), mgr->spin_numero, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mgr->spin_numero), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mgr->spin_numero), TRUE);
but_numero = gtk_button_new ();
gtk_widget_set_name(but_numero, "numero-btn");
gtk_widget_show (but_numero);
gtk_table_attach (GTK_TABLE (mgr), but_numero, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
image1 = gtk_image_new_from_stock ("gtk-refresh", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image1);
gtk_container_add (GTK_CONTAINER (but_numero), image1);
// Wythoff
mgr->radio_wythoff = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (mgr->radio_numero), _("Wythoff symbol:"));
gtk_widget_set_name(mgr->radio_wythoff, "wythoff-rad");
gtk_widget_show (mgr->radio_wythoff);
gtk_table_attach (GTK_TABLE (mgr), mgr->radio_wythoff, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
mgr->entry_wythoff = gtk_entry_new ();
gtk_widget_set_name(mgr->entry_wythoff, "wythoff-ent");
gtk_widget_show (mgr->entry_wythoff);
gtk_table_attach (GTK_TABLE (mgr), mgr->entry_wythoff, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_entry_set_has_frame (GTK_ENTRY (mgr->entry_wythoff), FALSE);
but_wythoff = gtk_button_new ();
gtk_widget_set_name(but_wythoff, "wythoff-btn");
gtk_widget_show (but_wythoff);
gtk_table_attach (GTK_TABLE (mgr), but_wythoff, 2, 3, 1, 2, GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
image2 = gtk_image_new_from_stock ("gtk-refresh", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image2);
gtk_container_add (GTK_CONTAINER (but_wythoff), image2);
// Dual
mgr->but_dual = gtk_toggle_button_new_with_mnemonic (_("Dual"));
gtk_widget_set_name(mgr->but_dual, "numero-wythoff-dual-btn");
gtk_widget_show (mgr->but_dual);
gtk_table_attach (GTK_TABLE (mgr), mgr->but_dual, 3, 4, 0, 2, GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
// Filename
mgr->radio_filename = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (mgr->radio_wythoff), _("File:"));
gtk_widget_set_name(mgr->radio_filename, "filename-rad");
gtk_widget_show (mgr->radio_filename);
gtk_table_attach (GTK_TABLE (mgr), mgr->radio_filename, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
mgr->but_filename = gtk_file_chooser_button_new (_("Load a solid"), GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_widget_set_name(mgr->but_filename, "filename-but");
gtk_widget_show (mgr->but_filename);
gtk_table_attach (GTK_TABLE (mgr), mgr->but_filename, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
filename_path = g_get_user_special_dir(G_USER_DIRECTORY_DOCUMENTS);
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(mgr->but_filename), filename_path);
but_filename = gtk_button_new ();
gtk_widget_set_name(but_filename, "filename-btn");
gtk_widget_show (but_filename);
gtk_table_attach (GTK_TABLE (mgr), but_filename, 2, 3, 2, 3, GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
image3 = gtk_image_new_from_stock ("gtk-refresh", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image3);
gtk_container_add (GTK_CONTAINER (but_filename), image3);
// Nom
mgr->label_nom = gtk_label_new ("");
gtk_widget_set_name(mgr->label_nom, "numero-wythoff-filename-lbl");
gtk_widget_show (mgr->label_nom);
gtk_table_attach (GTK_TABLE (mgr), mgr->label_nom, 0, 4, 4, 5, GTK_FILL, GTK_FILL, 0, 0);
gtk_label_set_justify (GTK_LABEL (mgr->label_nom), GTK_JUSTIFY_CENTER);
g_signal_connect_swapped ((gpointer) mgr->radio_numero, "toggled",
G_CALLBACK (saa_solid_manager_radio_numero_toggled),
mgr);
g_signal_connect_swapped ((gpointer) mgr->radio_wythoff, "toggled",
G_CALLBACK (saa_solid_manager_radio_wythoff_toggled),
mgr);
g_signal_connect_swapped ((gpointer) mgr->radio_filename, "toggled",
G_CALLBACK (saa_solid_manager_radio_filename_toggled),
mgr);
g_signal_connect_swapped ((gpointer) but_numero, "clicked",
G_CALLBACK (saa_solid_manager_numero_changed),
mgr);
g_signal_connect_swapped ((gpointer) but_wythoff, "clicked",
G_CALLBACK (saa_solid_manager_wythoff_changed),
mgr);
g_signal_connect_swapped ((gpointer) but_filename, "clicked",
G_CALLBACK (saa_solid_manager_filename_changed),
mgr);
g_signal_connect_swapped ((gpointer) mgr->but_dual, "toggled",
G_CALLBACK (saa_solid_manager_dual_toggled),
mgr);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mgr->radio_wythoff), TRUE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mgr->radio_numero), TRUE);
}
static void
saa_solid_display_init (SaaSolidDisplay * dsp) {
GtkWidget * frs, * frar, * frai, * fro;
GtkWidget * ts, * tar, * to, * hai;
GtkWidget * bg_label;
GtkObject * adjs = gtk_adjustment_new (.02, .02, .5, .001, .01, 0);
GtkObject * adjar = gtk_adjustment_new (.01, .01, .2, .001, .01, 0);
gtk_table_resize(GTK_TABLE(dsp), 4, 1);
gtk_table_set_homogeneous(GTK_TABLE(dsp), TRUE);
frs = gtk_frame_new(_("Vertices"));
gtk_widget_show(frs);
gtk_table_attach_defaults (GTK_TABLE (dsp), frs, 0, 1, 0, 1);
ts = gtk_table_new(3, 2, TRUE);
gtk_widget_show(ts);
gtk_container_set_border_width (GTK_CONTAINER (ts), 5);
gtk_container_add(GTK_CONTAINER(frs), ts);
dsp->rads1 = gtk_radio_button_new_with_label(NULL, _("Do not display"));
gtk_widget_show(dsp->rads1);
gtk_table_attach_defaults (GTK_TABLE (ts), dsp->rads1, 0, 2, 0, 1);
dsp->rads2 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(dsp->rads1), _("Molecular"));
gtk_widget_show(dsp->rads2);
gtk_table_attach_defaults (GTK_TABLE (ts), dsp->rads2, 0, 1, 1, 2);
dsp->rads3 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(dsp->rads2), _("Point"));
gtk_widget_show(dsp->rads3);
gtk_table_attach_defaults (GTK_TABLE (ts), dsp->rads3, 0, 1, 2, 3);
dsp->spins = gtk_spin_button_new(GTK_ADJUSTMENT(adjs), 0.001, 3);
gtk_widget_show(dsp->spins);
gtk_table_attach (GTK_TABLE (ts), dsp->spins, 1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
dsp->bts = gtk_color_button_new();
gtk_widget_show(dsp->bts);
gtk_table_attach (GTK_TABLE (ts), dsp->bts, 1, 2, 2, 3, GTK_SHRINK, GTK_SHRINK, 0, 0);
frar = gtk_frame_new(_("Edges"));
gtk_widget_show(frar);
gtk_table_attach (GTK_TABLE (dsp), frar, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
tar = gtk_table_new(3, 2, TRUE);
gtk_widget_show(tar);
gtk_container_set_border_width (GTK_CONTAINER (tar), 5);
gtk_container_add(GTK_CONTAINER(frar), tar);
dsp->radar1 = gtk_radio_button_new_with_label(NULL, _("Do not display"));
gtk_widget_show(dsp->radar1);
gtk_table_attach_defaults (GTK_TABLE (tar), dsp->radar1, 0, 2, 0, 1);
dsp->radar2 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(dsp->radar1), _("Molecular"));
gtk_widget_show(dsp->radar2);
gtk_table_attach_defaults (GTK_TABLE (tar), dsp->radar2, 0, 1, 1, 2);
dsp->radar3 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(dsp->radar2), _("Line"));
gtk_widget_show(dsp->radar3);
gtk_table_attach_defaults (GTK_TABLE (tar), dsp->radar3, 0, 1, 2, 3);
dsp->spinar = gtk_spin_button_new(GTK_ADJUSTMENT(adjar), 0.001, 3);
gtk_widget_show(dsp->spinar);
gtk_table_attach (GTK_TABLE (tar), dsp->spinar, 1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
dsp->btar = gtk_color_button_new();
gtk_widget_show(dsp->btar);
gtk_table_attach (GTK_TABLE (tar), dsp->btar, 1, 2, 2, 3, GTK_SHRINK, GTK_SHRINK, 0, 0);
frai = gtk_frame_new(_("Wings"));
gtk_widget_show(frai);
gtk_table_attach (GTK_TABLE (dsp), frai, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
hai = gtk_vbox_new(TRUE, 5);
gtk_widget_show(hai);
gtk_container_set_border_width (GTK_CONTAINER (hai), 5);
gtk_container_add(GTK_CONTAINER(frai), hai);
dsp->radai1 = gtk_radio_button_new_with_label(NULL, _("Do not display"));
gtk_widget_show(dsp->radai1);
gtk_box_pack_start_defaults(GTK_BOX(hai), dsp->radai1);
dsp->radai2 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(dsp->radai1), _("Triangulation"));
gtk_widget_show(dsp->radai2);
gtk_box_pack_start_defaults(GTK_BOX(hai), dsp->radai2);
dsp->radai3 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(dsp->radai2), _("Colour"));
gtk_widget_show(dsp->radai3);
gtk_box_pack_start_defaults(GTK_BOX(hai), dsp->radai3);
fro = gtk_frame_new("Autres");
gtk_widget_show(fro);
gtk_table_attach_defaults (GTK_TABLE (dsp), fro, 0, 1, 3, 4);
to = gtk_table_new(4, 2, TRUE);
gtk_widget_show(to);
gtk_container_set_border_width (GTK_CONTAINER (to), 5);
gtk_container_add(GTK_CONTAINER(fro), to);
dsp->chlight = gtk_check_button_new_with_label(_("Lighting"));
gtk_widget_show(dsp->chlight);
gtk_table_attach (GTK_TABLE (to), dsp->chlight, 0, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
dsp->chtrans = gtk_check_button_new_with_label(_("Transparency"));
gtk_widget_show(dsp->chtrans);
gtk_table_attach (GTK_TABLE (to), dsp->chtrans, 0, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
dsp->chaxes = gtk_check_button_new_with_label(_("Axes"));
gtk_widget_show(dsp->chaxes);
gtk_table_attach (GTK_TABLE (to), dsp->chaxes, 0, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
bg_label = gtk_label_new(_("Background"));
gtk_widget_show(bg_label);
gtk_table_attach_defaults (GTK_TABLE (to), bg_label, 0, 1, 3, 4);
dsp->btbg = gtk_color_button_new();
gtk_widget_show(dsp->btbg);
gtk_table_attach (GTK_TABLE (to), dsp->btbg, 1, 2, 3, 4, GTK_SHRINK, GTK_SHRINK, 0, 0);
g_signal_connect_swapped ((gpointer) dsp->rads1, "toggled",
G_CALLBACK (saa_solid_display_s1),
dsp);
g_signal_connect_swapped ((gpointer) dsp->rads2, "toggled",
G_CALLBACK (saa_solid_display_s2),
dsp);
g_signal_connect_swapped ((gpointer) dsp->rads3, "toggled",
G_CALLBACK (saa_solid_display_s3),
dsp);
g_signal_connect_swapped ((gpointer) dsp->radar1, "toggled",
G_CALLBACK (saa_solid_display_ar1),
dsp);
g_signal_connect_swapped ((gpointer) dsp->radar2, "toggled",
G_CALLBACK (saa_solid_display_ar2),
dsp);
g_signal_connect_swapped ((gpointer) dsp->radar3, "toggled",
G_CALLBACK (saa_solid_display_ar3),
dsp);
g_signal_connect_swapped ((gpointer) dsp->radai1, "toggled",
G_CALLBACK (saa_solid_display_ai1),
dsp);
g_signal_connect_swapped ((gpointer) dsp->radai2, "toggled",
G_CALLBACK (saa_solid_display_ai2),
dsp);
g_signal_connect_swapped ((gpointer) dsp->radai3, "toggled",
G_CALLBACK (saa_solid_display_ai3),
dsp);
g_signal_connect_swapped ((gpointer) dsp->chlight, "toggled",
G_CALLBACK (saa_solid_display_light),
dsp);
g_signal_connect_swapped ((gpointer) dsp->chtrans, "toggled",
G_CALLBACK (saa_solid_display_trans),
dsp);
g_signal_connect_swapped ((gpointer) dsp->chaxes, "toggled",
G_CALLBACK (saa_solid_display_axes),
dsp);
g_signal_connect_swapped ((gpointer) dsp->btbg, "color-set",
G_CALLBACK (saa_solid_display_bgcolor),
dsp);
g_signal_connect_swapped ((gpointer) dsp->bts, "color-set",
G_CALLBACK (saa_solid_display_scolor),
dsp);
g_signal_connect_swapped ((gpointer) dsp->btar, "color-set",
G_CALLBACK (saa_solid_display_arcolor),
dsp);
g_signal_connect_swapped ((gpointer) dsp->spins, "value-changed",
G_CALLBACK (saa_solid_display_ssize),
dsp);
g_signal_connect_swapped ((gpointer) dsp->spinar, "value-changed",
G_CALLBACK (saa_solid_display_arsize),
dsp);
}
