page_trim.cc

Go to the documentation of this file.

/*
* page_trim.cc Notebook Trim Page Object
* Copyright (C) 2001-2007 Dan Dennedy <dan@dennedy.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <iostream>
using std::cerr;
using std::endl;

#include <sys/time.h>
#include <sys/types.h>
#include <dirent.h>
#include <pthread.h>

#include "page_trim.h"
#include "avi.h"
#include "error.h"
#include "message.h"
#include "filehandler.h"
#include "frame.h"
#include "commands.h"
#include "page_editor.h"
#include "ieee1394io.h"

#undef PLAY_WITH_STATS

#define TRIM_ADJ_POS 0
#define TRIM_ADJ_IN 1
#define TRIM_ADJ_OUT 2

extern "C"
{
#include "support.h"

    extern KinoCommon *common;
    extern struct navigate_control g_nav_ctl;
    extern char cmd[];
    static char lastcmd[ 256 ] = { 0 };
    static int _getOneSecond( void );

    static void resetThreads( );
    static void *readThread( void * info );
    static void *videoThread( void * info );
    static void *audioThread( void * info );
    static pthread_t readthreadTrim;
    static pthread_t audiothreadTrim;
    static pthread_t videothreadTrim;
    static pthread_mutex_t threadlock = PTHREAD_MUTEX_INITIALIZER;
    static pthread_mutex_t readlock = PTHREAD_MUTEX_INITIALIZER;
    static GtkAdjustment *trim_adj[ 3 ];
    static gboolean skipPosUpdate = FALSE;
    static GtkSpinButton *spin_in;
    static GtkSpinButton *spin_out;
    static GtkToggleButton *link_toggle;
    static GtkToggleButton *loop_toggle;
    static gboolean doScrub = false;
    static int newFrame = 0;
    static int lastFrame = -1;

#define PLAYBACK_FRAMES 50

    static Frame *frameContent[ PLAYBACK_FRAMES ];
    extern IEEE1394Writer *writer1394;

    /* signal callbacks */
    gboolean
    on_trim_value_changed_event ( GtkWidget * widget,
                                  GdkEventButton * event,
                                  gpointer user_data )
    {
        int value = ( int ) GTK_ADJUSTMENT( widget ) ->value;
        if ( GTK_ADJUSTMENT( widget ) == trim_adj[ TRIM_ADJ_IN ] )
        {
            int diff = common->getPageTrim() ->getOutPoint() - common->getPageTrim() ->getInPoint() + value;

            if ( gtk_toggle_button_get_active( link_toggle ) == TRUE && skipPosUpdate == FALSE )
            {
                if ( diff <= common->getPageTrim() ->getTotalFrames() )
                {
                    if ( value >= common->getPageTrim() ->getOutPoint() )
                        gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_OUT ], value );
                    else
                        common->getPageTrim() ->setInPoint( value );

                    skipPosUpdate = TRUE;
                    gtk_spin_button_set_value( spin_out, ( gfloat ) diff );
                    skipPosUpdate = TRUE;
                    gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_OUT ], diff );
                }
                else
                {
                    skipPosUpdate = TRUE;
                    gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_IN ], common->getPageTrim() ->getInPoint() );
                }
            }
            else
            {
                if ( value > common->getPageTrim() ->getOutPoint() )
                    gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_OUT ], value );
                common->getPageTrim() ->setInPoint( value );
            }
            skipPosUpdate = TRUE;
            common->getPageTrim() ->movedToFrame( value );
            gtk_spin_button_set_value( spin_in, ( gfloat ) value );

        }
        else if ( GTK_ADJUSTMENT( widget ) == trim_adj[ TRIM_ADJ_OUT ] )
        {
            int diff = common->getPageTrim() ->getInPoint() - common->getPageTrim() ->getOutPoint() + value;

            if ( gtk_toggle_button_get_active( link_toggle ) == TRUE && skipPosUpdate == FALSE )
            {
                if ( diff >= 0 )
                {
                    if ( value <= common->getPageTrim() ->getInPoint() )
                        gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_IN ], value - 1 );
                    common->getPageTrim() ->setOutPoint( value );

                    skipPosUpdate = TRUE;
                    gtk_spin_button_set_value( spin_in, ( gfloat ) diff );
                    skipPosUpdate = TRUE;
                    gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_IN ], diff );
                }
                else
                {
                    skipPosUpdate = TRUE;
                    gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_OUT ], common->getPageTrim() ->getOutPoint() );
                }
            }
            else
            {
                if ( value < common->getPageTrim() ->getInPoint() )
                    gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_IN ], value );
                common->getPageTrim() ->setOutPoint( value );
            }
            skipPosUpdate = TRUE;
            common->getPageTrim() ->movedToFrame( value );
            gtk_spin_button_set_value( spin_out, ( gfloat ) value );

        }
        else if ( skipPosUpdate == FALSE )
        {
            skipPosUpdate = TRUE;
            common->getPageTrim() ->movedToFrame( value );
        }
        skipPosUpdate = FALSE;
        return FALSE;
    }

    void
    on_spinbutton_trim_in_value_changed ( GtkSpinButton * spinbutton,
                                          gpointer user_data )
    {
        if ( strcmp( gtk_entry_get_text( GTK_ENTRY( spin_in ) ), "" ) )
        {
            int value = atoi( gtk_entry_get_text( GTK_ENTRY( spin_in ) ) );
            gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_IN ], value );
        }
        gtk_entry_set_text( GTK_ENTRY( lookup_widget( GTK_WIDGET( spinbutton ), "entry_trim_in" ) ),
            common->getTime().parseFramesToString( ( int )gtk_spin_button_get_value( spinbutton ),
            common->getTimeFormat() ).c_str() );
    }

    void
    on_spinbutton_trim_out_value_changed ( GtkSpinButton * spinbutton,
                                           gpointer user_data )
    {
        if ( strcmp( gtk_entry_get_text( GTK_ENTRY( spin_out ) ), "" ) )
        {
            int value = atoi( gtk_entry_get_text( GTK_ENTRY( spin_out ) ) );
            gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_OUT ], value );
        }
        gtk_entry_set_text( GTK_ENTRY( lookup_widget( GTK_WIDGET( spinbutton ), "entry_trim_out" ) ),
            common->getTime().parseFramesToString( ( int )gtk_spin_button_get_value( spinbutton ),
            common->getTimeFormat() ).c_str() );
    }

    void
    on_button_trim_in_reset_clicked ( GtkButton * button,
                                      gpointer user_data )
    {
        gtk_widget_grab_focus( lookup_widget( GTK_WIDGET( button ), "eventbox_trim" ) );
        common->getPageTrim() ->resetInPoint();
    }

    void
    on_button_trim_out_reset_clicked ( GtkButton * button,
                                       gpointer user_data )
    {
        gtk_widget_grab_focus( lookup_widget( GTK_WIDGET( button ), "eventbox_trim" ) );
        common->getPageTrim() ->resetOutPoint();
    }

    void
    on_button_trim_in_set_clicked ( GtkButton * button,
                                    gpointer user_data )
    {
        int value = common->getPageTrim() ->getPosition();
        gtk_widget_grab_focus( lookup_widget( GTK_WIDGET( button ), "eventbox_trim" ) );
        gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_IN ], value );
    }

    void
    on_button_trim_out_set_clicked ( GtkButton * button,
                                     gpointer user_data )
    {
        int value = common->getPageTrim() ->getPosition();
        gtk_widget_grab_focus( lookup_widget( GTK_WIDGET( button ), "eventbox_trim" ) );
        gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_OUT ], value );
    }

    void
    on_togglebutton_trim_link_toggled ( GtkToggleButton * togglebutton,
                                        gpointer user_data )
    {
        gtk_widget_grab_focus( lookup_widget( GTK_WIDGET( togglebutton ), "eventbox_trim" ) );
        GtkImage *image = GTK_IMAGE( lookup_widget( GTK_WIDGET( togglebutton ), "pixmap_trim_link" ) );
        if ( gtk_toggle_button_get_active( togglebutton ) )
            gtk_image_set_from_file( image, DATADIR "/kino/link.xpm" );
        else
            gtk_image_set_from_file( image, DATADIR "/kino/link_off.xpm" );
    }

    gboolean
    on_spinbutton_trim_in_focus_in_event ( GtkWidget * widget,
                                           GdkEventFocus * event,
                                           gpointer user_data )
    {
        g_nav_ctl.escaped = TRUE;
        return FALSE;
    }

    gboolean
    on_spinbutton_trim_in_focus_out_event ( GtkWidget * widget,
                                            GdkEventFocus * event,
                                            gpointer user_data )
    {
        g_nav_ctl.escaped = FALSE;
        return FALSE;
    }

    gboolean
    on_spinbutton_trim_out_focus_in_event ( GtkWidget * widget,
                                            GdkEventFocus * event,
                                            gpointer user_data )
    {
        g_nav_ctl.escaped = TRUE;
        return FALSE;
    }


    gboolean
    on_spinbutton_trim_out_focus_out_event ( GtkWidget * widget,
            GdkEventFocus * event,
            gpointer user_data )
    {
        g_nav_ctl.escaped = FALSE;
        return FALSE;
    }

    gboolean
    on_trim_button_press_event ( GtkWidget * widget,
                                 GdkEventButton * event,
                                 gpointer user_data )
    {
        doScrub = TRUE;
        videoPause();
        return FALSE;
    }


    gboolean
    on_trim_button_release_event ( GtkWidget * widget,
                                   GdkEventButton * event,
                                   gpointer user_data )
    {
        doScrub = FALSE;
        return FALSE;
    }

    /* insert mode callbacks */

    gboolean
    on_combo_trim_clip_entry_focus_in_event( GtkWidget       *widget,
                                             GdkEventFocus   *event,
                                             gpointer         user_data)
    {
        g_nav_ctl.escaped = TRUE;
        return FALSE;
    }

    gboolean
    on_combo_trim_clip_entry_focus_out_event( GtkWidget       *widget,
                                              GdkEventFocus   *event,
                                              gpointer         user_data)
    {
        g_nav_ctl.escaped = FALSE;
        const gchar* filename = gtk_entry_get_text( GTK_ENTRY( widget ) );
        if ( strlen( filename ) )
        {
            switch ( common->checkFile( ( char* ) filename ) )
            {
                case AVI:
                case RAW_DV:
                case QT:
                    if ( common->getPageTrim()->loadFile( filename ) )
                        common->getPageTrim()->movedToFrame( common->getPageTrim()->getInPoint() );
                    break;
                default:
                    // XXX: the following is making gtk abort
                    //modal_message( _( "Invalid file specified." ) );
                    break;
            }
        }
        return FALSE;
    }

    void
    on_combo_trim_clip_entry_changed( GtkEditable     *editable,
                                      gpointer         user_data)
    {
        if ( g_nav_ctl.escaped == FALSE )
        {
            const gchar* filename = gtk_entry_get_text( GTK_ENTRY( lookup_widget( GTK_WIDGET( editable ), "entry_trim_clip" ) ) );
            if ( strlen( filename ) )
            {
                switch ( common->checkFile( ( char* ) filename ) )
                {
                    case AVI:
                    case RAW_DV:
                    case QT:
                        if ( common->getPageTrim()->loadFile( filename ) )
                        {
                            common->getPageTrim()->movedToFrame( common->getPageTrim()->getInPoint() );
                            break;
                        }
                    default:
                    {
                        const std::string& importedFile = common->importFile( filename );
                        if ( common->getPageTrim()->loadFile( const_cast<char*>( importedFile.c_str() ) ) )
                        {
                            gtk_entry_set_text( GTK_ENTRY( lookup_widget( GTK_WIDGET( editable ), "entry_trim_clip" ) ), const_cast<char*>( importedFile.c_str() ) );
                            common->getPageTrim()->movedToFrame( common->getPageTrim()->getInPoint() );
                        }
                        else
                        {
                            gtk_entry_set_text( GTK_ENTRY( lookup_widget( GTK_WIDGET( editable ), "entry_trim_clip" ) ), "" );
                        }
                        break;
                    }
                        // XXX: the following is making gtk abort
                        //modal_message( _( "Invalid file specified." ) );
//                      break;
                }
            }
        }
    }

    void
    on_button_trim_open_clicked( GtkButton       *button,
                                 gpointer         user_data)
    {
        char *filename = common->getFileToOpen( _("Choose a DV file") );
        if ( filename && strcmp( filename, "" ) )
        {
            gtk_entry_set_text( GTK_ENTRY( lookup_widget( GTK_WIDGET( button ), "entry_trim_clip" ) ),
                filename );
        }
    }

    void
    on_button_trim_insert_before_clicked( GtkButton       *button,
                                          gpointer         user_data)
    {
        gtk_widget_grab_focus( lookup_widget( GTK_WIDGET( button ), "eventbox_trim" ) );
        common->getPageTrim()->insertScene( TRIM_INSERT_MODE_BEFORE );
    }

    void
    on_button_trim_insert_after_clicked( GtkButton       *button,
                                         gpointer         user_data)
    {
        gtk_widget_grab_focus( lookup_widget( GTK_WIDGET( button ), "eventbox_trim" ) );
        common->getPageTrim()->insertScene( TRIM_INSERT_MODE_AFTER );
    }

    void
    on_menuitem_trim_update_activate( GtkMenuItem     *menuitem,
                                      gpointer         user_data)
    {
        gtk_widget_grab_focus( lookup_widget( GTK_WIDGET( menuitem ), "eventbox_trim" ) );
        common->getPageTrim()->setMode( PAGE_TRIM_MODE_UPDATE );
    }

    void
    on_menuitem_trim_insert_activate( GtkMenuItem     *menuitem,
                                      gpointer         user_data)
    {
        gtk_widget_grab_focus( lookup_widget( GTK_WIDGET( menuitem ), "eventbox_trim" ) );
        common->getPageTrim()->setMode( PAGE_TRIM_MODE_INSERT );
    }

    void
    on_button_trim_apply_clicked( GtkButton       *button,
                                  gpointer         user_data)
    {
        gtk_widget_grab_focus( lookup_widget( GTK_WIDGET( button ), "eventbox_trim" ) );
        processCommand( "Enter" );
    }
    
    void
    on_entry_trim_in_activate              (GtkEntry        *entry,
                                            gpointer         user_data)
    {
        common->getTime().parseValueToString( gtk_entry_get_text( entry ), common->getTimeFormat() );
        GtkSpinButton *spinbutton = GTK_SPIN_BUTTON( lookup_widget( GTK_WIDGET( entry ), "spinbutton_trim_in" ) );
        gtk_spin_button_set_value( spinbutton, common->getTime().getFrames() );
        on_spinbutton_trim_in_value_changed( spinbutton, NULL );
    }
    
    gboolean
    on_entry_trim_in_focus_out_event       (GtkWidget       *widget,
                                            GdkEventFocus   *event,
                                            gpointer         user_data)
    {
        on_entry_trim_in_activate( GTK_ENTRY( widget ), NULL );
        g_nav_ctl.escaped = FALSE;
        return FALSE;
    }
    
    void
    on_entry_trim_out_activate             (GtkEntry        *entry,
                                            gpointer         user_data)
    {
        common->getTime().parseValueToString( gtk_entry_get_text( entry ), common->getTimeFormat() );
        GtkSpinButton *spinbutton = GTK_SPIN_BUTTON( lookup_widget( GTK_WIDGET( entry ), "spinbutton_trim_out" ) );
        gtk_spin_button_set_value( spinbutton, common->getTime().getFrames() );
        on_spinbutton_trim_out_value_changed( spinbutton, NULL );
    }
    
    gboolean
    on_entry_trim_out_focus_out_event      (GtkWidget       *widget,
                                            GdkEventFocus   *event,
                                            gpointer         user_data)
    {
        on_entry_trim_out_activate( GTK_ENTRY( widget ), NULL );
        g_nav_ctl.escaped = FALSE;
        return FALSE;
    }

}

GArray *scenes = NULL;
PageTrim::PageTrim( KinoCommon *common ) :
        start_orig( 0 ), update_start(0), end_orig( 0 ), in_orig( 0 ), out_orig( 0 ), in( 0 ), out( 0 ),
        max( 0 ), pos( -1 ), currentScene( 0 ), lastPos( -1 ), mode( PAGE_TRIM_MODE_UNKNOWN ),
        changed( false )
{
    cerr << "> Creating page trim" << endl;
    this->common = common;
    this->frameArea = GTK_DRAWING_AREA( lookup_widget( common->getWidget(), "drawingarea_trim" ) );
    gtk_widget_set_double_buffered( GTK_WIDGET( frameArea ), FALSE );
    this->positionLabelCurrent = GTK_LABEL( lookup_widget( common->getWidget(), "position_label_current" ) );
    this->positionLabelTotal = GTK_LABEL( lookup_widget( common->getWidget(), "position_label_total" ) );
    spin_in = GTK_SPIN_BUTTON( lookup_widget( common->getWidget(), "spinbutton_trim_in" ) );
    spin_out = GTK_SPIN_BUTTON( lookup_widget( common->getWidget(), "spinbutton_trim_out" ) );
    link_toggle = GTK_TOGGLE_BUTTON( lookup_widget( common->getWidget(), "togglebutton_trim_link" ) );
    loop_toggle = GTK_TOGGLE_BUTTON( lookup_widget( common->getWidget(), "togglebutton_trim_loop" ) );

    this->g_copiedPlayList = new PlayList();

    // Attach the custom GTK+ Trim control
    trim_adj[ TRIM_ADJ_POS ] = GTK_ADJUSTMENT(
                                   gtk_adjustment_new( 0, 0, 0, 1, 10, 0 ) );
    trim_adj[ TRIM_ADJ_IN ] = GTK_ADJUSTMENT(
                                  gtk_adjustment_new( 0, 0, 0, 1, 10, 0 ) );
    trim_adj[ TRIM_ADJ_OUT ] = GTK_ADJUSTMENT(
                                   gtk_adjustment_new( 0, 0, 0, 1, 10, 0 ) );
    for ( int i = 0; i < 3; i++ )
        g_signal_connect ( G_OBJECT ( trim_adj[ i ] ), "value_changed",
                           G_CALLBACK( on_trim_value_changed_event ), ( gpointer ) i );
    trim = gtk_enhanced_scale_new( ( GtkObject** ) trim_adj, 3 );
    gtk_widget_set_name ( trim, "trim" );
    gtk_widget_ref( trim );
    gtk_object_set_data_full ( GTK_OBJECT( common->getWidget() ), "trim", trim,
                               ( GtkDestroyNotify ) gtk_widget_unref );
    GtkWidget *vbox_trim = lookup_widget( common->getWidget(), "vbox_trim_custom" );
    gtk_widget_show( trim );
    gtk_box_pack_start( GTK_BOX ( vbox_trim ), trim, FALSE, TRUE, 0 );
    g_signal_connect( G_OBJECT( trim ), "button_press_event",
                      G_CALLBACK( on_trim_button_press_event ), NULL );
    g_signal_connect( G_OBJECT( trim ), "button_release_event",
                      G_CALLBACK( on_trim_button_release_event ), NULL );
}

PageTrim::~PageTrim( )
{
    cerr << "> Destroying page trim" << endl;
    delete this->g_copiedPlayList;
}

void PageTrim::newFile()
{
    this->stopNavigator();
}

void PageTrim::start()
{
    cerr << ">> Starting Trimmer" << endl;

    start_orig = update_start = end_orig = in = in_orig = out = out_orig = max = 0;

    for ( int i = 0; i < PLAYBACK_FRAMES; i ++ )
        frameContent[ i ] = GetFramePool( ) ->GetFrame( );

    this->displayer = new FrameDisplayer();
    if ( Preferences::getInstance().dv1394Preview )
    {
#ifdef HAVE_IEC61883
        AVC avc;
        Preferences::getInstance( ).phyID = avc.getNodeId( Preferences::getInstance( ).avcGUID );
        Preferences::getInstance( ).phyID = avc.isPhyIDValid( Preferences::getInstance( ).phyID );
        if ( !writer1394 )
            writer1394 = new iec61883Writer(
                         ( avc.getPort() < 0 ) ? 0 : avc.getPort(),
                         Preferences::getInstance().channel,
                         2 );
#endif
#ifdef HAVE_DV1394
        if ( Preferences::getInstance().dvExportDevice > 0 && !writer1394 )
            writer1394 = new dv1394Writer(
                         Preferences::getInstance().dvExportDevice,
                         Preferences::getInstance().channel,
                         2,
                         Preferences::getInstance().cip_n,
                         Preferences::getInstance().cip_d,
                         Preferences::getInstance().syt_offset );
#endif
    }

    if ( ! Preferences::getInstance().trimModeInsert && common->g_currentFrame > -1 )
        setMode( PAGE_TRIM_MODE_UPDATE );
    else
        setMode( PAGE_TRIM_MODE_INSERT );

    if ( common->getPlayList() ->GetNumFrames() > 0 )
    {
        // Load the current scene
        loadScene( common->g_currentFrame );
        lastPos = pos = in + common->g_currentFrame - start_orig;
        movedToFrame( pos );

        // Load the clip combo
        GList *items = NULL;
        map<string, FileHandler*>::iterator n;
        for ( n = GetFileMap()->GetMap().begin(); n != GetFileMap()->GetMap().end(); ++n )
            items = g_list_append( items, ( void* ) n->first.c_str() );
        g_nav_ctl.escaped = TRUE;
        gtk_combo_set_popdown_strings( GTK_COMBO( lookup_widget( common->getWidget(), "combo_trim_clip" ) ), items);
        gtk_entry_set_text( GTK_ENTRY( lookup_widget( common->getWidget(), "entry_trim_clip" ) ), "" );
        g_nav_ctl.escaped = FALSE;
    }

    gtk_widget_grab_focus( GTK_WIDGET( frameArea ) );
    common->packIt( "packer_trim", "packer_trim_outer" );

    gtk_notebook_set_page( GTK_NOTEBOOK( lookup_widget( common->getWidget(), "notebook_keyhelp" ) ), 2 );
    gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( lookup_widget( common->getWidget(), "menuitem_trim" ) ), TRUE );
}

gulong PageTrim::activate()
{
    return EDIT_MENU |
           SCENE_LIST |
           VIDEO_START_OF_MOVIE |
           VIDEO_START_OF_SCENE |
           VIDEO_REWIND |
           VIDEO_BACK |
           VIDEO_PLAY |
           VIDEO_PAUSE |
           VIDEO_STOP |
           VIDEO_FORWARD |
           VIDEO_FAST_FORWARD |
           VIDEO_NEXT_SCENE |
           VIDEO_END_OF_MOVIE |
           VIDEO_SHUTTLE |
           INFO_FRAME;
}

void PageTrim::clean()
{
    cerr << ">> Leaving Trimmer" << endl;
    stopNavigator();
    delete displayer;
    displayer = 0;
    delete writer1394;
    writer1394 = NULL;
    saveScene();
    for ( int i = 0; i < PLAYBACK_FRAMES; i ++ )
        GetFramePool( ) ->DoneWithFrame( frameContent[ i ] );

    cerr << ">> Left Trimmer" << endl;
}


void PageTrim::loadScene( int newScene )
{
    char value[ 20 ];
    PlayList newPlayList;
    playlist = newPlayList;
    PlayList *pl = common->getPlayList();
    FileHandler *media;

    currentScene = newScene;

    // first, save begin and end time markers to region of the
    // the whole movie that this scene represents
    update_start = start_orig = pl->FindStartOfScene( currentScene );
    end_orig = pl->FindEndOfScene( currentScene );

    // get a local playlist representing just the scene
    // based on time markers in the movie
    pl->GetPlayList( start_orig, end_orig, playlist );

    // set the in point and current position to the in point
    // of the first clip in the scene
    in = in_orig = lastPos = pos = pl->GetClipBegin( currentScene );

    // unwind the clip at the beginning of the scene
    playlist.SetClipBegin( 0, "0" );

    // get the clip at the end of the scene
    playlist.GetMediaObject( playlist.FindEndOfScene( 0 ), &media );

    // unwind the clip at the end of the scene
    // XXX: what about frames deleted from the beginning or middle
    // of a multi-clip scene?
    int prevClipEnd = playlist.GetClipEnd( playlist.GetNumFrames() - 1 );
    int newClipEnd = media->GetTotalFrames() - 1;
    snprintf( value, 19, "%i", newClipEnd );
    playlist.SetClipEnd( playlist.GetNumFrames() - 1, value );

    // get the total number of frames now in the local playlist
    max = playlist.GetNumFrames() - 1;

    // set the out point to the difference between out point before
    // and after unwinding
    out = out_orig = max - ( newClipEnd - prevClipEnd );

    // inform controller of our scene change
    common->setCurrentScene( start_orig );

    // update the trim UI
    trim_adj[ TRIM_ADJ_IN ] ->upper = max;
    trim_adj[ TRIM_ADJ_IN ] ->value = in;
    g_signal_emit_by_name( trim_adj[ TRIM_ADJ_IN ], "changed" );
    trim_adj[ TRIM_ADJ_OUT ] ->upper = max;
    trim_adj[ TRIM_ADJ_OUT ] ->value = out;
    g_signal_emit_by_name( trim_adj[ TRIM_ADJ_OUT ], "changed" );
    trim_adj[ TRIM_ADJ_POS ] ->upper = max;
    g_signal_emit_by_name( trim_adj[ TRIM_ADJ_POS ], "changed" );

    // Recalibrate the spinners
    GtkAdjustment *adjust = gtk_spin_button_get_adjustment( spin_in );
    adjust->lower = 0;
    adjust->upper = max;
    adjust->value = in;
    g_signal_emit_by_name( adjust, "changed" );
    gtk_spin_button_set_value( spin_in, ( gfloat ) in );

    adjust = gtk_spin_button_get_adjustment( spin_out );
    adjust->lower = 0;
    adjust->upper = max;
    adjust->value = out;
    g_signal_emit_by_name( adjust, "changed" );
    gtk_spin_button_set_value( spin_out, ( gfloat ) out );

    g_nav_ctl.escaped = TRUE;
    gtk_entry_set_text( GTK_ENTRY( lookup_widget( common->getWidget(), "entry_trim_clip" ) ), "" );
    g_nav_ctl.escaped = FALSE;

    timeFormatChanged();
}


void PageTrim::saveScene()
{
    if ( playlist.GetNumFrames() && ( in_orig != in || out_orig != out || changed ) )
    {
        // commit out point to local playlist
        playlist.Delete( out + 1, max );
        // commmit in point to local playlist
        playlist.Delete( 0, in - 1 );
        // delete the original scene from the movie
        common->getPlayList() ->Delete( start_orig, end_orig );
        // insert the revised scene (local playlist) into the movie
        // at the saved begin time marker
        common->getPlayList() ->InsertPlayList( playlist, start_orig );

        changed = false;

        // put into undo history
        GetEditorBackup() ->Store( common->getPlayList() );

        // update commons and other views (title bar and storyboard)
        common->hasListChanged = TRUE;
        common->setWindowTitle( );
        common->getPageEditor()->DrawBar( common->g_currentFrame );

        // Refresh the combo menu
        GList *items = NULL;
        map<string, FileHandler*>::iterator n;
        for ( n = GetFileMap()->GetMap().begin(); n != GetFileMap()->GetMap().end(); ++n )
            items = g_list_append( items, ( void* ) n->first.c_str() );
        g_nav_ctl.escaped = TRUE;
        gtk_combo_set_popdown_strings( GTK_COMBO( lookup_widget( common->getWidget(), "combo_trim_clip" ) ), items);
        g_nav_ctl.escaped = FALSE;
    }
}


bool PageTrim::loadFile( const string& filename )
{
    PlayList newList;
    bool result = true;

    try
    {
        if ( newList.LoadMediaObject( const_cast< char* >( filename.c_str() ) ) )
        {
            playlist = newList;
            start_orig = common->getPlayList()->FindStartOfScene( currentScene );
            end_orig = common->getPlayList()->FindEndOfScene( currentScene );
            in = in_orig = lastPos = pos = 0;
            out = out_orig = max = playlist.GetNumFrames() - 1;
            changed = true;

            trim_adj[ TRIM_ADJ_IN ] ->upper = max;
            trim_adj[ TRIM_ADJ_IN ] ->value = in;
            g_signal_emit_by_name( trim_adj[ TRIM_ADJ_IN ], "changed" );
            trim_adj[ TRIM_ADJ_OUT ] ->upper = max;
            trim_adj[ TRIM_ADJ_OUT ] ->value = out;
            g_signal_emit_by_name( trim_adj[ TRIM_ADJ_OUT ], "changed" );
            trim_adj[ TRIM_ADJ_POS ] ->upper = max;
            g_signal_emit_by_name( trim_adj[ TRIM_ADJ_POS ], "changed" );

            GtkAdjustment *adjust = gtk_spin_button_get_adjustment( spin_in );
            adjust->lower = 0;
            adjust->upper = max;
            adjust->value = in;
            g_signal_emit_by_name( adjust, "changed" );
            gtk_spin_button_set_value( spin_in, ( gfloat ) in );

            adjust = gtk_spin_button_get_adjustment( spin_out );
            adjust->lower = 0;
            adjust->upper = max;
            adjust->value = out;
            g_signal_emit_by_name( adjust, "changed" );
            gtk_spin_button_set_value( spin_out, ( gfloat ) out );
            
            timeFormatChanged();
        }
        else
        {
            // XXX: the following is making gtk abort
            // modal_message( _( "Failed to load media file." ) );
            result = false;
        }
    }
    catch ( string s )
    {
        cerr << "Could not load file " << filename << ", because an exception has occurred: " << endl;
        cerr << s << endl;
        result = false;
    }

    return result;
}


void PageTrim::insertScene( TrimInsertMode insertMode )
{
    if ( playlist.GetNumFrames() > 0 )
    {
        int i = getSceneIndex();

        if ( insertMode == TRIM_INSERT_MODE_BEFORE )
        {
            PlayList tmp;
            tmp = playlist;
            tmp.Delete( out + 1, max );
            tmp.Delete( 0, in - 1 );
            common->getPlayList()->InsertPlayList( tmp, start_orig );
        }
        else if ( insertMode == TRIM_INSERT_MODE_AFTER )
        {
            PlayList tmp;
            tmp = playlist;
            tmp.Delete( out + 1, max );
            tmp.Delete( 0, in - 1 );
            common->getPlayList()->InsertPlayList( tmp, end_orig + 1 );
            i++;
        }
        GetEditorBackup()->Store( common->getPlayList() );
        common->hasListChanged = TRUE;
        common->setWindowTitle( );
        common->getPageEditor()->DrawBar( common->g_currentFrame );
        selectScene( i );
        common->setCurrentScene( start_orig );

        // Refresh the combo menu
        GList *items = NULL;
        const char *filename = gtk_entry_get_text( GTK_ENTRY( lookup_widget( GTK_WIDGET( common->getWidget() ), "entry_trim_clip" ) ) );
        map<string, FileHandler*>::iterator n;
        items = g_list_append( items, ( void* ) filename );
        for ( n = GetFileMap()->GetMap().begin(); n != GetFileMap()->GetMap().end(); ++n )
            if ( strcmp( n->first.c_str(), filename ) )
                items = g_list_append( items, ( void* ) n->first.c_str() );
        g_nav_ctl.escaped = TRUE;
        gtk_combo_set_popdown_strings( GTK_COMBO( lookup_widget( common->getWidget(), "combo_trim_clip" ) ), items);
        g_nav_ctl.escaped = FALSE;
    }
}


void PageTrim::setMode( PageTrimMode newMode )
{
    if ( newMode != mode )
    {
        if ( newMode == PAGE_TRIM_MODE_UPDATE && common->getPlayList()->GetNumFrames() > 0 )
        {
            mode = newMode;
            gtk_widget_show( lookup_widget( common->getWidget(), "hbox_trim_update" ) );
            gtk_widget_hide( lookup_widget( common->getWidget(), "hbox_trim_insert" ) );

            // Load the currently selected scene
            gfloat saved_in = in;
            gfloat saved_out = out;
            loadScene( update_start );
            gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_IN ], saved_in );
            gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_OUT ], saved_out );
        }
        else if ( newMode == PAGE_TRIM_MODE_INSERT )
        {
            mode = newMode;
            gtk_widget_hide( lookup_widget( common->getWidget(), "hbox_trim_update" ) );
            gtk_widget_show( lookup_widget( common->getWidget(), "hbox_trim_insert" ) );
        }

        // initialize insert mode controls for edit mode
        gtk_option_menu_set_history( GTK_OPTION_MENU( lookup_widget( common->getWidget(), "optionmenu_trim" ) ), static_cast< int >( mode ) );
    }
}

void PageTrim::startNavigator()
{
    stopNavigator( );
    g_nav_ctl.active = TRUE;
    resetThreads( );
    pthread_create( &readthreadTrim, NULL, readThread, &g_nav_ctl );
    pthread_create( &audiothreadTrim, NULL, audioThread, &g_nav_ctl );
    pthread_create( &videothreadTrim, NULL, videoThread, ( gpointer ) & g_nav_ctl );
}

void PageTrim::stopNavigator()
{
    if ( g_nav_ctl.active )
    {
        g_nav_ctl.active = FALSE;
        gdk_threads_leave();
        pthread_join( readthreadTrim, NULL );
        pthread_join( audiothreadTrim, NULL );
        pthread_join( videothreadTrim, NULL );
        gdk_threads_enter();
        getFrameDisplayer()->CloseSound();
    }
}

void PageTrim::movedToFrame( int frame )
{
    if ( common->hasListChanged == TRUE )
    {
        common->getPageEditor()->ResetBar();
        common->hasListChanged = FALSE;

        if ( mode == PAGE_TRIM_MODE_UPDATE &&
            common->getPlayList() ->GetNumFrames() > 0 )
        {
            loadScene( frame );
            frame = in;
        }
        else if ( mode == PAGE_TRIM_MODE_INSERT )
        {
            const char *file = gtk_entry_get_text( GTK_ENTRY( lookup_widget( GTK_WIDGET( common->getWidget() ), "entry_trim_clip" ) ) );
            if ( file && strcmp( file, "" ) )
            {
                loadFile( file );
                frame = pos;
            }
        }
    }
    if ( max > 0 )
    {
        if ( frame > out && gtk_toggle_button_get_active( loop_toggle ) == TRUE )
            pos = in;
        else if ( frame < in && gtk_toggle_button_get_active( loop_toggle ) == TRUE )
            pos = out;
        else if ( frame >= 0 && frame <= max )
            pos = frame;
        else if ( frame >= max )
            pos = max;
        else if ( frame < 0 && max > 0 )
            pos = 0;
        else
            pos = -1;

        if ( g_nav_ctl.active == FALSE )
        {
            skipPosUpdate = FALSE;
            showFrame( pos, ( pos == lastPos ) || ( Preferences::getInstance().audioScrub == FALSE ) );
        }
        else
        {
            lastFrame = newFrame = pos;
            startNavigator();
        }
    }
}

void PageTrim::showFrame( int i, gboolean no_audio )
{
    if ( max == 0 )
    {
        common->loadSplash( frameArea );
        common->showFrameInfo( -1 );
        return ;
    }
    else if ( i > -1 )
    {
        Frame & frame = *( GetFramePool( ) ->GetFrame( ) );
        if ( i > max )
            i = max;
        playlist.GetFrame( i, frame );
        common->showFrameInfo( i );
        if ( writer1394 != NULL )
            writer1394->SendFrame( frame, false );
        if ( getFrameDisplayer() )
            getFrameDisplayer() ->Put( frame, GTK_WIDGET( frameArea ), no_audio );
        lastPos = i;
        gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_POS ], ( gfloat ) i );
        GetFramePool( ) ->DoneWithFrame( &frame );
        common->g_currentFrame = start_orig + (pos - in_orig);
    }
}


void PageTrim::showFrame( int position, Frame& frame )
{
    if ( max == 0 )
    {
        common->loadSplash( frameArea );
    }
    else
    {
        getFrameDisplayer() ->Put( frame, GTK_WIDGET( frameArea ), TRUE );
        common->showFrameInfo( position );
        skipPosUpdate = TRUE;
        gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_POS ], ( gfloat ) position );
    }
}


void PageTrim::videoStartOfMovie()
{
    movedToFrame( 0 );
    common->toggleComponents( VIDEO_START_OF_MOVIE, false );
}

void PageTrim::videoPreviousScene()
{
    movedToFrame( in );
    common->toggleComponents( VIDEO_START_OF_SCENE, false );
}

void PageTrim::videoStartOfScene()
{
    movedToFrame( in );
    common->toggleComponents( VIDEO_START_OF_SCENE, false );
}

void PageTrim::videoRewind()
{
    common->toggleComponents( common->getComponentState(), false );

    // Toggle Rewind state
    if ( g_nav_ctl.step != -10 )
    {
        common->toggleComponents( VIDEO_REWIND, true );
        g_nav_ctl.step = -10;
        g_nav_ctl.rate = 0;
        startNavigator();
    }
    else
    {
        stopNavigator();
        g_nav_ctl.step = 1;
        g_nav_ctl.rate = 1;
        common->toggleComponents( VIDEO_REWIND, false );
        common->toggleComponents( VIDEO_STOP, true );
    }
}

void PageTrim::videoBack(int step)
{
    common->toggleComponents( common->getComponentState(), false );
    if ( g_nav_ctl.active )
    {
        if ( g_nav_ctl.step != -1 )
        {
            g_nav_ctl.step = -1;
            g_nav_ctl.rate = 1;
            common->toggleComponents( VIDEO_BACK, true );
        }
        else
        {
            stopNavigator();
            g_nav_ctl.step = 1;
            g_nav_ctl.rate = 0;
            common->toggleComponents( VIDEO_BACK, false );
            common->toggleComponents( VIDEO_STOP, true );
        }
    }
    else
    {
        common->moveByFrames( step );
        common->toggleComponents( VIDEO_BACK, false );
        common->toggleComponents( VIDEO_STOP, true );
    }
}

void PageTrim::videoPlay()
{
    common->toggleComponents( common->getComponentState(), false );
    if ( g_nav_ctl.active == FALSE || g_nav_ctl.step != 1 )
    {
        common->toggleComponents( VIDEO_PLAY, true );
        g_nav_ctl.step = 1;
        startNavigator();
    }
    else
    {
        stopNavigator();
        common->toggleComponents( VIDEO_PLAY, false );
        common->toggleComponents( VIDEO_STOP, true );
    }
}

void PageTrim::videoPause()
{
    common->toggleComponents( common->getComponentState(), false );
    common->toggleComponents( VIDEO_STOP, true );
    stopNavigator();
}

void PageTrim::videoStop()
{
    common->toggleComponents( common->getComponentState(), false );
    common->toggleComponents( VIDEO_STOP, true );
    stopNavigator();
}

void PageTrim::videoForward(int step)
{
    common->toggleComponents( common->getComponentState(), false );
    if ( g_nav_ctl.active && g_nav_ctl.step != 1 )
    {
        g_nav_ctl.step = 1;
        g_nav_ctl.rate = 1;
        common->toggleComponents( VIDEO_FORWARD, true );
        startNavigator();
    }
    else
    {
        stopNavigator();
        common->moveByFrames( step );
        common->toggleComponents( VIDEO_FORWARD, false );
        common->toggleComponents( VIDEO_STOP, true );
    }
}

void PageTrim::videoFastForward()
{
    common->toggleComponents( common->getComponentState(), false );

    if ( g_nav_ctl.step != 10 )
    {
        common->toggleComponents( VIDEO_FAST_FORWARD, true );
        g_nav_ctl.step = 10;
        g_nav_ctl.rate = 0;
        startNavigator();
    }
    else
    {
        stopNavigator();
        g_nav_ctl.step = 1;
        g_nav_ctl.rate = 1;
        common->toggleComponents( VIDEO_FAST_FORWARD, false );
        common->toggleComponents( VIDEO_STOP, true );
    }
}

void PageTrim::videoShuttle( int angle )
{
    int frames_sec = _getOneSecond();
    int speedTable[] = {
            0,
            8,  10, 15, 20, 33, 50, 75,
            100,
            200, 300, 400, 500, 800, 1200,
            ( frames_sec * 100 ) };
    char s[ 64 ];

    if ( angle < -15 )
        angle = -15;
    if ( angle > 15 )
        angle = 15;

    int speed = speedTable[ ( angle < 0 ) ? -angle : angle ] * ( ( angle < 0 ) ? -1 : 1 );
    if ( speed == 0 || g_nav_ctl.step != speed / 100 || g_nav_ctl.rate != 100 / speed )
    {
        stopNavigator( );
        if ( speed == 0 )
        {
            common->keyboardFeedback( "", "" );
            common->toggleComponents( VIDEO_STOP, true );
        }
        else
        {
            g_nav_ctl.step = speed / 100;
            g_nav_ctl.rate = 100 / speed;
            g_nav_ctl.subframe = 0;
            startNavigator();
            snprintf( s, 63, _( "Shuttle %+.1f fps" ), ( float ) speed / 100.0 * frames_sec );
            common->keyboardFeedback( "", s );
        }
    }
}

void PageTrim::videoNextScene()
{
    movedToFrame( out );
    common->toggleComponents( VIDEO_NEXT_SCENE, false );
}

void PageTrim::videoEndOfScene()
{
    movedToFrame( out );
    common->toggleComponents( VIDEO_NEXT_SCENE, false );
}

void PageTrim::videoEndOfMovie()
{
    common->toggleComponents( common->getComponentState(), false );
    common->toggleComponents( VIDEO_END_OF_MOVIE, true );
    stopNavigator();
    movedToFrame( max );
    common->toggleComponents( VIDEO_END_OF_MOVIE, false );
    common->toggleComponents( VIDEO_STOP, true );
}

void PageTrim::selectScene( int i )
{
    bool restartNavigator = ( g_nav_ctl.active == TRUE );
    
    stopNavigator();
    
    if ( mode == PAGE_TRIM_MODE_UPDATE )
        // commit the changes and load a new scene
        saveScene();

    // figure out what scene I am in
    vector <int> scene = common->getPageEditor() ->GetScene();
    if ( i >= ( int ) scene.size() )
        i = scene.size() - 1;
    currentScene = ( i <= 0 ) ? 0 : scene[ i - 1 ];
    common->g_currentFrame = currentScene;

    if ( mode == PAGE_TRIM_MODE_UPDATE )
    {
        loadScene( currentScene );
        movedToFrame( in );
    }
    else if ( mode == PAGE_TRIM_MODE_INSERT )
    {
        // set the insertion points
        start_orig = common->getPlayList()->FindStartOfScene( currentScene );
        end_orig = common->getPlayList()->FindEndOfScene( currentScene );

        common->setCurrentScene( start_orig );
    }
    
    if ( restartNavigator )
        startNavigator();
}

int PageTrim::getSceneIndex()
{
    int i = 0;
    if ( common->getPlayList()->GetNumFrames() > 0 )
    {
        vector <int> scene = common->getPageEditor() ->GetScene();
        for ( i = 0; i < (int) scene.size() - 1; i++ )
            if ( currentScene < scene[ i ] )
                break;
    }
    else
    {
        i = -1;
    }
    return i;
}

void PageTrim::resetInPoint()
{
    in = in_orig;
    gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_IN ], ( gfloat ) in );
    gtk_spin_button_set_value( spin_in, ( gfloat ) in );
}


void PageTrim::resetOutPoint()
{
    out = out_orig;
    gtk_adjustment_set_value( trim_adj[ TRIM_ADJ_OUT ], ( gfloat ) out );
    gtk_spin_button_set_value( spin_out, ( gfloat ) out );
}

gboolean PageTrim::processKeyboard( GdkEventKey *event )
{
    gboolean ret = FALSE;

    // Only process while not escape mode
    if ( g_nav_ctl.escaped == FALSE )
    {
        if ( strcmp( lastcmd, "alt" ) == 0 )
        {
            strcpy( lastcmd, "" );
            return ret;
        }

        // Translate special keys to equivalent command
        switch ( event->keyval )
        {
        case GDK_Home:
            strcat( cmd, "gg");
            ret = TRUE;
            break;
        case GDK_End:
            strcat( cmd, "G");
            ret = TRUE;
            break;
        case GDK_BackSpace:
        case GDK_Left:
            strcat( cmd, "h" );
            ret = TRUE;
            break;
        case GDK_Up:
            strcat( cmd, "k" );
            ret = TRUE;
            break;
        case GDK_Right:
            strcat( cmd, "l" );
            ret = TRUE;
            break;
        case GDK_Return:
            if ( cmd[ 0 ] != 0 )
            {
                // Last command is now
                strcpy( lastcmd, cmd );

                // end the command entry
                cmd[ 0 ] = 0;
                common->setStatusBar( "" );
                break;
            }
            else
            {
                strcat( cmd, "Enter" );
                ret = TRUE;
                break;
            }
        case GDK_Down:
            strcat( cmd, "j" );
            ret = TRUE;
            break;
        case GDK_Delete:
            strcat( cmd, "x" );
            ret = TRUE;
            break;
        case GDK_Escape:
            if ( common->getComponentState() & VIDEO_STOP )
            {
                common->changePageRequest( PAGE_EDITOR );
                return ret;
            }
            else
            {
                strcat( cmd, "Esc" );
                break;
            }
        case GDK_Alt_L:
        case GDK_Alt_R:
            strcpy( lastcmd, "alt" );
            return ret;
        case GDK_Insert:
        case GDK_KP_Insert:
            strcat( cmd, "Ins" );
            ret = TRUE;
            break;
        default:
            if ( strcmp( event->string, "." ) )
                strcat( cmd, event->string );
            break;
        }

        if ( !strcmp( event->string, "." ) )
            strcpy( cmd, lastcmd );
        else if ( cmd[ 0