home *** CD-ROM | disk | FTP | other *** search
/ Chip 2005 June / ccd0605.iso / LINUX / gopchop-1.1.7.tar.tar / gopchop-1.1.7.tar / gopchop-1.1.7 / src / callbacks.cpp < prev    next >
C/C++ Source or Header  |  2005-05-01  |  31KB  |  1,052 lines
  1. /* vi:set ai ts=4 sw=4 expandtab: */
  2. /*
  3. #
  4. # C++-ized callbacks.c file produced by Glade for GTK event callbacks
  5. #
  6. # $Id: callbacks.cpp,v 1.33 2005/05/01 17:59:23 keescook Exp $
  7. #
  8. # Copyright (C) 2001-2003 Kees Cook
  9. # kees@outflux.net, http://outflux.net/
  10. # 
  11. # This program is free software; you can redistribute it and/or
  12. # modify it under the terms of the GNU General Public License
  13. # as published by the Free Software Foundation; either version 2
  14. # of the License, or (at your option) any later version.
  15. # 
  16. # This program is distributed in the hope that it will be useful,
  17. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  18. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19. # GNU General Public License for more details.
  20. # 
  21. # You should have received a copy of the GNU General Public License
  22. # along with this program; if not, write to the Free Software
  23. # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  24. # http://www.gnu.org/copyleft/gpl.html
  25. #
  26. */
  27.  
  28. #include "GOPchop.h"
  29.  
  30. #include <gtk/gtk.h>
  31. #include <gdk/gdkkeysyms.h>
  32.  
  33. #include <stdio.h>
  34.  
  35. extern "C"
  36. {
  37. #include "callbacks.h"
  38. #include "interface.h"
  39. #include "support.h"
  40. #include "video_out.h"
  41. }
  42.  
  43. #include "main.h"
  44. #include "widgets.h"
  45. #include "gettext.h"
  46.  
  47. #include "Picture.h"
  48. #include "sessions.h"
  49.  
  50. #include "display.h"
  51.  
  52. extern struct display_engine_t * engine;
  53. extern int desired_output;
  54. extern char * opt_videoout;
  55. extern int opt_show_states;
  56. extern char * opt_pipe;
  57.  
  58. static void
  59. slider_updated_actions(uint32_t GOP)
  60. {
  61.     // only do something if we have output, and auto refreshing
  62.     if (options.auto_refresh)
  63.         show_GOP(engine,GOP);
  64.  
  65.     if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button_run))) {
  66.         display_flush(engine);
  67.     }
  68.  
  69.     // make sure the parser is loaded
  70.     if (mpeg2parser->getParsingState()==PARSER_STATE_FINISHED)
  71.         update_GOP_info(GOP);
  72.  
  73.     // handle start/end button availability
  74.     if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button_start_mark))) {
  75.         gtk_widget_set_sensitive(button_end_mark, (GOP >= mark_start));
  76.     }
  77. }
  78.  
  79. void file_is_loaded()
  80. {
  81.     List *GOPs;
  82.     List *pictures;
  83.     gchar buf[128];
  84.     char *pathname;
  85.     int picture_count = 0;
  86.  
  87.     // toggle our file options
  88.     gtk_widget_set_sensitive(menu_load_mpeg2, FALSE);
  89.     gtk_widget_set_sensitive(menu_load_clip_list, FALSE);
  90.     gtk_widget_set_sensitive(menu_save_clip_list, TRUE);
  91.     gtk_widget_set_sensitive(menu_export_mpeg2, TRUE);
  92.     gtk_widget_set_sensitive(menu_close, TRUE);
  93.  
  94.     gtk_widget_set_sensitive(menu_delete, TRUE);
  95.     gtk_widget_set_sensitive(menu_clear, TRUE);
  96.  
  97.     gtk_widget_set_sensitive(menu_video_window, TRUE);
  98.  
  99.     gtk_widget_set_sensitive(button_run, TRUE);
  100.     gtk_widget_set_sensitive(button_prev, TRUE);
  101.     gtk_widget_set_sensitive(button_next, TRUE);
  102.     gtk_widget_set_sensitive(button_refresh, TRUE);
  103.     gtk_widget_set_sensitive(button_start_mark, TRUE);
  104.     gtk_widget_set_sensitive(button_end_mark, FALSE);
  105.  
  106.     // adjust the slider scales
  107.     gtk_range_set_range(GTK_RANGE(GOP_selector), 0.0, (gdouble) (mpeg2parser->numGOPs()));
  108.     gtk_spin_button_set_range(GTK_SPIN_BUTTON(GOP_selector_spinbutton), 0.0, (gdouble) (mpeg2parser->numGOPs()-1));
  109.  
  110.     // start decode window
  111.     display_close(engine);
  112.     engine = display_open(desired_output,opt_pipe,opt_videoout,opt_show_states);
  113.     set_GOP_selected(0);
  114.     flush();
  115.     slider_updated_actions(0);
  116.  
  117.     pathname = mpeg2parser->getFilename();
  118.     if (!pathname)
  119.         pathname = "unknown";
  120.     gtk_label_set_text(GTK_LABEL(GOP_label_filename), pathname);
  121. }
  122.  
  123. void file_is_unloaded()
  124. {
  125.     // stop decode window
  126.     display_close(engine);
  127.     engine = NULL;
  128.     set_GOP_selected(0);
  129.  
  130.     // toggle our file options
  131.     gtk_widget_set_sensitive(menu_load_mpeg2, TRUE);
  132.     gtk_widget_set_sensitive(menu_load_clip_list, TRUE);
  133.     gtk_widget_set_sensitive(menu_save_clip_list, FALSE);
  134.     gtk_widget_set_sensitive(menu_export_mpeg2, FALSE);
  135.     gtk_widget_set_sensitive(menu_close, FALSE);
  136.  
  137.     gtk_widget_set_sensitive(menu_delete, FALSE);
  138.     gtk_widget_set_sensitive(menu_clear, FALSE);
  139.  
  140.     gtk_widget_set_sensitive(menu_video_window, FALSE);
  141.  
  142.     gtk_widget_set_sensitive(button_run, FALSE);
  143.     gtk_widget_set_sensitive(button_prev, FALSE);
  144.     gtk_widget_set_sensitive(button_next, FALSE);
  145.     gtk_widget_set_sensitive(button_refresh, FALSE);
  146.     gtk_widget_set_sensitive(button_start_mark, FALSE);
  147.     gtk_widget_set_sensitive(button_end_mark, FALSE);
  148.  
  149.     // adjust the slider scales
  150.     gtk_range_set_range(GTK_RANGE(GOP_selector), 0.0, 0.1);
  151.     gtk_spin_button_set_range(GTK_SPIN_BUTTON(GOP_selector_spinbutton), 0.0, 0.1);
  152.  
  153.     // wipe out GOP info window
  154.     clear_GOP_info();
  155.  
  156.     // wipe out clip window
  157.     clear_GOP_slices();
  158.  
  159.     // reset parser
  160.     mpeg2parser->reset();
  161.  
  162.     if (error_dialog)
  163.     {
  164.         // hide the errors (no errors now!)
  165.         gtk_widget_hide(error_dialog);
  166.     }
  167. }
  168.  
  169.  
  170. /*
  171.  * #############################################################################
  172.  * ######################## Start Menu Related Functions #######################
  173.  * #############################################################################
  174.  */
  175.  
  176. /* +-----------------------------------+
  177.  * | File Menu Related Functions       |
  178.  * +-----------------------------------+ */
  179. void
  180. on_menu_load_mpeg2_activate            (GtkMenuItem    *menuitem,
  181.                                         gpointer        user_data)
  182. {
  183.     if( !new_file_window ) {
  184.         new_file_window = create_new_file_window();
  185.     }
  186.     gtk_widget_show( new_file_window );
  187. }
  188.  
  189.  
  190. void
  191. on_menu_load_clip_list_activate        (GtkMenuItem    *menuitem,
  192.                                         gpointer        user_data)
  193. {
  194.     if (!open_file_window)
  195.     {
  196.         open_file_window = create_open_file_window();
  197.     }
  198.     gtk_widget_show(open_file_window);
  199. }
  200.  
  201.  
  202. void
  203. on_menu_save_clip_list_activate        (GtkMenuItem    *menuitem,
  204.                                         gpointer        user_data)
  205. {
  206.     if (!save_file_window)
  207.     {
  208.         save_file_window = create_save_file_window();
  209.     }
  210.     gtk_widget_show(save_file_window);
  211. }
  212.  
  213.  
  214. void
  215. on_menu_export_mpeg2_activate          (GtkMenuItem    *menuitem,
  216.                                         gpointer        user_data)
  217. {
  218.     if (!export_file_window)
  219.     {
  220.         export_file_window = create_export_file_window();
  221.     }
  222.     gtk_widget_show(export_file_window);
  223. }
  224.  
  225.  
  226. void
  227. on_menu_file_close_activate            (GtkMenuItem    *menuitem,
  228.                                         gpointer        user_data)
  229. {
  230.     file_is_unloaded();
  231. }
  232.  
  233.  
  234. void
  235. on_menu_file_quit_activate             (GtkMenuItem    *menuitem,
  236.                                         gpointer        user_data)
  237. {
  238.     mpeg2parser->reset();
  239.     gtk_main_quit();
  240. }
  241.  
  242.  
  243. /* +-----------------------------------+
  244.  * | Edit Menu Related Functions       |
  245.  * +-----------------------------------+ */
  246. void
  247. on_menu_delete_activate                (GtkMenuItem    *menuitem,
  248.                                         gpointer        user_data)
  249. {
  250.     GtkTreeSelection *selection;
  251.     GtkTreeIter       iter;
  252.  
  253.     selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(main_clist));
  254.     if (!gtk_tree_selection_get_selected(selection, NULL, &iter)) {
  255.         return; /* nothing selected: skip */
  256.     }
  257.  
  258.     remove_GOP_slice(&iter);
  259. }
  260.  
  261.  
  262. void
  263. on_menu_file_clear_activate            (GtkMenuItem    *menuitem,
  264.                                         gpointer        user_data)
  265. {
  266.     clear_GOP_slices();
  267. }
  268.  
  269. static char *
  270. string_merge(char * one, char * two)
  271. {
  272.     char * result=NULL;
  273.  
  274.     if (!(result=(char*)malloc(strlen(one)+strlen(two)+1))) {
  275.         perror("malloc");
  276.         exit(1);
  277.     }
  278.     sprintf(result,"%s%s",one,two);
  279.     return result;
  280. }
  281.  
  282.  
  283. // are we _displaying_ preferences or saving them?
  284. static void
  285. handle_simple_preferences(gboolean display)
  286. {
  287.     rc_parse_item * parse_item;
  288.  
  289.     for (parse_item = parsable_items;
  290.          parse_item->option;
  291.          parse_item++) {
  292.  
  293. //        printf("%s '%s' ...\n",display ? "Populating" : "Storing", parse_item->option);
  294.  
  295.         // skip missing variables
  296.         if (!parse_item->variable) continue;
  297.  
  298.         switch (parse_item->vartype) {
  299.             case RC_TYPE_BOOLEAN:
  300.             {
  301.                 gboolean * value = (gboolean*)parse_item->variable;
  302.                 GtkWidget * button;
  303.                 char *name = string_merge(parse_item->option,"_checkbutton");
  304.  
  305.                 button = lookup_widget( GTK_WIDGET(preferences_window), name );
  306.                 if (display) {
  307.                     gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(button),
  308.                                                   (*value == false) ?
  309.                                                     FALSE : TRUE );
  310.                 }
  311.                 else {
  312.                     *value = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(button) );
  313.                 }
  314.  
  315.                 if (name) free(name);
  316.                 break;
  317.             }
  318.             case RC_TYPE_INTEGER:
  319.             {
  320.                 int * value = (int*)parse_item->variable;
  321.                 GtkWidget *spinner, *range;
  322.                 char *spin_name  = string_merge(parse_item->option,"_spinner");
  323.                 char *slide_name = string_merge(parse_item->option,"_slider");
  324.  
  325.                 spinner = lookup_widget(GTK_WIDGET(preferences_window),
  326.                                         spin_name );
  327.                 range = lookup_widget(GTK_WIDGET(preferences_window),
  328.                                       slide_name);
  329.                 if (display) {
  330.                     gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinner),
  331.                                               (gdouble)*value);
  332.                     gtk_range_set_value(GTK_RANGE(range),
  333.                                         (gdouble)*value);
  334.                 }
  335.                 else {
  336.                     *value = (int) gtk_range_get_value(GTK_RANGE(range));
  337.                 }
  338.  
  339.  
  340.                 if (spin_name) free(spin_name);
  341.                 if (slide_name) free(slide_name);
  342.                 break;
  343.             }
  344.             case RC_TYPE_STRING:
  345.             {
  346.                 // string combo boxes are not simple...
  347.                 break;
  348.             }
  349.             default:
  350.             {
  351.                 printf("Unknown parseable vartype: %s:%d\n",
  352.                        parse_item->option,parse_item->vartype);
  353.                 break;
  354.             }
  355.         }
  356.     }
  357. }
  358.  
  359.  
  360. void
  361. on_menu_options_preferences_activate   (GtkMenuItem    *menuitem,
  362.                                         gpointer        user_data)
  363. {
  364.     GtkToggleButton *button;
  365.     GtkCombo        *combo;
  366.     GtkRange        *range;
  367.     GtkSpinButton   *spinner;
  368.     GList           *items;
  369.     int i;
  370.     vo_driver_t const *drivers;
  371.     
  372.     items = NULL;
  373.  
  374.     if( !preferences_window ) {
  375.         preferences_window = create_preferences_window();
  376.     }
  377.  
  378.         /* set the combo box up with the correct values. */
  379.         combo = GTK_COMBO(lookup_widget(GTK_WIDGET(preferences_window), "video_output_driver_combo" ));
  380.         gchar * vidpref = NULL;
  381.         drivers = vo_drivers();
  382.         for( i = 0; drivers[i].name; i++ ) {
  383.             items = g_list_append(items, drivers[i].name);
  384.  
  385.             // while looking through the list of available video drivers,
  386.             // the prefered driver is xv2, followed by xv, and finally x11.
  387.             // If the user hasn't selected one, this one will be used.
  388.             if ( !strcmp(drivers[i].name,"xv2") ||
  389.                  (!vidpref && !strcmp(drivers[i].name,"xv"))) {
  390.                 if (vidpref) free(vidpref);
  391.                 vidpref=g_strdup(drivers[i].name);
  392.             }
  393.         }
  394.         if (!vidpref) vidpref=g_strdup("x11");
  395.  
  396.         gtk_combo_set_popdown_strings(combo, items);
  397.  
  398.         if( !options.video_driver_ptr ) options.video_driver_ptr = vidpref;
  399.         else                            if (vidpref) free(vidpref);
  400.  
  401.         gtk_entry_set_text(GTK_ENTRY(combo->entry),
  402.                            (const gchar*)options.video_driver_ptr);
  403.  
  404.     handle_simple_preferences(true);
  405.  
  406.     gtk_widget_show(preferences_window);
  407. }
  408.  
  409.  
  410. /* +-----------------------------------+
  411.  * | View Menu Related Functions       |
  412.  * +-----------------------------------+ */
  413. void
  414. on_menu_info_window_activate           (GtkMenuItem    *menuitem,
  415.                                         gpointer        user_data)
  416. {
  417.     if( TRUE == gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)) ) {
  418.         if( NULL == GOP_window ) {
  419.             GOP_window = GTK_WIDGET(create_GOP_window());
  420.         }
  421.  
  422.         gtk_widget_show(GOP_window);
  423.     } else {
  424.         gtk_widget_hide(GOP_window);
  425.     }
  426. }
  427.  
  428.  
  429. void
  430. on_menu_video_window_activate          (GtkMenuItem    *menuitem,
  431.                                         gpointer        user_data)
  432. {
  433.  
  434. }
  435.  
  436. /* +-----------------------------------+
  437.  * | Help Menu Related Functions       |
  438.  * +-----------------------------------+ */
  439. void
  440. on_menu_help_about_activate            (GtkMenuItem    *menuitem,
  441.                                         gpointer        user_data)
  442. {
  443.     static char buf[1024];
  444.     GtkWidget *label;
  445.  
  446.     if (!about_window)
  447.     {
  448.         about_window = create_about_window();
  449.  
  450.         // set version in window
  451.         snprintf(buf, 1023, _("GOPchop %s (%s)"), VERSION, __DATE__);
  452.         label = GTK_WIDGET(lookup_widget(GTK_WIDGET(about_window),
  453.                                          "about_label_version"));
  454.         gtk_label_set_text(GTK_LABEL(label), buf);
  455.  
  456.         label = GTK_WIDGET(lookup_widget(GTK_WIDGET(about_window),
  457.                                          "about_label_cvsid"));
  458.         gtk_label_set_text(GTK_LABEL(label), GOPchop_cvsid);
  459.     }
  460.  
  461.     gtk_widget_show(about_window);
  462. }
  463. /*
  464.  * #############################################################################
  465.  * ######################## End Menu Related Functions #########################
  466.  * #############################################################################
  467.  */
  468.  
  469.  
  470. /*
  471.  * #############################################################################
  472.  * ######################## Start FileSelection Related Functions ##############
  473.  * #############################################################################
  474.  */
  475.  
  476. /* +-----------------------------------+
  477.  * | Preferences Related Functions     |
  478.  * +-----------------------------------+ */
  479. void
  480. on_preferences_okbutton_clicked        (GtkButton       *button,
  481.                                         gpointer         user_data)
  482. {
  483.     const gchar     *string;
  484.     GtkCombo        *combo;
  485.  
  486.     // handle video mode selection
  487.     combo = GTK_COMBO(lookup_widget(GTK_WIDGET(preferences_window), "video_output_driver_combo" ));
  488.     string = gtk_entry_get_text(GTK_ENTRY(combo->entry));
  489.     options.video_driver_ptr = options.video_driver;
  490.     g_snprintf(options.video_driver_ptr, 24, "%s", string);
  491.     opt_videoout = options.video_driver_ptr;
  492.  
  493.     // load simple prefs from window
  494.     handle_simple_preferences(false);
  495.     
  496.     gtk_widget_hide(preferences_window);
  497.  
  498.     // preference setting side-effects
  499.     options.run_speed = options.default_run_speed;
  500.     gtk_range_set_value(GTK_RANGE(slider_run_speed), options.run_speed);
  501.     mpeg2parser->set_ignore_endcode(options.ignore_endcode);
  502.  
  503.     rc_save(PACKAGE,parsable_items);
  504. }
  505.  
  506. void
  507. on_preferences_cancelbutton_clicked    (GtkButton       *button,
  508.                                         gpointer         user_data)
  509. {
  510.     gtk_widget_hide(preferences_window);
  511. }
  512.  
  513. gboolean
  514. on_preferences_window_delete_event     (GtkWidget       *widget,
  515.                                         GdkEvent        *event,
  516.                                         gpointer         user_data)
  517. {
  518.     gtk_widget_hide(preferences_window);
  519.     return TRUE;
  520. }
  521.  
  522. void
  523. on_preferences_run_speed_slider_value_changed
  524.                                         (GtkRange        *range,
  525.                                         gpointer         user_data)
  526. {
  527.     gdouble value;
  528.     GtkSpinButton *spinner;
  529.     
  530.     value = gtk_range_get_value(range);
  531.     spinner = GTK_SPIN_BUTTON(lookup_widget(GTK_WIDGET(preferences_window), "default_run_speed_spinner" ));
  532.     gtk_spin_button_set_value(spinner, value);
  533. }
  534.  
  535. void
  536. on_preferences_run_speed_spinner_value_changed
  537.                                         (GtkSpinButton   *spinbutton,
  538.                                         gpointer         user_data)
  539. {
  540.     gdouble value;
  541.     GtkRange *range;
  542.  
  543.     value = gtk_spin_button_get_value(spinbutton);
  544.     range = GTK_RANGE(lookup_widget(GTK_WIDGET(preferences_window), "default_run_speed_slider"));
  545.     gtk_range_set_value( range, value );
  546. }
  547.  
  548.  
  549. /* +-----------------------------------+
  550.  * | New Related Functions             |
  551.  * +-----------------------------------+ */
  552. void
  553. on_new_file_okbutton_clicked           (GtkButton       *button,
  554.                                         gpointer         user_data)
  555. {
  556.     char *filename;
  557.  
  558.     gtk_widget_hide(new_file_window);
  559.     flush();
  560.  
  561.     filename = (char*)
  562.         gtk_file_selection_get_filename(GTK_FILE_SELECTION
  563.                                         (new_file_window));
  564.  
  565.     open_file(filename);
  566. }
  567.  
  568. void
  569. on_new_file_cancelbutton_clicked       (GtkButton       *button,
  570.                                         gpointer         user_data)
  571. {
  572.     gtk_widget_hide(new_file_window);
  573. }
  574.  
  575. void
  576. on_new_file_window_destroy             (GtkObject       *object,
  577.                                         gpointer         user_data)
  578. {
  579.     new_file_window = NULL;
  580. }
  581.  
  582. gboolean
  583. on_new_file_window_delete_event        (GtkWidget       *widget,
  584.                                         GdkEvent        *event,
  585.                                         gpointer         user_data)
  586. {
  587.     gtk_widget_hide(new_file_window);
  588.     return TRUE;
  589. }
  590.  
  591.  
  592. /* +-----------------------------------+
  593.  * | Open Related Functions            |
  594.  * +-----------------------------------+ */
  595. void
  596. on_open_file_okbutton_clicked          (GtkButton       *button,
  597.                                         gpointer         user_data)
  598. {
  599.     char *filename;
  600.     int   load_status;
  601.  
  602.     gtk_widget_hide(open_file_window);
  603.     flush();
  604.  
  605.     filename = (char*)
  606.         gtk_file_selection_get_filename(GTK_FILE_SELECTION
  607.                                         (open_file_window));
  608.  
  609.     load_status = load_session(filename);
  610.     if( SESSION_LOADED_OK == load_status ) {
  611.     } else {
  612.         show_error( error_to_string(load_status) );
  613.     }
  614. }
  615.  
  616. void
  617. on_open_file_cancelbutton_clicked      (GtkButton       *button,
  618.                                         gpointer         user_data)
  619. {
  620.     gtk_widget_hide(open_file_window);
  621. }
  622.  
  623. void
  624. on_open_file_window_destroy            (GtkObject       *object,
  625.                                         gpointer         user_data)
  626. {
  627.     open_file_window = NULL;
  628. }
  629.  
  630. gboolean
  631. on_open_file_window_delete_event       (GtkWidget       *widget,
  632.                                         GdkEvent        *event,
  633.                                         gpointer         user_data)
  634. {
  635.     gtk_widget_hide(open_file_window);
  636.     return TRUE;
  637. }
  638.  
  639.  
  640. /* +-----------------------------------+
  641.  * | Save Related Functions            |
  642.  * +-----------------------------------+ */
  643. void
  644. on_save_file_okbutton_clicked          (GtkButton       *button,
  645.                                         gpointer         user_data)
  646. {
  647.     gchar     *filename;
  648.     GtkWidget *dialog;
  649.  
  650.     gint result = GTK_RESPONSE_OK;
  651.  
  652.     filename = (char*)
  653.         gtk_file_selection_get_filename(GTK_FILE_SELECTION
  654.                                         (save_file_window));
  655.     if( !access(filename, F_OK) ) {
  656.         dialog = gtk_message_dialog_new(GTK_WINDOW(save_file_window),
  657.                                         GTK_DIALOG_DESTROY_WITH_PARENT,
  658.                                         GTK_MESSAGE_QUESTION,
  659.                                         GTK_BUTTONS_OK_CANCEL,
  660.                                         "File '%s' exists.  Overwrite?",
  661.                                         filename);
  662.         result = gtk_dialog_run( GTK_DIALOG(dialog) );
  663.         gtk_widget_destroy( dialog );
  664.     }
  665.  
  666.     gtk_widget_hide(save_file_window);
  667.     flush();
  668.  
  669.     if( GTK_RESPONSE_OK == result ) {
  670.         save_session( filename );
  671.     }
  672. }
  673.  
  674. void
  675. on_save_file_cancelbutton_clicked      (GtkButton       *button,
  676.                                         gpointer         user_data)
  677. {
  678.     gtk_widget_hide(save_file_window);
  679. }
  680.  
  681. gboolean
  682. on_save_file_window_delete_event       (GtkWidget       *widget,
  683.                                         GdkEvent        *event,
  684.                                         gpointer         user_data)
  685. {
  686.     gtk_widget_hide(save_file_window);
  687.     return TRUE;
  688. }
  689.  
  690.  
  691. /* +-----------------------------------+
  692.  * | Export Related Functions          |
  693.  * +-----------------------------------+ */
  694. void
  695. on_export_file_okbutton_clicked        (GtkButton       *button,
  696.                                         gpointer         user_data)
  697. {
  698.     gchar *filename;
  699.     GtkWidget *dialog;
  700.  
  701.     gint result = GTK_RESPONSE_OK;
  702.  
  703.     filename = (char*)
  704.         gtk_file_selection_get_filename(GTK_FILE_SELECTION
  705.                                         (export_file_window));
  706.  
  707.     if( !access(filename, F_OK) ) {
  708.         dialog = gtk_message_dialog_new(GTK_WINDOW(save_file_window),
  709.                                         GTK_DIALOG_DESTROY_WITH_PARENT,
  710.                                         GTK_MESSAGE_QUESTION,
  711.                                         GTK_BUTTONS_OK_CANCEL,
  712.                                         "File '%s' exists.  Overwrite?",
  713.                                         filename);
  714.         result = gtk_dialog_run( GTK_DIALOG(dialog) );
  715.         gtk_widget_destroy( dialog );
  716.     }
  717.  
  718.     gtk_widget_hide(export_file_window);
  719.     flush();
  720.  
  721.     if( GTK_RESPONSE_OK == result ) {
  722.         save_file(filename);
  723.     }
  724.  
  725. }
  726.  
  727.  
  728. void
  729. on_export_file_cancelbutton_clicked    (GtkButton       *button,
  730.                                         gpointer         user_data)
  731. {
  732.     gtk_widget_hide(export_file_window);
  733. }
  734.  
  735. void
  736. on_export_file_window_destroy          (GtkObject       *object,
  737.                                         gpointer         user_data)
  738. {
  739.     export_file_window = NULL;
  740. }
  741.  
  742. gboolean
  743. on_export_file_window_delete_event     (GtkWidget       *widget,
  744.                                         GdkEvent        *event,
  745.                                         gpointer         user_data)
  746. {
  747.     gtk_widget_hide(export_file_window);
  748.     return TRUE;
  749. }
  750. /*
  751.  * #############################################################################
  752.  * ######################## End FileSelection Related Functions ################
  753.  * #############################################################################
  754.  */
  755.  
  756. /*
  757.  * #############################################################################
  758.  * ######################## Start Main Window Related Functions ################
  759.  * #############################################################################
  760.  */
  761. void
  762. on_GOP_selector_value_changed          (GtkRange        *range,
  763.                                         gpointer         user_data)
  764. {
  765.     uint32_t GOP;
  766.  
  767.     GOP = (uint32_t) gtk_range_get_value(range);
  768.     gtk_spin_button_set_value(GTK_SPIN_BUTTON(GOP_selector_spinbutton), (gdouble)GOP);
  769.  
  770.     slider_updated_actions(GOP);
  771. }
  772.  
  773. void
  774. on_GOP_selector_spinbutton_value_changed
  775.                                         (GtkSpinButton   *spinbutton,
  776.                                         gpointer         user_data)
  777. {
  778.     uint32_t GOP;
  779.  
  780.     GOP = (uint32_t) gtk_spin_button_get_value(spinbutton);
  781.     gtk_range_set_value(GTK_RANGE(GOP_selector), (gdouble)GOP);
  782.  
  783.     slider_updated_actions(GOP);
  784. }
  785.  
  786. void
  787. on_slider_run_speed_value_changed      (GtkRange        *range,
  788.                                         gpointer         user_data)
  789. {
  790.     options.run_speed = (int) gtk_range_get_value(range);
  791. }
  792. /*
  793.  * #############################################################################
  794.  * ######################## End Main Window Related Functions ##################
  795.  * #############################################################################
  796.  */
  797.  
  798.  
  799. static gboolean run_saved_refresh = true;
  800. void on_button_run_toggled(GtkToggleButton * togglebutton, gpointer user_data)
  801. {
  802.     uint32_t GOPs, i;
  803.  
  804.     GOPs = mpeg2parser->numGOPs();
  805.     i = get_GOP_selected();
  806.  
  807.     if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(togglebutton))) {
  808.         // if you clicked "Run", you want to see it...
  809.         run_saved_refresh = options.auto_refresh;
  810.         options.auto_refresh = true;
  811.     }
  812.  
  813.     while (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(togglebutton)))
  814.     {
  815.         set_GOP_selected(i);
  816.         flush();
  817.         i = get_GOP_selected();
  818.         i+=options.run_speed;
  819.         if (i >= GOPs)
  820.         {
  821.             if (options.run_loop)
  822.                 i = 0;
  823.             else
  824.             {
  825.                 // flip back off now
  826.                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(togglebutton),
  827.                                              FALSE);
  828.                 flush();
  829.             }
  830.         }
  831.     }
  832.     flush();
  833.     display_flush(engine);
  834.  
  835.     options.auto_refresh = run_saved_refresh;
  836. }
  837.  
  838.  
  839. void on_about_window_destroy(GtkObject * object, gpointer user_data)
  840. {
  841.     about_window = NULL;
  842. }
  843.  
  844.  
  845. void on_about_button_cool_clicked(GtkButton * button, gpointer user_data)
  846. {
  847.     gtk_widget_hide(about_window);
  848.     gtk_widget_destroy(about_window);
  849. }
  850.  
  851.  
  852. void on_error_button_annoying_clicked(GtkButton * button, gpointer user_data)
  853. {
  854.     gtk_widget_hide(error_dialog);
  855. }
  856.  
  857. void
  858. on_button_start_mark_toggled           (GtkToggleButton *togglebutton,
  859.                                         gpointer         user_data)
  860. {
  861.     if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(togglebutton))) {
  862.         /* start mark */
  863.         char buf[128];
  864.         mark_start = get_GOP_selected();
  865.  
  866.         gtk_widget_set_sensitive(button_end_mark, TRUE);
  867.  
  868.         sprintf(buf, "%d", mark_start);
  869.         gtk_label_set_text(GTK_LABEL(main_label_mark), buf);
  870.     }
  871.     else {
  872.         /* undo start mark */
  873.         gtk_widget_set_sensitive(button_end_mark, FALSE);
  874.         gtk_label_set_text(GTK_LABEL(main_label_mark), "no mark set");
  875.     }
  876. }
  877.  
  878. void on_button_end_mark_clicked(GtkButton * button, gpointer user_data)
  879. {
  880.     mark_end = get_GOP_selected();
  881.  
  882.     if (mark_end >= mark_start)
  883.     {
  884.         gtk_widget_set_sensitive(button_end_mark, FALSE);
  885.         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_start_mark),
  886.                                      FALSE);
  887.  
  888.         gtk_label_set_text(GTK_LABEL(main_label_mark), "no mark set");
  889.  
  890.         add_GOP_slice(mark_start, mark_end);
  891.     }
  892.     else
  893.     {
  894.         // FIXME: do something to "flash" the startmark label
  895.     }
  896. }
  897.  
  898.  
  899. void on_button_refresh_clicked(GtkButton * button, gpointer user_data)
  900. {
  901.     show_GOP(engine,get_GOP_selected());
  902.     display_redraw(engine);
  903. }
  904.  
  905.  
  906. gboolean
  907. on_main_clist_key_press_event(GtkWidget * widget,
  908.                               GdkEventKey * event, gpointer user_data)
  909. {
  910.     GtkTreeSelection *selection;
  911.     GtkTreeIter       iter;
  912.  
  913.     selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
  914.     if (!gtk_tree_selection_get_selected(selection, NULL, &iter)) {
  915.         return FALSE; /* nothing selected: skip */
  916.     }
  917.  
  918.     switch (event->keyval)
  919.     {
  920.     case GDK_Delete:
  921.     case GDK_KP_Delete:
  922.     case GDK_BackSpace:
  923.         remove_GOP_slice(&iter);
  924.         return TRUE;
  925.     }
  926.     return FALSE;
  927. }
  928.  
  929.  
  930. gboolean
  931. on_main_clist_button_press_event(GtkWidget * widget,
  932.                                  GdkEventButton * event, gpointer user_data)
  933. {
  934.  
  935. #if 0
  936.     if (event->button == 3)     // right-click
  937.     {
  938.         main_popup_info.x = event->x;
  939.         main_popup_info.y = event->y;
  940.         gtk_menu_popup(GTK_MENU(main_popup), NULL, NULL, NULL,
  941.                        &main_popup_info, event->button, event->time);
  942.         return TRUE;
  943.     }
  944. #endif
  945.  
  946.     return FALSE;
  947. }
  948.  
  949.  
  950. void on_main_popup_delete_activate(GtkMenuItem * menuitem, gpointer user_data)
  951. {
  952.     gint row, col;
  953.     popup_info_t *info;
  954.  
  955.     fprintf( stderr, "on_main_popup_delete_activate\n" );
  956.  
  957.     if (info = (popup_info_t *) user_data)
  958.     {
  959.         gtk_clist_get_selection_info(GTK_CLIST(main_clist),
  960.                                      info->x, info->y, &row, &col);
  961.  
  962.         //printf("bloa! (x %d y %d is row %d col %d)\n");
  963.     }
  964.     else
  965.         printf("%s",
  966.                _("Oops.  NULL info in on_main_popup_delete_activate\n"));
  967.  
  968. }
  969.  
  970.  
  971. void on_save_file_window_destroy(GtkObject * object, gpointer user_data)
  972. {
  973.     save_file_window = NULL;
  974. }
  975.  
  976.  
  977. void on_button_next_clicked(GtkButton * button, gpointer user_data)
  978. {
  979.     set_GOP_selected(get_GOP_selected() + 1);
  980. }
  981.  
  982.  
  983. void on_button_prev_clicked(GtkButton * button, gpointer user_data)
  984. {
  985.     uint32_t gop;
  986.  
  987.     // don't wrap to the end
  988.     gop=get_GOP_selected();
  989.     if (gop>0) {
  990.         gop--;
  991.     }
  992.     set_GOP_selected(gop);
  993. }
  994.  
  995.  
  996. #if 0
  997. void
  998. on_menu_options_ignore_errors_activate(GtkMenuItem * menuitem,
  999.                                        gpointer user_data)
  1000. {
  1001.     options.ignore_errors=GTK_CHECK_MENU_ITEM(menuitem)->active;
  1002.     rc_save(PACKAGE,parsable_items);
  1003. }
  1004.  
  1005.  
  1006. void
  1007. on_menu_options_drop_orphaned_frames_activate
  1008.                                         (GtkMenuItem     *menuitem,
  1009.                                         gpointer         user_data)
  1010. {
  1011.     options.drop_orphaned_frames=GTK_CHECK_MENU_ITEM(menuitem)->active;
  1012.     rc_save(PACKAGE,parsable_items);
  1013. }
  1014.  
  1015.  
  1016.  
  1017. void
  1018. on_menu_options_adjust_timestamps_activate
  1019.                                         (GtkMenuItem     *menuitem,
  1020.                                         gpointer         user_data)
  1021. {
  1022.     options.adjust_timestamps=GTK_CHECK_MENU_ITEM(menuitem)->active;
  1023.     rc_save(PACKAGE,parsable_items);
  1024. }
  1025. #endif
  1026.  
  1027. gboolean
  1028. on_main_window_delete_event            (GtkWidget       *widget,
  1029.                                         GdkEvent        *event,
  1030.                                         gpointer         user_data)
  1031. {
  1032.     mpeg2parser->reset();
  1033.     gtk_main_quit();
  1034.  
  1035.     return FALSE;
  1036. }
  1037.  
  1038.  
  1039. gboolean
  1040. on_GOP_window_delete_event             (GtkWidget       *widget,
  1041.                                         GdkEvent        *event,
  1042.                                         gpointer         user_data)
  1043. {
  1044.     GtkWidget *menuitem;
  1045.  
  1046.     menuitem = GTK_WIDGET(lookup_widget(GTK_WIDGET(main_window), "menu_info_window"));
  1047.     gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(menuitem), FALSE );
  1048.     gtk_widget_hide(GOP_window);
  1049.     return TRUE;
  1050. }
  1051. /******************************************************************************/
  1052.