void OnConf_Cpu(GtkMenuItem *menuitem, gpointer user_data)
{
char str[512];
CpuDlg = create_CpuDlg();
gtk_window_set_title(GTK_WINDOW(CpuDlg), _("Configuration"));
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_EERec")), !!CHECK_EEREC);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_VU0rec")), !!CHECK_VU0REC);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_VU1rec")), !!CHECK_VU1REC);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_MTGS")), !!CHECK_MULTIGS);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_LimitNormal")), CHECK_FRAMELIMIT == PCSX2_FRAMELIMIT_NORMAL);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_LimitLimit")), CHECK_FRAMELIMIT == PCSX2_FRAMELIMIT_LIMIT);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_LimitFS")), CHECK_FRAMELIMIT == PCSX2_FRAMELIMIT_SKIP);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_VUSkip")), CHECK_FRAMELIMIT == PCSX2_FRAMELIMIT_VUSKIP);
sprintf(str, "Cpu Vendor: %s", cpuinfo.x86ID);
gtk_label_set_text(GTK_LABEL(lookup_widget(CpuDlg, "GtkLabel_CpuVendor")), str);
sprintf(str, "Familly: %s", cpuinfo.x86Fam);
gtk_label_set_text(GTK_LABEL(lookup_widget(CpuDlg, "GtkLabel_Family")), str);
sprintf(str, "Cpu Speed: %d MHZ", cpuinfo.cpuspeed);
gtk_label_set_text(GTK_LABEL(lookup_widget(CpuDlg, "GtkLabel_CpuSpeed")), str);
strcpy(str, "Features: ");
if (cpucaps.hasMultimediaExtensions) strcat(str, "MMX");
if (cpucaps.hasStreamingSIMDExtensions) strcat(str, ",SSE");
if (cpucaps.hasStreamingSIMD2Extensions) strcat(str, ",SSE2");
if (cpucaps.hasStreamingSIMD3Extensions) strcat(str, ",SSE3");
if (cpucaps.hasAMD64BitArchitecture) strcat(str, ",x86-64");
gtk_label_set_text(GTK_LABEL(lookup_widget(CpuDlg, "GtkLabel_Features")), str);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "CustomFPSLimit")), (gdouble)Config.CustomFps);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "FrameThreshold")), (gdouble)Config.CustomFrameSkip);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "FramesBeforeSkipping")), (gdouble)Config.CustomConsecutiveFrames);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "FramesToSkip")), (gdouble)Config.CustomConsecutiveSkip);
gtk_widget_show_all(CpuDlg);
if (MainWindow) gtk_widget_set_sensitive(MainWindow, FALSE);
gtk_main();
}
void
clear_text_page(gboolean add, gint *uncommitted)
{
guint len;
gint ucm;
ucm = *uncommitted;
gtk_entry_set_text(GTK_ENTRY(sp->title_entry), "");
if (add == TRUE)
{
time_label_set_time(TIME_LABEL(sp->tlabel_created), time(NULL));
}
else
{
time_label_set_time(TIME_LABEL(sp->tlabel_created), -1);
}
time_label_set_time(TIME_LABEL(sp->tlabel_changed), -1);
if (add == TRUE)
{
gtk_label_set_text(GTK_LABEL(sp->label_changes), _("0"));
}
else
{
gtk_label_set_text(GTK_LABEL(sp->label_changes), "");
}
time_label_set_time(TIME_LABEL(sp->tlabel_expire), -1);
gtk_entry_set_text(GTK_ENTRY(sp->note_id_entry), "");
gnome_date_edit_set_time(GNOME_DATE_EDIT(sp->de_deadline), 0);
gtk_entry_set_text(GTK_ENTRY(sp->prio_entry), "");
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(sp->todo_check), FALSE);
gtk_adjustment_set_value(GTK_ADJUSTMENT(sp->ad_complete), 0);
len = gtk_text_get_length(GTK_TEXT(sp->text_entry));
if (len)
{
gtk_text_freeze(GTK_TEXT(sp->text_entry));
gtk_text_set_point(GTK_TEXT(sp->text_entry), 0);
gtk_text_forward_delete(GTK_TEXT(sp->text_entry), len);
gtk_text_thaw(GTK_TEXT(sp->text_entry));
}
*uncommitted = ucm;
}
/**
* TBD
*/
static void set_strategy( void ) {
GtkWidget *btn = NULL;
switch ( config.strategy ) {
case STRATEGY1:
btn = radiobtn_strategy_1;
break;
case STRATEGY2:
btn = radiobtn_strategy_2;
break;
case STRATEGY3:
btn = radiobtn_strategy_3;
break;
case STRATEGY4:
btn = radiobtn_strategy_4;
break;
case STRATEGY5:
btn = radiobtn_strategy_5;
break;
}
gtk_toggle_button_set_state( GTK_TOGGLE_BUTTON( btn ), TRUE );
} // set_strategy
/**
* TBD
*/
static void set_level( void ) {
GtkWidget *btn = NULL;
switch ( config.level ) {
case LEVEL1:
btn = radiobtn_level_1;
break;
case LEVEL2:
btn = radiobtn_level_2;
break;
case LEVEL3:
btn = radiobtn_level_3;
break;
case LEVEL4:
btn = radiobtn_level_4;
break;
case LEVEL5:
btn = radiobtn_level_5;
break;
}
gtk_toggle_button_set_state( GTK_TOGGLE_BUTTON( btn ), TRUE );
} // set_level
GtkWidget*
get_viewer_toolbar(GtkWidget *parent)
{
GtkWidget *toolbar, *pixmap_wid, *button;
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
gboolean fit_screen;
style = gtk_widget_get_style(parent);
toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS);
gtk_tooltips_set_colors(
GTK_TOOLBAR(toolbar)->tooltips,
get_viewer_tooltips_bgcolor(parent->window, gdk_window_get_colormap(parent->window)),
&style->fg[GTK_STATE_NORMAL]);
gtk_tooltips_set_delay(GTK_TOOLBAR(toolbar)->tooltips, 100);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)browse_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Browse"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_browse),
NULL);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)fullscreen_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Full screen"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_full_screen),
NULL);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)save_image_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
saveimage_button = gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Save Image"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_save_image),
NULL);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)prev_image_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
prev_button = gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Previous Image"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_prev_image),
NULL);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)next_image_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
next_button = gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Next Image"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_next_image),
NULL);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)slideshow_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
slideshow_button = gtk_toolbar_append_element(
GTK_TOOLBAR(toolbar),
GTK_TOOLBAR_CHILD_TOGGLEBUTTON,
NULL,
NULL,
_("Stop/Resume Slideshow"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_slideshow_toggled),
NULL);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)refresh_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Refresh"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_refresh),
NULL);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)screen_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
button = gtk_toolbar_append_element(
GTK_TOOLBAR(toolbar),
GTK_TOOLBAR_CHILD_TOGGLEBUTTON,
NULL,
NULL,
_("Fit Screen"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_fitscreen_toggled),
NULL);
fit_screen = rc_get_boolean("fit_screen");
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), fit_screen);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)rotate_left_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL,
_("Rotate -90"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_rotate),
(gint *) LEFT);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)rotate_right_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL,
_("Rotate +90"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_rotate),
(gint *) RIGHT);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)right_left_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL,
_("Reflect Right/Left"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_reflect),
(gint *) RIGHTLEFT);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)up_down_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL,
_("Reflect Up/Down"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_reflect),
(gint *) UPDOWN);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)exit_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL,
_("Exit"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(close_gtksee),
NULL);
return toolbar;
}
void
viewer_slideshow_set_state(gboolean e)
{
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(slideshow_button), e);
}
GtkWidget* envelope_box_new(const gchar *label)
{
EnvelopeBox *e;
GtkWidget *box2, *thing, *box3, *box4;
e = gtk_type_new(envelope_box_get_type());
GTK_BOX(e)->spacing = 2;
GTK_BOX(e)->homogeneous = FALSE;
box2 = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(e), box2, FALSE, TRUE, 0);
gtk_widget_show(box2);
thing = gtk_check_button_new_with_label(label);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(thing), 0);
gtk_box_pack_start(GTK_BOX(box2), thing, FALSE, TRUE, 0);
gtk_widget_show(thing);
gtk_signal_connect(GTK_OBJECT(thing), "toggled",
GTK_SIGNAL_FUNC(handle_toggle_button), e);
e->enable = GTK_TOGGLE_BUTTON(thing);
add_empty_hbox(box2);
box2 = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(e), box2, FALSE, TRUE, 0);
gtk_widget_show(box2);
/* Numerical list editing fields */
box3 = gtk_vbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(box2), box3, FALSE, TRUE, 0);
gtk_widget_show(box3);
put_labelled_spin_button(box3, "Env length", 1, 12, &e->spin_length, spin_length_changed, e);
put_labelled_spin_button(box3, "Current pos", 0, 11, &e->spin_pos, spin_pos_changed, e);
put_labelled_spin_button(box3, "Offset", 0, 65535, &e->spin_offset, spin_offset_changed, e);
put_labelled_spin_button(box3, "Value", 0, 64, &e->spin_value, spin_value_changed, e);
box4 = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start(GTK_BOX(box3), box4, FALSE, TRUE, 0);
gtk_widget_show(box4);
thing = gtk_button_new_with_label("Insert");
gtk_box_pack_start(GTK_BOX(box4), thing, TRUE, TRUE, 0);
gtk_widget_show(thing);
gtk_signal_connect(GTK_OBJECT(thing), "clicked",
GTK_SIGNAL_FUNC(insert_clicked), e);
thing = gtk_button_new_with_label("Delete");
gtk_box_pack_start(GTK_BOX(box4), thing, TRUE, TRUE, 0);
gtk_widget_show(thing);
gtk_signal_connect(GTK_OBJECT(thing), "clicked",
GTK_SIGNAL_FUNC(delete_clicked), e);
thing = gtk_vseparator_new();
gtk_box_pack_start(GTK_BOX(box2), thing, FALSE, TRUE, 0);
gtk_widget_show(thing);
#if 0
/* Graphical editing stuff to be inserted here */
thing = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(box2), thing, TRUE, TRUE, 0);
gtk_widget_show(thing);
thing = gtk_vseparator_new();
gtk_box_pack_start(GTK_BOX(box2), thing, FALSE, TRUE, 0);
gtk_widget_show(thing);
#endif
/* Sustain / Loop widgets */
box3 = gtk_vbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(box2), box3, FALSE, TRUE, 0);
gtk_widget_show(box3);
thing = gtk_check_button_new_with_label("Sustain");
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(thing), 0);
gtk_box_pack_start(GTK_BOX(box3), thing, FALSE, TRUE, 0);
gtk_widget_show(thing);
gtk_signal_connect(GTK_OBJECT(thing), "toggled",
GTK_SIGNAL_FUNC(handle_toggle_button), e);
e->sustain = GTK_TOGGLE_BUTTON(thing);
put_labelled_spin_button(box3, "Point", 0, 11, &e->spin_sustain, handle_spin_button, e);
thing = gtk_check_button_new_with_label("Loop");
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(thing), 0);
gtk_box_pack_start(GTK_BOX(box3), thing, FALSE, TRUE, 0);
gtk_widget_show(thing);
gtk_signal_connect(GTK_OBJECT(thing), "toggled",
GTK_SIGNAL_FUNC(handle_toggle_button), e);
e->loop = GTK_TOGGLE_BUTTON(thing);
put_labelled_spin_button(box3, "Start", 0, 11, &e->spin_loop_start, handle_spin_button, e);
put_labelled_spin_button(box3, "End", 0, 11, &e->spin_loop_end, handle_spin_button, e);
return GTK_WIDGET(e);
}
/*!
\brief personality_choice() is called from a one shot timeout from main
in order to open the window to ask the user what ECU family to deal with
running.
*/
G_MODULE_EXPORT gboolean personality_choice(void)
{
GtkWidget *dialog = NULL;
GtkWidget *vbox = NULL;
GtkWidget *hbox = NULL;
GtkWidget *ebox = NULL;
GtkWidget *sep = NULL;
GtkWidget *button = NULL;
GtkWidget *label = NULL;
gchar ** dirs = NULL;
gchar * filename = NULL;
PersonaElement *element = NULL;
gchar *tmpbuf = NULL;
gboolean shouldjump = FALSE;
gchar *name = NULL;
GArray *classes = NULL;
GSList *group = NULL;
GList *p_list = NULL;
GList *s_list = NULL;
ConfigFile *cfgfile = NULL;
guint i = 0;
gint result = 0;
gchar * pathstub = NULL;
extern gconstpointer *global_data;
pathstub = g_build_filename(INTERROGATOR_DATA_DIR,"Profiles",NULL);
dirs = get_dirs((const gchar *)DATA_GET(global_data,"project_name"),pathstub,&classes);
if (!dirs)
{
MTXDBG(CRITICAL,_("NO Interrogation profiles found, was MegaTunix installed properly?\n"));
return FALSE;
}
i = 0;
while (dirs[i])
{
tmpbuf = g_build_filename(dirs[i],"details.cfg",NULL);
cfgfile = cfg_open_file(tmpbuf);
if (!cfgfile)
{
/*MTXDBG(CRITICAL,_("\"%s\" file missing!, was MegaTunix installed properly?\n"),tmpbuf);*/
i++;
g_free(tmpbuf);
continue;
}
g_free(tmpbuf);
element = g_new0(PersonaElement, 1);
cfg_read_string(cfgfile,"Family","sequence",&element->sequence);
cfg_read_string(cfgfile,"Family","friendly_name",&element->name);
cfg_read_string(cfgfile,"Family","persona",&element->persona);
cfg_read_string(cfgfile,"Family","ecu_lib",&element->ecu_lib);
cfg_read_string(cfgfile,"Family","common_lib",&element->common_lib);
if (!cfg_read_string(cfgfile,"Family","baud",&element->baud_str))
MTXDBG(CRITICAL,_("\"details.cfg\" baud string undefined!, was MegaTunix installed properly?\n"));
element->dirname = g_strdup(dirs[i]);
element->filename = g_path_get_basename(dirs[i]);
if (g_strcasecmp(element->filename,(gchar *)DATA_GET(global_data,"last_ecu_family")) == 0)
element->def = TRUE;
if ((DATA_GET(global_data,"cli_persona")) && (element->persona))
{
if (g_strcasecmp(element->persona, (gchar *)DATA_GET(global_data,"cli_persona")) == 0)
{
button = gtk_toggle_button_new();
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button),TRUE);
persona_selection(button,(gpointer)element);
g_object_ref_sink(button);
g_object_unref(button);
shouldjump = TRUE;
}
}
if (g_array_index(classes,FileClass,i) == PERSONAL)
p_list = g_list_prepend(p_list,(gpointer)element);
if (g_array_index(classes,FileClass,i) == SYSTEM)
s_list = g_list_prepend(s_list,(gpointer)element);
g_free(name);
i++;
cfg_free(cfgfile);
}
p_list = g_list_sort(p_list,persona_seq_sort);
s_list = g_list_sort(s_list,persona_seq_sort);
g_strfreev(dirs);
g_array_free(classes,TRUE);
if (shouldjump)
{
g_list_foreach(p_list,free_persona_element,NULL);
g_list_foreach(s_list,free_persona_element,NULL);
g_list_free(p_list);
g_list_free(s_list);
DATA_SET(global_data,"cli_persona",NULL);
if (DATA_GET(global_data,"offline"))
goto jumpahead_offline;
else
goto jumpahead;
}
set_title(g_strdup(_("Choose an ECU family?")));
update_logbar("interr_view","warning",_("Prompting user for ECU family to interrogate...\n"),FALSE,FALSE,FALSE);
dialog = gtk_dialog_new_with_buttons("Select ECU Personality",
GTK_WINDOW(lookup_widget("main_window")),
GTK_DIALOG_DESTROY_WITH_PARENT,
"Exit MegaTunix",
GTK_RESPONSE_CLOSE,
"Go Offline",
GTK_RESPONSE_CANCEL,
"Find my ECU",
GTK_RESPONSE_OK,
NULL);
vbox = gtk_vbox_new(TRUE,2);
gtk_container_set_border_width(GTK_CONTAINER(vbox),5);
//gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),vbox,TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),vbox,TRUE,TRUE,0);
if (g_list_length(p_list) > 0)
{
label = gtk_label_new("Custom (personal) Profiles");
gtk_box_pack_start(GTK_BOX(vbox),label,TRUE,TRUE,0);
group = NULL;
/* Cycle list for PERSONAL profile files */
for (i=0;i<g_list_length(p_list);i++)
{
element = (PersonaElement *)g_list_nth_data(p_list,i);
ebox = gtk_event_box_new();
gtk_box_pack_start(GTK_BOX(vbox),ebox,TRUE,TRUE,0);
hbox = gtk_hbox_new(FALSE,10);
gtk_container_add(GTK_CONTAINER(ebox),hbox);
label = gtk_label_new(element->name);
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,TRUE,0);
if (!check_for_files (element->dirname,"prof"))
{
gtk_widget_set_sensitive(ebox,FALSE);
button = gtk_radio_button_new(NULL);
}
else
{
button = gtk_radio_button_new(group);
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(button));
}
g_signal_connect(button,
"toggled",
G_CALLBACK(persona_selection),
element);
gtk_box_pack_end(GTK_BOX(hbox),button,FALSE,TRUE,0);
if (element->def)
{
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button),TRUE);
gtk_toggle_button_toggled(GTK_TOGGLE_BUTTON(button));
}
}
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox),sep,TRUE,TRUE,0);
}
label = gtk_label_new("System Wide ECU Profiles");
gtk_box_pack_start(GTK_BOX(vbox),label,TRUE,TRUE,0);
/* Cycle list for System interogation files */
for (i=0;i<g_list_length(s_list);i++)
{
element = (PersonaElement *)g_list_nth_data(s_list,i);
ebox = gtk_event_box_new();
gtk_box_pack_start(GTK_BOX(vbox),ebox,TRUE,TRUE,0);
hbox = gtk_hbox_new(FALSE,10);
gtk_container_add(GTK_CONTAINER(ebox),hbox);
label = gtk_label_new(element->name);
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,TRUE,0);
if (!check_for_files (element->dirname,"prof"))
{
gtk_widget_set_sensitive(ebox,FALSE);
button = gtk_radio_button_new(NULL);
}
else
{
button = gtk_radio_button_new(group);
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(button));
}
g_signal_connect(button,
"toggled",
G_CALLBACK(persona_selection),
element);
gtk_box_pack_end(GTK_BOX(hbox),button,FALSE,TRUE,0);
if (element->def)
{
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button),TRUE);
gtk_toggle_button_toggled(GTK_TOGGLE_BUTTON(button));
}
}
gtk_widget_show_all(dialog);
result = gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
g_list_foreach(p_list,free_persona_element,NULL);
g_list_foreach(s_list,free_persona_element,NULL);
g_list_free(p_list);
g_list_free(s_list);
switch (result)
{
case GTK_RESPONSE_CLOSE:
leave(NULL,NULL);
break;
case GTK_RESPONSE_ACCEPT:
case GTK_RESPONSE_OK: /* Normal mode */
jumpahead:
plugins_init();
pathstub = g_build_filename(INTERROGATOR_DATA_DIR,"Profiles",DATA_GET(global_data,"ecu_family"),"comm.xml",NULL);
filename = get_file((const gchar *)DATA_GET(global_data,"project_name"),pathstub,NULL);
g_free(pathstub);
load_comm_xml(filename);
g_free(filename);
io_cmd("interrogation",NULL);
break;
default: /* Offline */
jumpahead_offline:
plugins_init();
pathstub = g_build_filename(INTERROGATOR_DATA_DIR,"Profiles",DATA_GET(global_data,"ecu_family"),"comm.xml",NULL);
filename = get_file((const gchar *)DATA_GET(global_data,"project_name"),pathstub,NULL);
g_free(pathstub);
load_comm_xml(filename);
g_free(filename);
g_timeout_add(100,(GSourceFunc)set_offline_mode,NULL);
return FALSE;
}
return FALSE;
}
/*!
\brief shows the tabe visibility chooser window
\param widget is the widget clicked to get this to come up
\param data is unused
\return TRUE on success
*/
G_MODULE_EXPORT gboolean show_tab_visibility_window(GtkWidget * widget, gpointer data)
{
GladeXML *main_xml = NULL;
GladeXML *xml = NULL;
GtkWidget *vbox = NULL;
GtkWidget *notebook = NULL;
GtkWidget *table = NULL;
GtkWidget *child = NULL;
GtkWidget *label = NULL;
GtkWidget *button = NULL;
gboolean *hidden_list = NULL;
if (!(GTK_IS_WIDGET(vis_window)))
{
main_xml = (GladeXML *)DATA_GET(global_data,"main_xml");
if (!main_xml)
return FALSE;
notebook = glade_xml_get_widget(main_xml,"toplevel_notebook");
hidden_list = (gboolean *)DATA_GET(global_data,"hidden_list");
xml = glade_xml_new(main_xml->filename,"tab_visibility_top_vbox",NULL);
vis_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_transient_for(GTK_WINDOW(vis_window),GTK_WINDOW(lookup_widget("main_window")));
gtk_window_set_title(GTK_WINDOW(vis_window),_("Tab Visibility"));
gtk_window_set_default_size(GTK_WINDOW(vis_window),200,300);
g_signal_connect(G_OBJECT(vis_window),"delete_event",
G_CALLBACK(gtk_widget_hide),vis_window);
vbox = glade_xml_get_widget(xml,"tab_visibility_top_vbox");
if (GTK_IS_WIDGET(vbox))
gtk_container_add(GTK_CONTAINER(vis_window),vbox);
else
printf(_("ERROR, glade element not found!\n"));
gint rows = gtk_notebook_get_n_pages(GTK_NOTEBOOK(notebook));
DATA_SET(global_data,"notebook_rows",GINT_TO_POINTER(rows));
table = glade_xml_get_widget(xml,"tab_visibility_table");
gtk_table_resize(GTK_TABLE(table),rows,2);
for (gint i=0;i<rows;i++)
{
child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),i);
button = gtk_check_button_new();
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button),hidden_list[i]);
g_signal_connect(G_OBJECT(button),"toggled",
G_CALLBACK(hide_tab),
GINT_TO_POINTER(i));
gtk_table_attach_defaults(GTK_TABLE(table),button,
0,1,i+1,i+2);
label = gtk_label_new(gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook),child));
gtk_table_attach_defaults(GTK_TABLE(table),label,
1,2,i+1,i+2);
}
}
gtk_widget_show_all(vis_window);
return TRUE;
}
GtkWidget *atonal_if_new(atonal * mod)
{
AtonalIF *atonal_if;
GtkWidget *vbox2, *hbox;
GtkWidget *button;
GtkWidget *slider;
gint i;
gchar buf[4];
atonal_if = gtk_type_new(atonal_if_get_type());
modulewindow_set_module (MODULEWINDOW(atonal_if), (module *)mod);
#if 0
button = gtk_button_new_with_label("Clear");
gtk_box_pack_start(GTK_BOX(hbox2), button, TRUE, TRUE, 1);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(at_clear_cb), atonal_if);
gtk_widget_show(button);
button = gtk_button_new_with_label("Chaos");
gtk_box_pack_start(GTK_BOX(hbox2), button, TRUE, TRUE, 1);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(at_chaos_cb), atonal_if);
gtk_widget_show(button);
#endif
/* S E Q U E N C E */
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(MODULEWINDOW(atonal_if)->mainbox), hbox, TRUE, TRUE, 1);
gtk_widget_show(hbox);
#if 0
button = gtk_label_new("Triggers:");
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 3);
gtk_widget_show(button);
#endif
#if 0
slider = slider_int_new("", &(mod->vol), 0, 64, 0);
gtk_box_pack_start(GTK_BOX(hbox), slider, FALSE, FALSE, 0);
gtk_widget_show(slider);
#endif
for (i = 0; i < AT_LENGTH; i++) {
if (i && i % 4 == 0) {
button = gtk_vseparator_new();
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE,
FALSE, 3);
gtk_widget_show(button);
}
vbox2 = gtk_vbox_new(FALSE, 1);
gtk_box_pack_start(GTK_BOX(hbox), vbox2, TRUE, TRUE, 0);
gtk_widget_show(vbox2);
snprintf(buf, 4, "%d", i);
slider =
slider_int_new(buf,
&(mod->sequence[i].note),
110, 660, 1);
gtk_box_pack_start(GTK_BOX(vbox2), slider, TRUE, TRUE, 0);
gtk_widget_show(slider);
button = gtk_toggle_button_new();
gtk_box_pack_start(GTK_BOX(vbox2), button, FALSE, FALSE,
1);
gtk_widget_set_usize(button, 10, 10);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button),
(mod->sequence[i].
trigger == 1));
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(atonal_if_set_note_cb),
atonal_if);
gtk_widget_show(button);
atonal_if->buttons[i].button = button;
}
/*
button = outputlabel_new((module *)mod, j);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 1);
gtk_widget_show(button);
*/
return GTK_WIDGET(atonal_if);
}
void SoftDlgProc(void)
{
char Text[32];
ReadConfig();
ConfDlg = create_Config();
#ifdef _SDL
gtk_window_set_title(GTK_WINDOW(ConfDlg), "Configure the P.E.Op.S. PSX SDL Soft Renderer...");
#endif
FullBtn = lookup_widget(ConfDlg, "GtkRadioButton_Fullscreen");
WinBtn = lookup_widget(ConfDlg, "GtkRadioButton_Windowed");
EditW = lookup_widget(ConfDlg, "GtkEntry_Width");
EditH = lookup_widget(ConfDlg, "GtkEntry_Height");
EditF = lookup_widget(ConfDlg, "GtkEntry_FPS");
StretchComboModes = lookup_widget(ConfDlg, "GtkCombo_Stretching");
DitherComboModes = lookup_widget(ConfDlg, "GtkCombo_Dithering");
ShowFpsBtn = lookup_widget(ConfDlg, "GtkCheckButton_FPSdisplay");
FpsLimitBtn = lookup_widget(ConfDlg, "GtkCheckButton_FPSlimit");
FrameSkipBtn = lookup_widget(ConfDlg, "GtkCheckButton_FPSskip");
SSSPSXLimitBtn = lookup_widget(ConfDlg, "GtkCheckButton_SSSPSXLimit");
AutoFpsBtn = lookup_widget(ConfDlg, "GtkCheckButton_FPSauto");
ScanLinesBtn = lookup_widget(ConfDlg, "GtkCheckButton_Scanlines");
FixesBtn = lookup_widget(ConfDlg, "GtkCheckButton_Fixes");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(FullBtn), iWindowMode != 1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(WinBtn), iWindowMode != 0);
Modes = NULL;
#if !defined(_SDL) && defined(USE_XF86VM)
{
Display *display;
int myscreen;
// Open display
display=XOpenDisplay(NULL);
if (display)
{
int nmodes,iC;
myscreen=DefaultScreen(display);
XF86VidModeGetAllModeLines(display,myscreen, // -> enum all mode infos
&nmodes,&modes);
if (modes) // -> infos got?
{
for (iC=0;iC<nmodes;++iC) // -> loop modes
{
sprintf(modesl[iC], "%dx%d", modes[iC]->hdisplay, modes[iC]->vdisplay);
Modes = g_list_append(Modes, modesl[iC]);
}
}
}
}
#else
Modes = g_list_append(Modes, "320x240");
Modes = g_list_append(Modes, "640x480");
Modes = g_list_append(Modes, "800x600");
Modes = g_list_append(Modes, "1024x768");
#endif
ComboModes = lookup_widget(ConfDlg, "GtkCombo_Modes");
gtk_combo_set_popdown_strings(GTK_COMBO(ComboModes), Modes);
if (!iWindowMode)
{
sprintf (Text, "%dx%d", iResX, iResY);
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(ComboModes)->entry), Text);
}
sprintf(Text,"%d", iResX);
gtk_entry_set_text(GTK_ENTRY(EditW), Text);
sprintf(Text,"%d", iResY);
gtk_entry_set_text(GTK_ENTRY(EditH), Text);
/////////
SModes = NULL;
SModes = g_list_append(SModes, (char *)&szStretchModes[0][0]);
SModes = g_list_append(SModes, (char *)&szStretchModes[1][0]);
SModes = g_list_append(SModes, (char *)&szStretchModes[2][0]);
SModes = g_list_append(SModes, (char *)&szStretchModes[3][0]);
SModes = g_list_append(SModes, (char *)&szStretchModes[4][0]);
SModes = g_list_append(SModes, (char *)&szStretchModes[5][0]);
SModes = g_list_append(SModes, (char *)&szStretchModes[6][0]);
SModes = g_list_append(SModes, (char *)&szStretchModes[7][0]);
SModes = g_list_append(SModes, (char *)&szStretchModes[8][0]);
SModes = g_list_append(SModes, (char *)&szStretchModes[9][0]);
SModes = g_list_append(SModes, (char *)&szStretchModes[10][0]);
SModes = g_list_append(SModes, (char *)&szStretchModes[11][0]);
SModes = g_list_append(SModes, (char *)&szStretchModes[12][0]);
SModes = g_list_append(SModes, (char *)&szStretchModes[13][0]);
SModes = g_list_append(SModes, (char *)&szStretchModes[14][0]);
SModes = g_list_append(SModes, (char *)&szStretchModes[15][0]);
gtk_combo_set_popdown_strings(GTK_COMBO(StretchComboModes), SModes);
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(StretchComboModes)->entry), (char *)&szStretchModes[iUseNoStretchBlt][0]);
DModes = NULL;
DModes = g_list_append(DModes, (char *)&szDitherModes[0][0]);
DModes = g_list_append(DModes, (char *)&szDitherModes[1][0]);
DModes = g_list_append(DModes, (char *)&szDitherModes[2][0]);
gtk_combo_set_popdown_strings(GTK_COMBO(DitherComboModes), DModes);
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(DitherComboModes)->entry), (char *)&szDitherModes[iUseDither][0]);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(ShowFpsBtn), iShowFPS);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(FpsLimitBtn), UseFrameLimit);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(SSSPSXLimitBtn), bSSSPSXLimit);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(FrameSkipBtn), UseFrameSkip);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(AutoFpsBtn), iFrameLimit-1);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(ScanLinesBtn), iUseScanLines);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(FixesBtn), iUseFixes);
sprintf(Text,"%.1f", fFrameRate);
gtk_entry_set_text(GTK_ENTRY(EditF), Text);
gtk_widget_show_all(ConfDlg);
gtk_main ();
}
void philips_cfg_page2 ( GtkWidget *notebook, struct P_CONFIG_CONTROLS *controls, PhilipsCfgInfo *pcfginfo )
{
GtkWidget *frame;
GtkWidget *label;
GtkWidget *box, *vbox;
GSList *group;
vbox = gtk_hbox_new ( FALSE, 5 );
frame = gtk_frame_new ( "Resolution" );
gtk_container_border_width ( GTK_CONTAINER(frame), 10 );
gtk_widget_set_usize ( frame, 130, 75 );
gtk_widget_show ( frame );
box = gtk_vbox_new ( FALSE, 5 );
if ( cameraid != 5000 ) {
controls->res_640 = gtk_radio_button_new_with_label ( NULL, "640 x 480" );
gtk_box_pack_start ( GTK_BOX(box), controls->res_640, FALSE, FALSE, 0 );
if ( pcfginfo->resolution == 1 )
gtk_toggle_button_set_state ( GTK_TOGGLE_BUTTON(controls->res_640), TRUE );
gtk_widget_show ( controls->res_640 );
group = gtk_radio_button_group ( GTK_RADIO_BUTTON(controls->res_640) );
}
if ( cameraid >= 4000 && cameraid != 5000 ) {
controls->res_1280 = gtk_radio_button_new_with_label ( group, "1280 x 960" );
gtk_box_pack_start ( GTK_BOX(box), controls->res_1280, FALSE, FALSE, 0 );
if ( pcfginfo->resolution == 4 )
gtk_toggle_button_set_state ( GTK_TOGGLE_BUTTON(controls->res_640), TRUE );
gtk_widget_show ( controls->res_1280 );
group = gtk_radio_button_group ( GTK_RADIO_BUTTON(controls->res_1280) );
}
if ( cameraid == 5000 ) {
controls->res_900 = gtk_radio_button_new_with_label ( NULL, "900 x 600" );
gtk_box_pack_start ( GTK_BOX(box), controls->res_900, FALSE, FALSE, 0 );
if ( pcfginfo->resolution == 5 )
gtk_toggle_button_set_state ( GTK_TOGGLE_BUTTON(controls->res_900), TRUE );
gtk_widget_show ( controls->res_900 );
group = gtk_radio_button_group ( GTK_RADIO_BUTTON(controls->res_900) );
controls->res_1800 = gtk_radio_button_new_with_label ( NULL, "1800 x 900" );
gtk_box_pack_start ( GTK_BOX(box), controls->res_1800, FALSE, FALSE, 0 );
if ( pcfginfo->resolution == 6 )
gtk_toggle_button_set_state ( GTK_TOGGLE_BUTTON(controls->res_1800), TRUE );
gtk_widget_show ( controls->res_1800 );
group = gtk_radio_button_group ( GTK_RADIO_BUTTON(controls->res_1800) );
}
gtk_container_add ( GTK_CONTAINER(frame), box );
gtk_widget_show ( box );
gtk_box_pack_start ( GTK_BOX(vbox), frame, FALSE, FALSE, 0 );
gtk_widget_show ( vbox );
frame = gtk_frame_new ( "Quality" );
gtk_container_border_width ( GTK_CONTAINER(frame), 10 );
gtk_widget_set_usize ( frame, 130, 75 );
gtk_widget_show ( frame );
box = gtk_vbox_new ( FALSE, 5 );
controls->q_fine = gtk_radio_button_new_with_label ( NULL, "Fine" );
gtk_box_pack_start ( GTK_BOX(box), controls->q_fine, FALSE, FALSE, 0 );
gtk_widget_show ( controls->q_fine );
group = gtk_radio_button_group ( GTK_RADIO_BUTTON(controls->q_fine) );
controls->q_normal = gtk_radio_button_new_with_label ( group, "Normal" );
gtk_box_pack_start ( GTK_BOX(box), controls->q_normal, FALSE, FALSE, 0 );
gtk_widget_show ( controls->q_normal );
group = gtk_radio_button_group ( GTK_RADIO_BUTTON(controls->q_normal) );
controls->q_economy = gtk_radio_button_new_with_label ( group, "Economy" );
gtk_box_pack_start ( GTK_BOX(box), controls->q_economy, FALSE, FALSE, 0 );
gtk_widget_show ( controls->q_economy );
group = gtk_radio_button_group ( GTK_RADIO_BUTTON(controls->q_economy) );
gtk_container_add ( GTK_CONTAINER(frame), box );
gtk_widget_show ( box );
gtk_box_pack_start ( GTK_BOX(vbox), frame, FALSE, FALSE, 0 );
label = gtk_label_new ( "Image Quality" );
gtk_notebook_append_page ( GTK_NOTEBOOK(notebook), vbox, label );
}
void update_general_controls()
{
gfloat tmp1 = 0.0;
GtkWidget * widget = NULL;
MtxGaugeFace *g = NULL;
GdkColor color;
if (GTK_IS_WIDGET(gauge))
g = MTX_GAUGE_FACE(gauge);
else
return;
if (!toplevel)
return;
hold_handlers = TRUE;
mtx_gauge_face_get_attribute(g,ROTATION,&tmp1);
if (tmp1 == MTX_ROT_CW)
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"cw_rbutton"));
else if (tmp1 == MTX_ROT_CCW)
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"ccw_rbutton"));
else
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"cw_rbutton"));
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(widget),TRUE);
mtx_gauge_face_get_attribute(g,ANTIALIAS,&tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"antialiased_check"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),(gint)tmp1);
mtx_gauge_face_get_attribute(g,TATTLETALE,&tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"tattletale_check"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),(gint)tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"tattletale_alpha_spin"));
mtx_gauge_face_get_attribute(g,TATTLETALE_ALPHA,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_length_spin"));
mtx_gauge_face_get_attribute(g,NEEDLE_LENGTH,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_width_spin"));
mtx_gauge_face_get_attribute(g,NEEDLE_WIDTH,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_tip_width_spin"));
mtx_gauge_face_get_attribute(g,NEEDLE_TIP_WIDTH,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_tail_width_spin"));
mtx_gauge_face_get_attribute(g,NEEDLE_TAIL_WIDTH,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_tail_spin"));
mtx_gauge_face_get_attribute(g,NEEDLE_TAIL,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"start_angle_spin"));
mtx_gauge_face_get_attribute(g,START_ANGLE,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"sweep_angle_spin"));
mtx_gauge_face_get_attribute(g,SWEEP_ANGLE,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"lbound_spin"));
mtx_gauge_face_get_attribute(g,LBOUND,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"ubound_spin"));
mtx_gauge_face_get_attribute(g,UBOUND,&tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"background_color_day_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_BG_DAY, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"background_color_nite_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_BG_NITE, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_color_day_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_NEEDLE_DAY, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_color_nite_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_NEEDLE_NITE, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"gradient_begin_color_day_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_GRADIENT_BEGIN_DAY, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"gradient_begin_color_nite_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_GRADIENT_BEGIN_NITE, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"gradient_end_color_day_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_GRADIENT_END_DAY, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"gradient_end_color_nite_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_GRADIENT_END_NITE, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"daytime_radiobutton"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),mtx_gauge_face_get_daytime_mode(g));
hold_handlers = FALSE;
}
static gint
sobel_dialog ()
{
GtkWidget *dlg;
GtkWidget *button;
GtkWidget *toggle;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *hbox;
gchar **argv;
gint argc;
argc = 1;
argv = g_new (gchar *, 1);
argv[0] = g_strdup ("sobel");
gtk_init (&argc, &argv);
gtk_rc_parse (gimp_gtkrc ());
dlg = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dlg), _("Sobel Edge Detection"));
gtk_window_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
(GtkSignalFunc) sobel_close_callback,
NULL);
/* Action area */
button = gtk_button_new_with_label (_("OK"));
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) sobel_ok_callback,
dlg);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->action_area), button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_button_new_with_label (_("Cancel"));
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT (dlg));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->action_area), button, TRUE, TRUE, 0);
gtk_widget_show (button);
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 10);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (vbox), 10);
gtk_container_add (GTK_CONTAINER (frame), vbox);
toggle = gtk_check_button_new_with_label (_("Sobel Horizontally"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) sobel_toggle_update,
&bvals.horizontal);
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (toggle), bvals.horizontal);
gtk_widget_show (toggle);
toggle = gtk_check_button_new_with_label (_("Sobel Vertically"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) sobel_toggle_update,
&bvals.vertical);
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (toggle), bvals.vertical);
gtk_widget_show (toggle);
toggle = gtk_check_button_new_with_label (_("Keep sign of result (one direction only)"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) sobel_toggle_update,
&bvals.keep_sign);
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (toggle), bvals.vertical);
gtk_widget_show (toggle);
hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
gtk_widget_show (vbox);
gtk_widget_show (frame);
gtk_widget_show (dlg);
gtk_main ();
gdk_flush ();
return bint.run;
}
static void showif_handler_foreach_callback(gpointer data, gpointer user_data)
{
// Context: The current property box control item we're checking against
// to see if this is the context belonging to the control that changed
struct gui_generate_option_controls_context *context = (struct gui_generate_option_controls_context *)data;
// showif_foreach_data: control that changed and related option set
struct showif_handler_foreach_callback_data *showif_foreach_data = (struct showif_handler_foreach_callback_data *)user_data;
// Don't check check_control against itself, and only proceed
// if this control is referencing the check control's ID
if( (context->widget != showif_foreach_data->changed_control) &&
(context->option_list->showif_id != NULL) &&
(!strcasecmp(showif_foreach_data->changed_control_option->id, context->option_list->showif_id)) )
{
gboolean vis_current, vis_target;
// At this point, we know that "check_control" references the id of
// "changed_control", now we just need to see if the value matches;
// if so, we show the control, otherwise we must hide it...
GtkWidget *changed_control = showif_foreach_data->changed_control;
// Get value of control we're checking
unsigned char value = 0;
if(GTK_IS_COMBO_BOX(changed_control))
value = (unsigned char)gui_combobox_simple_get_index(changed_control);
else if(GTK_IS_SPIN_BUTTON(changed_control))
value = (unsigned char)gtk_spin_button_get_value(GTK_SPIN_BUTTON(changed_control));
else if(GTK_IS_TOGGLE_BUTTON(changed_control))
value = (unsigned char)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(changed_control)) ? 1 : 0;
vis_current = gtk_widget_get_visible(context->widget);
vis_target = (value == context->option_list->showif_val);
// Only do anything if visibility is changing
if(vis_current != vis_target)
{
GtkWidget *target_widget = context->widget;
gtk_widget_set_visible(context->label, vis_target);
gtk_widget_set_visible(target_widget, vis_target);
// If control is becoming visible but previously was not,
// set to minimum value because we can't be sure if the
// current value in the mask is valid on switch and
// probably wouldn't be useful even if it was...
if(vis_target)
{
if(GTK_IS_COMBO_BOX(target_widget))
gui_combobox_simple_set_selected(target_widget, context->option_list->options[0].value);
else if(GTK_IS_SPIN_BUTTON(target_widget))
gtk_spin_button_set_value(GTK_SPIN_BUTTON(target_widget), 0);
else if(GTK_IS_TOGGLE_BUTTON(target_widget))
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(target_widget), 0);
// Force change signal just in case the above doesn't actually change it
g_signal_emit_by_name(target_widget, context->widget_signal_name, context->widget_signal_data);
}
}
}
}
gint
save_dialog ( ImageInfo *info)
{
GtkWidget *dlg;
GtkWidget *toggle;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *frame;
GtkWidget *toggle_vbox;
GSList *group;
gint use_none = (info->save_vals.compression == COMPRESSION_NONE);
gint use_lzw = (info->save_vals.compression == COMPRESSION_LZW);
gint use_packbits = (info->save_vals.compression == COMPRESSION_PACKBITS);
gint use_deflate = (info->save_vals.compression == COMPRESSION_DEFLATE);
gint use_sgilog = (info->save_vals.compression == COMPRESSION_SGILOG);
gint use_pixarlog = (info->save_vals.compression == COMPRESSION_PIXARLOG);
gint use_jpeg = (info->save_vals.compression == COMPRESSION_JPEG);
gint use_jp2000 = (info->save_vals.compression == COMPRESSION_JP2000);
gint use_adobe = (info->save_vals.compression == COMPRESSION_ADOBE_DEFLATE);
gint use_lsb2msb = (info->save_vals.fillorder == FILLORDER_LSB2MSB);
gint use_msb2lsb = (info->save_vals.fillorder == FILLORDER_MSB2LSB);
gint use_sep_planar = (info->planar == PLANARCONFIG_SEPARATE);
gint use_premultiply =(info->save_vals.premultiply == EXTRASAMPLE_ASSOCALPHA);
gint use_notpremultiply = (info->save_vals.premultiply == EXTRASAMPLE_UNASSALPHA
|| info->save_vals.premultiply == EXTRASAMPLE_UNSPECIFIED );
gint use_icc_profile = (info->save_vals.use_icc_profile == TRUE);
gint use_no_icc = (info->save_vals.use_icc_profile == FALSE);
long dircount;
gchar text[256];
gimp_ui_init ("save", TRUE);
dlg = gimp_dialog_new (_("Save as Tiff"), "save",
gimp_standard_help_func, "filters/tiff.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
_("OK"), ok_callback,
NULL, NULL, NULL, TRUE, FALSE,
_("Cancel"), cancel_callback,
NULL, 1, NULL, FALSE, TRUE,
NULL);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
(GtkSignalFunc) close_callback,
NULL);
/* attach profile */
//LIST_FRAME (_("ICC Profile data"))
frame = gtk_frame_new (_("ICC Profile data"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 10);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, FALSE, TRUE, 0);
toggle_vbox = gtk_vbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (toggle_vbox), 5);
gtk_container_add (GTK_CONTAINER (frame), toggle_vbox);
group = NULL;
LIST_TOOGLE ( _("embedd ICC Profile"), use_icc_profile )
LIST_TOOGLE ( _("dont attach ICC color data"), use_no_icc )
gtk_widget_show (toggle_vbox);
gtk_widget_show (frame);
if (info->save_vals.use_icc_profile == -1)
gtk_widget_set_sensitive (frame, FALSE);
/* compression */
LIST_FRAME (_("Compression"))
group = NULL;
LIST_TOOGLE (_("None"), use_none)
#ifdef LZW_SUPPORT
LIST_TOOGLE (_("LZW"), use_lzw)
#endif
#ifdef PACKBITS_SUPPORT
LIST_TOOGLE (_("Pack Bits"), use_packbits)
#endif
/*#ifdef ZIP_SUPPORT */
LIST_TOOGLE ( _("Deflate"), use_deflate)
/*#endif */
/*#ifdef LOGLUV_SUPPORT */
LIST_TOOGLE (_("SGILOG (32-bit)") , use_sgilog)
gtk_widget_set_sensitive (toggle, FALSE);
if (info->bps >= 32 && SGILOGDATAFMT == SGILOGDATAFMT_FLOAT) {
if (info->profile_size) {
cmsHPROFILE p = cmsOpenProfileFromMem (info->icc_profile,
info->profile_size);
if (cmsGetColorSpace(p) == icSigXYZData
|| cmsGetColorSpace(p) == icSigRgbData)
gtk_widget_set_sensitive (toggle, TRUE);
}
}
/*#endif */
#if 0
/*#ifdef PIXARLOG_SUPPORT */
LIST_TOOGLE ( _("PixarLOG (11-bit)"), use_pixarlog)
if (info->bps < 32 && SGILOGDATAFMT == SGILOGDATAFMT_FLOAT)
gtk_widget_set_sensitive (toggle, FALSE);
/*#endif */
#endif
/*#ifdef JPEG_SUPPORT */
LIST_TOOGLE ( _("JPEG"), use_jpeg)
if (info->bps > 8)
gtk_widget_set_sensitive (toggle, FALSE);
#if 0
LIST_TOOGLE ( _("JP2000"), use_jp2000)
#endif
/*#endif */
LIST_TOOGLE ( _("Adobe"), use_adobe)
gtk_widget_show (toggle_vbox);
gtk_widget_show (frame);
/* fillorder */
LIST_FRAME (_("Fill Order"))
group = NULL;
LIST_TOOGLE ( _("LSB to MSB"), use_lsb2msb )
LIST_TOOGLE ( _("MSB to LSB"), use_msb2lsb )
gtk_widget_show (toggle_vbox);
gtk_widget_show (frame);
/* premultiply */
LIST_FRAME (_("Transparency Computation"))
group = NULL;
sprintf (text,_("Premultiply Colour (associate)"));
if ( info->photomet == PHOTOMETRIC_RGB )
sprintf (text,"%s - Standard", text);
LIST_TOOGLE ( text, use_premultiply )
LIST_TOOGLE ( _("Dont Premultiply"), use_notpremultiply )
gtk_widget_show (toggle_vbox);
gtk_widget_show (frame);
/* separate planes */
hbox = gtk_hbox_new (FALSE, 1);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), hbox, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_widget_show (hbox);
toggle = gtk_check_button_new_with_label (_("Write Separate Planes per Channel"));
gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 0);
gtk_widget_show (toggle);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
GTK_SIGNAL_FUNC (gimp_toggle_button_update),
&use_sep_planar);
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (toggle), use_sep_planar);
vbox = gtk_vbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), vbox, FALSE, TRUE, 0);
if (info->save_vals.premultiply == EXTRASAMPLE_UNSPECIFIED)
gtk_widget_set_sensitive (frame, FALSE);
TEXT_ENTRY ( _("Artist:"), text_entry_callback , image_artist )
TEXT_ENTRY ( _("Copyright:"), text_entry_callback , image_copyright )
TEXT_ENTRY ( _("Comment:"), text_entry_callback , image_comment )
gtk_widget_show (vbox);
gtk_widget_show (frame);
gtk_widget_show (dlg);
gtk_main ();
gdk_flush ();
if (use_icc_profile)
tsvals_.use_icc_profile = TRUE;
else if (use_no_icc)
tsvals_.use_icc_profile = FALSE;
if (use_none)
tsvals_.compression = COMPRESSION_NONE;
else if (use_lzw)
tsvals_.compression = COMPRESSION_LZW;
else if (use_packbits)
tsvals_.compression = COMPRESSION_PACKBITS;
else if (use_deflate)
tsvals_.compression = COMPRESSION_DEFLATE;
else if (use_sgilog)
tsvals_.compression = COMPRESSION_SGILOG;
else if (use_pixarlog)
tsvals_.compression = COMPRESSION_PIXARLOG;
else if (use_jpeg)
tsvals_.compression = COMPRESSION_JPEG;
else if (use_jp2000)
tsvals_.compression = COMPRESSION_JP2000;
else if (use_adobe)
tsvals_.compression = COMPRESSION_ADOBE_DEFLATE;
if (use_lsb2msb)
tsvals_.fillorder = FILLORDER_LSB2MSB;
else if (use_msb2lsb)
tsvals_.fillorder = FILLORDER_MSB2LSB;
if(use_sep_planar)
tsvals_.planar_separate = PLANARCONFIG_SEPARATE;
else
tsvals_.planar_separate = PLANARCONFIG_CONTIG;
if (use_premultiply
&& info->save_vals.premultiply != EXTRASAMPLE_UNSPECIFIED) {
tsvals_.premultiply = EXTRASAMPLE_ASSOCALPHA;
} else if (use_notpremultiply
&& info->save_vals.premultiply != EXTRASAMPLE_UNSPECIFIED) {
tsvals_.premultiply = EXTRASAMPLE_UNASSALPHA;
}
info = info->top;
for (dircount=0; dircount < info->pagecount ; dircount++) {
if (dircount > 0)
info = info->next;
info->save_vals.use_icc_profile = tsvals_.use_icc_profile;
info->save_vals.compression = tsvals_.compression;
info->save_vals.fillorder = tsvals_.fillorder;
if (info->save_vals.premultiply != EXTRASAMPLE_UNSPECIFIED) {
info->save_vals.premultiply = tsvals_.premultiply;
}
if (use_sgilog || use_pixarlog) {
if (info->spp > 2)
info->photomet = PHOTOMETRIC_LOGLUV;
else
info->photomet = PHOTOMETRIC_LOGL;
if (use_sgilog)
info->logDataFMT = SGILOGDATAFMT;
else
info->logDataFMT = PIXARLOGDATAFMT_FLOAT;
}
info->planar = tsvals_.planar_separate;
}
info = info->top;
/*g_message ("%d",tsint.run); */
return tsint.run;
}
bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
const wxPoint &pos, const wxSize &size,
int n, const wxString choices[], int majorDim,
long style, const wxValidator& validator,
const wxString &name )
{
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxRadioBox creation failed") );
return false;
}
m_widget = gtk_frame_new( wxGTK_CONV( title ) );
// majorDim may be 0 if all trailing parameters were omitted, so don't
// assert here but just use the correct value for it
m_majorDim = majorDim == 0 ? n : majorDim;
int num_per_major = (n - 1) / m_majorDim +1;
int num_of_cols = 0;
int num_of_rows = 0;
if (HasFlag(wxRA_SPECIFY_COLS))
{
num_of_cols = m_majorDim;
num_of_rows = num_per_major;
}
else
{
num_of_cols = num_per_major;
num_of_rows = m_majorDim;
}
GtkRadioButton *m_radio = (GtkRadioButton*) NULL;
GtkWidget *table = gtk_table_new( num_of_rows, num_of_cols, FALSE );
gtk_table_set_col_spacings( GTK_TABLE(table), 1 );
gtk_table_set_row_spacings( GTK_TABLE(table), 1 );
gtk_widget_show( table );
gtk_container_add( GTK_CONTAINER(m_widget), table );
wxString label;
GSList *radio_button_group = (GSList *) NULL;
for (int i = 0; i < n; i++)
{
if ( i != 0 )
radio_button_group = gtk_radio_button_group( GTK_RADIO_BUTTON(m_radio) );
label.Empty();
for ( const wxChar *pc = choices[i]; *pc; pc++ )
{
if ( *pc != wxT('&') )
label += *pc;
}
m_radio = GTK_RADIO_BUTTON( gtk_radio_button_new_with_label( radio_button_group, wxGTK_CONV( label ) ) );
gtk_widget_show( GTK_WIDGET(m_radio) );
gtk_signal_connect( GTK_OBJECT(m_radio), "key_press_event",
GTK_SIGNAL_FUNC(gtk_radiobox_keypress_callback), (gpointer)this );
m_boxes.Append( (wxObject*) m_radio );
if (HasFlag(wxRA_SPECIFY_COLS))
{
int left = i%num_of_cols;
int right = (i%num_of_cols) + 1;
int top = i/num_of_cols;
int bottom = (i/num_of_cols)+1;
gtk_table_attach( GTK_TABLE(table), GTK_WIDGET(m_radio), left, right, top, bottom,
GTK_FILL, GTK_FILL, 1, 1 );
}
else
{
int left = i/num_of_rows;
int right = (i/num_of_rows) + 1;
int top = i%num_of_rows;
int bottom = (i%num_of_rows)+1;
gtk_table_attach( GTK_TABLE(table), GTK_WIDGET(m_radio), left, right, top, bottom,
GTK_FILL, GTK_FILL, 1, 1 );
}
ConnectWidget( GTK_WIDGET(m_radio) );
if (!i) gtk_toggle_button_set_state( GTK_TOGGLE_BUTTON(m_radio), TRUE );
gtk_signal_connect( GTK_OBJECT(m_radio), "clicked",
GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this );
gtk_signal_connect( GTK_OBJECT(m_radio), "focus_in_event",
GTK_SIGNAL_FUNC(gtk_radiobutton_focus_in), (gpointer)this );
gtk_signal_connect( GTK_OBJECT(m_radio), "focus_out_event",
GTK_SIGNAL_FUNC(gtk_radiobutton_focus_out), (gpointer)this );
}
m_parent->DoAddChild( this );
SetLabel( title );
PostCreation(size);
return true;
}
void showchange(char *title, Trptr t, GtkSignalFunc func)
{
GtkWidget *main_vbox;
GtkWidget *ok_hbox;
GtkWidget *hbox;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *label;
GtkWidget *button;
GtkWidget *separator;
GSList *group;
GtkWidget *frame1, *frame2;
cleanup=func;
tcache=t;
flags=t->flags;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_grab_add(window);
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC(destroy_callback),
NULL);
gtk_window_set_title (GTK_WINDOW (window), title);
gtk_container_border_width (GTK_CONTAINER (window), 0);
main_vbox = gtk_vbox_new (FALSE, 1);
gtk_container_border_width (GTK_CONTAINER (main_vbox), 1);
gtk_widget_show (main_vbox);
label=gtk_label_new(t->name);
gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, TRUE, 0);
gtk_widget_show (label);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (main_vbox), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
hbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbox), 5);
gtk_widget_show (hbox);
box2 = gtk_vbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (box2), 5);
gtk_widget_show (box2);
button1 = gtk_radio_button_new_with_label (NULL, "Hex");
gtk_box_pack_start (GTK_BOX (box2), button1, TRUE, TRUE, 0);
if(flags&TR_HEX) gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button1), TRUE);
gtk_widget_show (button1);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button1));
button2 = gtk_radio_button_new_with_label(group, "Decimal");
gtk_box_pack_start (GTK_BOX (box2), button2, TRUE, TRUE, 0);
if(flags&TR_DEC) gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button2), TRUE);
gtk_widget_show (button2);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button2));
button5 = gtk_radio_button_new_with_label(group, "Signed Decimal");
gtk_box_pack_start (GTK_BOX (box2), button5, TRUE, TRUE, 0);
if(flags&TR_SIGNED) gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button5), TRUE);
gtk_widget_show (button5);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button5));
button3 = gtk_radio_button_new_with_label(group, "Binary");
gtk_box_pack_start (GTK_BOX (box2), button3, TRUE, TRUE, 0);
if(flags&TR_BIN) gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button3), TRUE);
gtk_widget_show (button3);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button3));
button4 = gtk_radio_button_new_with_label(group, "Octal");
gtk_box_pack_start (GTK_BOX (box2), button4, TRUE, TRUE, 0);
if(flags&TR_OCT) gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button4), TRUE);
gtk_widget_show (button4);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button4));
button6 = gtk_radio_button_new_with_label(group, "ASCII");
gtk_box_pack_start (GTK_BOX (box2), button6, TRUE, TRUE, 0);
if(flags&TR_ASCII) gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button6), TRUE);
gtk_widget_show (button6);
frame2 = gtk_frame_new ("Base");
gtk_container_border_width (GTK_CONTAINER (frame2), 3);
gtk_container_add (GTK_CONTAINER (frame2), box2);
gtk_widget_show (frame2);
gtk_box_pack_start(GTK_BOX (hbox), frame2, TRUE, TRUE, 0);
/****************************************************************************************************/
box1 = gtk_vbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (box1), 5);
gtk_widget_show (box1);
frame1 = gtk_frame_new ("Attributes");
gtk_container_border_width (GTK_CONTAINER (frame1), 3);
gtk_container_add (GTK_CONTAINER (frame1), box1);
gtk_box_pack_start(GTK_BOX (hbox), frame1, TRUE, TRUE, 0);
gtk_widget_show (frame1);
toggle1=gtk_check_button_new_with_label("Right Justify");
gtk_box_pack_start (GTK_BOX (box1), toggle1, TRUE, TRUE, 0);
if(flags&TR_RJUSTIFY)gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(toggle1), TRUE);
gtk_widget_show (toggle1);
gtk_signal_connect (GTK_OBJECT (toggle1), "toggled", GTK_SIGNAL_FUNC(toggle1_callback), NULL);
toggle2=gtk_check_button_new_with_label("Invert");
gtk_box_pack_start (GTK_BOX (box1), toggle2, TRUE, TRUE, 0);
if(flags&TR_INVERT)gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(toggle2), TRUE);
gtk_widget_show (toggle2);
gtk_signal_connect (GTK_OBJECT (toggle2), "toggled", GTK_SIGNAL_FUNC(toggle2_callback), NULL);
toggle3=gtk_check_button_new_with_label("Reverse");
gtk_box_pack_start (GTK_BOX (box1), toggle3, TRUE, TRUE, 0);
if(flags&TR_REVERSE)gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(toggle3), TRUE);
gtk_widget_show (toggle3);
gtk_signal_connect (GTK_OBJECT (toggle3), "toggled", GTK_SIGNAL_FUNC(toggle3_callback), NULL);
toggle4=gtk_check_button_new_with_label("Exclude");
gtk_box_pack_start (GTK_BOX (box1), toggle4, TRUE, TRUE, 0);
if(flags&TR_EXCLUDE)gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(toggle4), TRUE);
gtk_widget_show (toggle4);
gtk_signal_connect (GTK_OBJECT (toggle4), "toggled", GTK_SIGNAL_FUNC(toggle4_callback), NULL);
gtk_container_add (GTK_CONTAINER (main_vbox), hbox);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (main_vbox), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
/****************************************************************************************************/
ok_hbox = gtk_hbox_new (FALSE, 1);
gtk_container_border_width (GTK_CONTAINER (ok_hbox), 1);
gtk_widget_show (ok_hbox);
button = gtk_button_new_with_label ("Cancel");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(destroy_callback),
GTK_OBJECT (window));
gtk_box_pack_end (GTK_BOX (ok_hbox), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_show (button);
gtk_container_add (GTK_CONTAINER (main_vbox), ok_hbox);
button = gtk_button_new_with_label (" OK ");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(enter_callback),
GTK_OBJECT (window));
gtk_signal_connect_object (GTK_OBJECT (button),
"realize",
(GtkSignalFunc) gtk_widget_grab_default,
GTK_OBJECT (button));
gtk_box_pack_end (GTK_BOX (ok_hbox), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_show (button);
/****************************************************************************************************/
gtk_container_add (GTK_CONTAINER (window), main_vbox);
gtk_widget_show (window);
}