static void CheatList_TreeSelectionChanged(GtkTreeSelection *selection, gpointer user_data) {
GladeXML *xml;
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreePath *path;
gboolean selected;
int i;
selected = gtk_tree_selection_get_selected(selection, &model, &iter);
if (selected) {
path = gtk_tree_model_get_path(model, &iter);
i = *gtk_tree_path_get_indices(path);
gtk_tree_path_free(path);
// If a row was selected, and the row is not blank, we can now enable
// some of the disabled widgets
xml = glade_get_widget_tree(CheatListDlg);
gtk_widget_set_sensitive(GTK_WIDGET(glade_xml_get_widget(xml, "editbutton1")), TRUE);
gtk_widget_set_sensitive(GTK_WIDGET(glade_xml_get_widget(xml, "delbutton1")), TRUE);
} else {
xml = glade_get_widget_tree(CheatListDlg);
gtk_widget_set_sensitive(GTK_WIDGET(glade_xml_get_widget(xml, "editbutton1")), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(glade_xml_get_widget(xml, "delbutton1")), FALSE);
}
gtk_widget_set_sensitive (GTK_WIDGET(glade_xml_get_widget(xml, "savebutton1")), NumCheats);
}
EXPORT gboolean create_new_gauge(GtkWidget * widget, gpointer data)
{
GtkWidget *tmp = NULL;
GladeXML *xml = glade_get_widget_tree(widget);
GtkWidget *parent = glade_xml_get_widget(xml,"gauge_frame");
gauge = mtx_gauge_face_new();
gtk_widget_set_events(gauge,GDK_POINTER_MOTION_HINT_MASK
| GDK_POINTER_MOTION_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK);
g_signal_connect(GTK_WIDGET(gauge),"motion_notify_event",G_CALLBACK(gauge_motion),NULL);
g_signal_connect(GTK_WIDGET(gauge),"button_press_event",G_CALLBACK(gauge_button),NULL);
gtk_container_add(GTK_CONTAINER(parent),gauge);
gtk_widget_show_all(parent);
mtx_gauge_face_redraw_canvas(MTX_GAUGE_FACE(gauge));
gauge_loaded = TRUE;
gtk_widget_set_sensitive(glade_xml_get_widget(xml,"tab_notebook"),TRUE);
gtk_widget_set_sensitive(glade_xml_get_widget(xml,"animate_frame"),TRUE);
gtk_widget_set_sensitive(glade_xml_get_widget(xml,"new_gauge_menuitem"),FALSE);
gtk_widget_set_sensitive(glade_xml_get_widget(xml,"close_gauge_menuitem"),TRUE);
gtk_widget_set_sensitive(glade_xml_get_widget(xml,"load_gauge_menuitem"),FALSE);
gtk_widget_set_sensitive(glade_xml_get_widget(xml,"save_gauge_menuitem"),TRUE);
gtk_widget_set_sensitive(glade_xml_get_widget(xml,"save_as_menuitem"),TRUE);
update_attributes();
return (TRUE);
}
// get the current selected result index in the list
static int GetSelectedResultIndex() {
GladeXML *xml;
GtkTreeSelection *selection;
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreePath *path;
gboolean selected;
int i;
xml = glade_get_widget_tree(CheatSearchDlg);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(glade_xml_get_widget(xml, "GtkCList_Result")));
selected = gtk_tree_selection_get_selected(selection, &model, &iter);
if (!selected) {
return -1;
}
path = gtk_tree_model_get_path(model, &iter);
i = *gtk_tree_path_get_indices(path);
gtk_tree_path_free(path);
assert(i < NumSearchResults);
return i;
}
static void OnCheatListDlg_DelClicked(GtkWidget *widget, gpointer user_data) {
GladeXML *xml;
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreePath *path;
gboolean selected;
int i = -1;
xml = glade_get_widget_tree(CheatListDlg);
widget = glade_xml_get_widget(xml, "GtkCList_Cheat");
selected = gtk_tree_selection_get_selected(
gtk_tree_view_get_selection(GTK_TREE_VIEW(widget)),
&model, &iter);
if (selected) {
path = gtk_tree_model_get_path(model, &iter);
i = *gtk_tree_path_get_indices(path);
gtk_tree_path_free(path);
RemoveCheat(i);
}
LoadCheatListItems(i); // FIXME: should remove it from the list directly
// rather than regenerating the whole list
}
// set up the popup menu for the context of the passed glarea
void
configure_gl_popup_menu(GtkGLArea *glarea)
{
gchar menu_item_name[64];
gchar *o_string;
gboolean sensitivity = FALSE;
GladeXML *xml = glade_get_widget_tree(GTK_WIDGET (glarea));
gl_window_info *info = (gl_window_info*)gtk_object_get_data(GTK_OBJECT(glarea), "info");
GtkCheckMenuItem *menu_item;
//make sure the booleans and radios are set correctly before displaying the menu...
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (glade_xml_get_widget(xml, "glm_show_axis")),
info->show_axis
);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (glade_xml_get_widget(xml, "glm_show_grid")),
info->show_grid
);
switch(info->orientation)
{
case ORIENTATION_3D: o_string = "3d"; sensitivity = TRUE; break;
case ORIENTATION_FRONT: o_string = "front"; break;
case ORIENTATION_BACK: o_string = "back"; break;
case ORIENTATION_LEFT: o_string = "left"; break;
case ORIENTATION_RIGHT: o_string = "right"; break;
case ORIENTATION_TOP: o_string = "top"; break;
case ORIENTATION_BOTTOM: o_string = "bottom"; break;
default: break;
}
sprintf(menu_item_name, "glm_orientation_radio_%s", o_string);
menu_item = GTK_CHECK_MENU_ITEM (glade_xml_get_widget(xml, (const char *) menu_item_name));
if(menu_item == NULL)
g_print("orientation menu item is null\n");
else
gtk_check_menu_item_set_active(menu_item, 1);
switch(info->polygon_mode)
{
case MODE_WIREFRAME: strcpy(menu_item_name, "glm_wireframe"); break;
case MODE_FLAT: strcpy(menu_item_name, "glm_flat_shaded"); break;
case MODE_SMOOTH: strcpy(menu_item_name, "glm_smooth_shaded"); break;
case MODE_TEXTURED: strcpy(menu_item_name, "glm_textured"); break;
default: break;
}
menu_item = GTK_CHECK_MENU_ITEM (glade_xml_get_widget(xml, (const char *) menu_item_name));
if(menu_item == NULL)
g_print("polygon mode menu item is null\n");
else
gtk_check_menu_item_set_active(menu_item, 1);
return;
}
/**
* \brief the initial resize of the warning needs to be done a little time
* after the display of the dialog, so the actual size of the components
* can be determined. Therefor this is done through a timed function.
*/
void
auto_resize_warning_dialog ()
{
#undef DEBUGFUNCTION
#define DEBUGFUNCTION "auto_resize_warning_dialog()"
GtkRequisition vp_size;
int set_size = 0, orig_vp_size = 0;
gint win_width = 0;
gint win_height = 0;
GtkWidget *vbox = NULL, *viewport = NULL, *eitem = NULL;
GList *elist = NULL;
int ind = 0, height = 0;
GladeXML *xml = NULL;
#ifdef DEBUG
printf ("%s %s: Entering\n", DEBUGFILE, DEBUGFUNCTION);
#endif // DEBUG
g_assert (xvc_warn_main_window);
xml = glade_get_widget_tree (GTK_WIDGET (xvc_warn_main_window));
vbox = glade_xml_get_widget (xml, "xvc_warn_errors_vbox");
g_assert (vbox);
elist = gtk_container_get_children (GTK_CONTAINER (vbox));
eitem = g_list_nth_data (elist, 0);
// the hack keeps getting uglier ...
if (eitem->allocation.height > 1) {
for (ind = 0; ind < g_list_length (elist); ind++) {
eitem = g_list_nth_data (elist, ind);
g_assert (eitem);
height += (eitem->allocation.height + 1);
}
set_size = (height > 400 ? 400 : height);
viewport = glade_xml_get_widget (xml, "xvc_warn_errors_viewport");
g_assert (viewport);
gtk_widget_size_request (viewport, &vp_size);
orig_vp_size = vp_size.height;
gtk_widget_set_size_request (viewport, -1, set_size);
gtk_widget_size_request (viewport, &vp_size);
gtk_window_get_size (GTK_WINDOW (xvc_warn_main_window), &win_width,
&win_height);
gtk_window_resize (GTK_WINDOW (xvc_warn_main_window), win_width,
win_height - (orig_vp_size - vp_size.height) + 1);
g_source_remove (scheduled_warning_resize_id);
}
#ifdef DEBUG
printf ("%s %s: Leaving\n", DEBUGFILE, DEBUGFUNCTION);
#endif // DEBUG
}
EXPORT gboolean link_range_spinners(GtkWidget *widget, gpointer data)
{
GladeXML *xml = glade_get_widget_tree(widget);
GtkAdjustment *adj = NULL;
GtkWidget *upper_spin = glade_xml_get_widget(xml,"range_highpoint_spin");
adj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(upper_spin));
adj->lower = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget));
if (adj->value < adj->lower)
adj->value = adj->lower;
gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(upper_spin),adj);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(upper_spin),adj->value);
return FALSE;
}
gboolean sweep_gauge(gpointer data)
{
static gfloat lower = 0.0;
static gfloat upper = 0.0;
gfloat interval = 0.0;
gfloat cur_val = 0.0;
GladeXML *xml = NULL;
GtkWidget *button = NULL;
static gboolean rising = TRUE;
GtkWidget * gauge = NULL;
gauge = (GtkWidget *)data;
if (!GTK_IS_WIDGET(gauge))
return FALSE;
mtx_gauge_face_get_attribute(MTX_GAUGE_FACE(gauge), LBOUND, &lower);
mtx_gauge_face_get_attribute(MTX_GAUGE_FACE(gauge), UBOUND, &upper);
interval = (upper-lower)/75.0;
mtx_gauge_face_get_value(MTX_GAUGE_FACE (gauge), &cur_val);
if (cur_val >= upper)
rising = FALSE;
if (cur_val <= lower)
rising = TRUE;
if (rising)
cur_val+=interval;
else
cur_val-=interval;
mtx_gauge_face_set_value (MTX_GAUGE_FACE (gauge),cur_val);
if (cur_val <= lower)
{
/* This cancels the timeout once one full complete sweep
* of the gauge
*/
xml = glade_get_widget_tree(gauge->parent);
button = glade_xml_get_widget(xml,"animate_button");
gtk_widget_set_sensitive(button,TRUE);
mtx_gauge_face_set_value (MTX_GAUGE_FACE (gauge),lower);
return FALSE;
}
else
return TRUE;
}
EXPORT gboolean close_current_gauge(GtkWidget * widget, gpointer data)
{
GtkWidget *tmp = NULL;
GladeXML *xml = glade_get_widget_tree(widget);
GtkWidget *parent = glade_xml_get_widget(xml,"gauge_frame");
if (GTK_IS_WIDGET(gauge))
{
if (changed)
prompt_to_save();
gtk_widget_destroy(gauge);
gtk_widget_set_sensitive(glade_xml_get_widget(xml,"tab_notebook"),FALSE);
gauge_loaded = FALSE;
changed = FALSE;
}
gauge = NULL;
tmp = glade_xml_get_widget(xml,"animate_frame");
gtk_widget_set_sensitive(tmp,FALSE);
tmp = glade_xml_get_widget(xml,"new_gauge_menuitem");
gtk_widget_set_sensitive(tmp,TRUE);
tmp = glade_xml_get_widget(xml,"load_gauge_menuitem");
gtk_widget_set_sensitive(tmp,TRUE);
tmp = glade_xml_get_widget(xml,"close_gauge_menuitem");
gtk_widget_set_sensitive(tmp,FALSE);
tmp = glade_xml_get_widget(xml,"save_gauge_menuitem");
gtk_widget_set_sensitive(tmp,FALSE);
tmp = glade_xml_get_widget(xml,"save_as_menuitem");
gtk_widget_set_sensitive(tmp,FALSE);
tmp = glade_xml_get_widget(xml,"animate_button");
gtk_widget_set_sensitive(tmp,TRUE);
reset_onscreen_controls();
direct_path = FALSE;
gtk_widget_show_all(parent);
return (TRUE);
}
static void LoadCheatListItems(int index) {
GtkListStore *store = gtk_list_store_new(2, G_TYPE_BOOLEAN, G_TYPE_STRING);
GtkTreeIter iter;
GtkWidget *widget;
GladeXML *xml;
int i;
xml = glade_get_widget_tree(CheatListDlg);
widget = glade_xml_get_widget(xml, "GtkCList_Cheat");
for (i = 0; i < NumCheats; i++) {
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, Cheats[i].Enabled, 1, Cheats[i].Descr, -1);
}
gtk_tree_view_set_model(GTK_TREE_VIEW(widget), GTK_TREE_MODEL(store));
g_object_unref(G_OBJECT(store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(widget), TRUE);
gtk_widget_show(widget);
if (index >= NumCheats) {
index = NumCheats - 1;
}
if (index >= 0) {
GtkTreePath *path;
GtkTreeSelection *sel;
path = gtk_tree_path_new_from_indices(index, -1);
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
gtk_tree_selection_select_path(sel, path);
gtk_tree_path_free(path);
}
}
static GtkWidget *ventana_parametros_get_widget(GtkWidget *w, const char *nombre) {
GladeXML *xml = glade_get_widget_tree(w);
return glade_xml_get_widget(xml, nombre);
}
// update the cheat search dialog
static void UpdateCheatSearchDialog() {
GladeXML *xml;
char buf[256];
int i;
u32 addr;
GtkListStore *store = gtk_list_store_new(1, G_TYPE_STRING);
GtkTreeIter iter;
GtkWidget *widget;
xml = glade_get_widget_tree(CheatSearchDlg);
widget = glade_xml_get_widget(xml, "GtkCList_Result");
gtk_combo_box_set_active(GTK_COMBO_BOX(glade_xml_get_widget(xml, "combo_searchfor")), current_search);
gtk_combo_box_set_active(GTK_COMBO_BOX(glade_xml_get_widget(xml, "combo_datatype")), current_searchtype);
gtk_combo_box_set_active(GTK_COMBO_BOX(glade_xml_get_widget(xml, "combo_database")), current_searchbase);
if (current_searchbase == SEARCHBASE_DEC) {
sprintf(buf, "%u", current_valuefrom);
gtk_entry_set_text(GTK_ENTRY(glade_xml_get_widget(xml, "entry_value")), buf);
sprintf(buf, "%u", current_valueto);
gtk_entry_set_text(GTK_ENTRY(glade_xml_get_widget(xml, "entry_valueto")), buf);
}
else {
sprintf(buf, "%X", current_valuefrom);
gtk_entry_set_text(GTK_ENTRY(glade_xml_get_widget(xml, "entry_value")), buf);
sprintf(buf, "%X", current_valueto);
gtk_entry_set_text(GTK_ENTRY(glade_xml_get_widget(xml, "entry_valueto")), buf);
}
if (current_search == SEARCH_RANGE) {
gtk_widget_show(GTK_WIDGET(glade_xml_get_widget(xml, "label_valueto")));
gtk_widget_show(GTK_WIDGET(glade_xml_get_widget(xml, "entry_valueto")));
}
else {
gtk_widget_hide(GTK_WIDGET(glade_xml_get_widget(xml, "label_valueto")));
gtk_widget_hide(GTK_WIDGET(glade_xml_get_widget(xml, "entry_valueto")));
}
if (current_search >= SEARCH_INC) {
gtk_widget_set_sensitive(GTK_WIDGET(glade_xml_get_widget(xml, "entry_value")), FALSE);
}
else {
gtk_widget_set_sensitive(GTK_WIDGET(glade_xml_get_widget(xml, "entry_value")), TRUE);
}
if (current_search >= SEARCH_INCBY && prevM == NULL) {
gtk_widget_set_sensitive(GTK_WIDGET(glade_xml_get_widget(xml, "btn_start")), FALSE);
}
else {
gtk_widget_set_sensitive(GTK_WIDGET(glade_xml_get_widget(xml, "btn_start")), TRUE);
}
gtk_widget_set_sensitive(GTK_WIDGET(glade_xml_get_widget(xml, "btn_freeze")), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(glade_xml_get_widget(xml, "btn_modify")), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(glade_xml_get_widget(xml, "btn_copy")), FALSE);
if (prevM != NULL) {
gtk_widget_set_sensitive(GTK_WIDGET(glade_xml_get_widget(xml, "combo_datatype")), FALSE);
if (NumSearchResults > 100) {
// too many results to be shown
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, _("Too many addresses found."), -1);
gtk_widget_set_sensitive(widget, FALSE);
}
else {
for (i = 0; i < NumSearchResults; i++) {
addr = SearchResults[i];
switch (current_searchtype) {
case SEARCHTYPE_8BIT:
sprintf(buf, _("%.8X Current: %u (%.2X), Previous: %u (%.2X)"),
addr, PSXMu8(addr), PSXMu8(addr), PrevMu8(addr), PrevMu8(addr));
break;
case SEARCHTYPE_16BIT:
sprintf(buf, _("%.8X Current: %u (%.4X), Previous: %u (%.4X)"),
addr, PSXMu16(addr), PSXMu16(addr), PrevMu16(addr), PrevMu16(addr));
break;
case SEARCHTYPE_32BIT:
sprintf(buf, _("%.8X Current: %u (%.8X), Previous: %u (%.8X)"),
addr, PSXMu32(addr), PSXMu32(addr), PrevMu32(addr), PrevMu32(addr));
break;
default:
assert(FALSE); // impossible
break;
}
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, buf, -1);
}
gtk_widget_set_sensitive(widget, TRUE);
}
sprintf(buf, _("Founded Addresses: %d"), NumSearchResults);
gtk_label_set_text(GTK_LABEL(glade_xml_get_widget(xml, "label_resultsfound")), buf);
}
else {
gtk_widget_set_sensitive(GTK_WIDGET(glade_xml_get_widget(xml, "combo_datatype")), TRUE);
gtk_widget_set_sensitive(widget, FALSE);
gtk_label_set_text(GTK_LABEL(glade_xml_get_widget(xml, "label_resultsfound")),
_("Enter the values and start your search."));
}
gtk_tree_view_set_model(GTK_TREE_VIEW(widget), GTK_TREE_MODEL(store));
g_object_unref(G_OBJECT(store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(widget), TRUE);
gtk_widget_show(widget);
}
static void OnCheatListDlg_EditClicked(GtkWidget *widget, gpointer user_data) {
GtkWidget *dlg;
GtkWidget *box, *scroll, *label, *descr_edit, *code_edit;
GladeXML *xml;
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreePath *path;
gboolean selected;
int index, i;
char buf[8192];
char *p = buf;
xml = glade_get_widget_tree(CheatListDlg);
widget = glade_xml_get_widget(xml, "GtkCList_Cheat");
selected = gtk_tree_selection_get_selected(
gtk_tree_view_get_selection(GTK_TREE_VIEW(widget)),
&model, &iter);
if (!selected) {
return;
}
path = gtk_tree_model_get_path(model, &iter);
index = *gtk_tree_path_get_indices(path);
gtk_tree_path_free(path);
dlg = gtk_dialog_new_with_buttons(_("Edit Cheat"), GTK_WINDOW(CheatListDlg),
GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
gtk_window_set_default_size(GTK_WINDOW(dlg), 350, 350);
box = GTK_WIDGET(GTK_DIALOG(dlg)->vbox);
label = gtk_label_new(_("Cheat Description:"));
gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 5);
gtk_widget_show(label);
descr_edit = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(descr_edit), Cheats[index].Descr);
gtk_box_pack_start(GTK_BOX(box), descr_edit, FALSE, FALSE, 5);
gtk_widget_show(descr_edit);
label = gtk_label_new(_("Cheat Code:"));
gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 5);
gtk_widget_show(label);
code_edit = gtk_text_view_new();
for (i = Cheats[index].First; i < Cheats[index].First + Cheats[index].n; i++) {
sprintf(p, "%.8X %.4X\n", CheatCodes[i].Addr, CheatCodes[i].Val);
p += 14;
*p = '\0';
}
gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(code_edit)),
buf, -1);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(code_edit), GTK_WRAP_CHAR);
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), code_edit);
gtk_widget_show(code_edit);
gtk_box_pack_start(GTK_BOX(box), scroll, TRUE, TRUE, 5);
gtk_widget_show(scroll);
gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
gtk_widget_show_all(dlg);
if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_ACCEPT) {
GtkTextBuffer *b = gtk_text_view_get_buffer(GTK_TEXT_VIEW(code_edit));
GtkTextIter s, e;
char *codetext;
gtk_text_buffer_get_bounds(GTK_TEXT_BUFFER(b), &s, &e);
codetext = strdup(gtk_text_buffer_get_text(GTK_TEXT_BUFFER(b), &s, &e, FALSE));
if (EditCheat(index, gtk_entry_get_text(GTK_ENTRY(descr_edit)), codetext) != 0) {
SysErrorMessage(_("Error"), _("Invalid cheat code!"));
}
LoadCheatListItems(index);
free(codetext);
}
gtk_widget_destroy(dlg);
}
void
on_xvc_warn_main_window_response (GtkDialog * dialog, gint response_id,
gpointer user_data)
{
#undef DEBUGFUNCTION
#define DEBUGFUNCTION "on_xvc_warn_main_window_response()"
GladeXML *xml = NULL;
GtkWidget *mitem = NULL;
#ifdef DEBUG
printf ("%s %s: Entering with response_id %i, called from %i\n",
DEBUGFILE, DEBUGFUNCTION, response_id, called_from_where);
#endif // DEBUG
switch (response_id) {
case GTK_RESPONSE_OK:
if (warning_elist != NULL) {
XVC_ErrorListItem *err;
err = warning_elist;
for (; err != NULL; err = err->next) {
(*err->err->action) (err);
}
}
warning_elist = xvc_errorlist_delete (warning_elist);
switch (called_from_where) {
case 0:
gtk_widget_destroy (xvc_warn_main_window);
xvc_pref_do_OK ();
break;
#ifdef USE_FFMPEG
case 1:
gtk_widget_destroy (xvc_warn_main_window);
xvc_toggle_cap_type ();
break;
#endif // USE_FFMPEG
case 2:
gtk_widget_destroy (xvc_warn_main_window);
xvc_check_start_options ();
}
break;
case GTK_RESPONSE_CANCEL:
switch (called_from_where) {
case 0:
xvc_pref_reset_OK_attempts ();
gtk_widget_destroy (xvc_warn_main_window);
break;
#ifdef USE_FFMPEG
case 1:
xvc_undo_toggle_cap_type ();
gtk_widget_destroy (xvc_warn_main_window);
break;
#endif // USE_FFMPEG
}
break;
case GTK_RESPONSE_HELP:
doHelp ();
break;
case GTK_RESPONSE_REJECT:
xml = glade_get_widget_tree (xvc_ctrl_m1);
g_assert (xml);
mitem = glade_xml_get_widget (xml, "xvc_ctrl_m1_mitem_preferences");
g_assert (mitem);
gtk_menu_item_activate (GTK_MENU_ITEM (mitem));
xml = NULL;
xml = glade_get_widget_tree (xvc_pref_main_window);
g_assert (xml);
mitem = glade_xml_get_widget (xml, "xvc_pref_cancel_button");
g_assert (mitem);
gtk_widget_set_sensitive (GTK_WIDGET (mitem), FALSE);
warning_elist = xvc_errorlist_delete (warning_elist);
xvc_pref_reset_OK_attempts ();
gtk_widget_destroy (xvc_warn_main_window);
break;
default:
break;
}
#ifdef DEBUG
printf ("%s %s: Leaving\n", DEBUGFILE, DEBUGFUNCTION);
#endif // DEBUG
}
