Export Class Reference

An Export reflects the interaction between the PageExport object and an individual export notebook page. More...

#include <export.h>

Inheritance diagram for Export:

[legend]Collaboration diagram for Export:

[legend]List of all members.

Public Member Functions
	Export (PageExport *_exportPage, KinoCommon *_common)
	**********************************************************************
virtual	~Export ()
gulong	activate ()
	Wrappers for activate, deactivate, exports own little isolated state stuff This method toggles buttons and other components to fit with what is supported by the current export page.
gulong	deactivate ()
virtual void	start ()
	Empty methods - here for tracking during development.
virtual void	clean ()
void	startExport (bool preview=false)
	**********************************************************************
virtual void	stopExport ()
	Fallbacks for children that does not overwrite.
virtual void	pauseExport ()
virtual void	selectScene (int)
	Put the scene begin and end frame numbers into spinners.
virtual void	selectSection (int)
void	onRangeChange (GtkSpinButton *widget)
	Callback function for the start and end spinners.
Static Public Member Functions
static char *	formatSecs (char *buf, int size, double seconds)
	Format seconds.
Protected Member Functions
void	innerLoopUpdate (int progress, int begin, int end, int every, int currentFrame=-1, const char *activity=_("Exporting"))
	Every child should call this method once every loop It will check for pausing, update the statusbar and the progressbar It is recommended that you call it the beginning of your innermost loop likely before exporting any actual frame data.
double	calculateAdjustedRate (PlayList *playlist, double outputRate, int begin, int end, int every)
	Determine a new audio sampling rate that will try to maximize the proper number of audio samples for the duration because DV often contains unlocked audio.
virtual void	doPause ()
	Do the actual pause.
virtual enum export_result	doExport (PlayList *playlist, int begin, int end, int every, bool preview)=0
	The actual method that does the export.
virtual gulong	onActivate ()
	By default we support the stop, and pause buttons, as well as EXPORT_SCENE_LIST stop is implicit (not defined in fact) You should override this method, if you do not support pause or export, do support preview or do not support the EXPORT_SCENE_LIST.
virtual gulong	onDeactivate ()
Protected Attributes
gulong	actions
PageExport *	exportPage
KinoCommon *	common
GtkOptionMenu *	menuRange
GtkSpinButton *	startSpin
GtkEntry *	startEntry
GtkSpinButton *	endSpin
GtkEntry *	endEntry
GtkSpinButton *	everySpin
GtkToggleButton *	previewButton
GtkToggleButton *	exportButton
GtkToggleButton *	stopButton
GtkToggleButton *	pauseButton
double	startTime
	Variables used to measure time during the export.
double	pauseTime
double	nextUpdateTime

---

Detailed Description

An Export reflects the interaction between the PageExport object and an individual export notebook page.

All subsequent Export objects must extend this class (publicly) and rewrite any or all of the virtual methods provided.

Definition at line 80 of file export.h.

---

Constructor & Destructor Documentation

Export::Export (  PageExport *  _exportPage, KinoCommon *  _common )

********************************************************************** Definition at line 48 of file export.cc. References common, endEntry, endSpin, everySpin, exportButton, exportPage, KinoCommon::getWidget(), PageExport::getWidget(), lookup_widget(), menuRange, on_tool_change(), pauseButton, previewButton, selectSection(), startEntry, startSpin, and stopButton. : actions( EXPORT_SCENE_LIST ), exportPage( _exportPage ), common( _common ) { menuRange = GTK_OPTION_MENU( lookup_widget( exportPage->getWidget(), "optionmenu_export_range" ) ); startSpin = GTK_SPIN_BUTTON( lookup_widget( exportPage->getWidget(), "spinbutton_export_range_start" ) ); startEntry = GTK_ENTRY( lookup_widget( exportPage->getWidget(), "entry_export_start" ) ); endSpin = GTK_SPIN_BUTTON( lookup_widget( exportPage->getWidget(), "spinbutton_export_range_end" ) ); endEntry = GTK_ENTRY( lookup_widget( exportPage->getWidget(), "entry_export_end" ) ); everySpin = GTK_SPIN_BUTTON( lookup_widget( exportPage->getWidget(), "spinbutton_export_range_every" ) ); gtk_option_menu_set_history( menuRange, 0 ); selectSection( 0 ); g_signal_connect( G_OBJECT( menuRange ), "changed", G_CALLBACK( on_tool_change ), this ); /* Get pointers to the common control buttons (bottom of page) */ previewButton = GTK_TOGGLE_BUTTON( lookup_widget( common->getWidget(), "togglebutton_export_preview" ) ); exportButton = GTK_TOGGLE_BUTTON( lookup_widget( common->getWidget(), "togglebutton_export_export" ) ); stopButton = GTK_TOGGLE_BUTTON( lookup_widget( common->getWidget(), "togglebutton_export_stop" ) ); pauseButton = GTK_TOGGLE_BUTTON( lookup_widget( common->getWidget(), "togglebutton_export_pause" ) ); }

virtual Export::~Export (   )  [inline, virtual]

Definition at line 184 of file export.h. { }

---

Member Function Documentation

gulong Export::activate (   )

Wrappers for activate, deactivate, exports own little isolated state stuff This method toggles buttons and other components to fit with what is supported by the current export page. Also, it adjust the spin range on the from-to range export. Definition at line 283 of file export.cc. References actions, common, endSpin, EXPORT_EXPORT, EXPORT_PREVIEW, EXPORT_SCENE_LIST, exportButton, PageExport::exportMutex, exportPage, KinoCommon::getPlayList(), PageExport::isExporting, menuRange, onActivate(), pauseButton, previewButton, SCENE_LIST, selectSection(), startSpin, and stopButton. { actions = onActivate(); selectSection( gtk_option_menu_get_history( menuRange ) ); /* Adjust on from-to range start: */ GtkAdjustment *adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( startSpin ) ); adjust->lower = 0; adjust->upper = common->getPlayList() ->GetNumFrames() - 1; g_signal_emit_by_name( adjust, "changed" ); if ( adjust->value > adjust->upper ) { gtk_adjustment_set_value ( adjust, adjust->upper ); } /* end: */ adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( endSpin ) ); adjust->lower = 0; adjust->upper = common->getPlayList() ->GetNumFrames() - 1; g_signal_emit_by_name( adjust, "changed" ); if ( adjust->value > adjust->upper ) { gtk_adjustment_set_value ( adjust, adjust->upper ); } /* Enable/disable common buttons */ bool supports_preview = actions & EXPORT_PREVIEW; bool supports_export = actions & EXPORT_EXPORT; // bool supports_pause = tmp & EXPORT_PAUSE; /* Adjust to reasonable standard */ exportPage->exportMutex = true; if ( exportPage->isExporting ) { /* Not good, we should locked on a page when exporting */ cerr << ">>> Export::activate() internal error: " << "called with exportPage->isExporting!" << endl; /* Hmm. We should not change _anything_ when exporting. Really... */ /* Only stop and pause should be available - if pausing, pause should be pressed TODO: we do not really know when we are previewing... */ /* This code have been left here, until it is certain that the current solution where the user can not change to another export page during export, is acceptable to all parties. gtk_toggle_button_set_active( previewButton, FALSE ); gtk_widget_set_sensitive( GTK_WIDGET(previewButton), supports_preview ); gtk_toggle_button_set_active( exportButton, TRUE ); gtk_widget_set_sensitive( GTK_WIDGET(exportButton), FALSE ); gtk_toggle_button_set_active( stopButton, FALSE ); gtk_widget_set_sensitive( GTK_WIDGET(stopButton), TRUE ); gtk_toggle_button_set_active( pauseButton, exportPage->isPausing ); gtk_widget_set_sensitive( GTK_WIDGET(pauseButton), supports_pause ); */ } else { /* At most preview and export available */ gtk_toggle_button_set_active( previewButton, FALSE ); gtk_widget_set_sensitive( GTK_WIDGET( previewButton ), supports_preview ); gtk_toggle_button_set_active( exportButton, FALSE ); gtk_widget_set_sensitive( GTK_WIDGET( exportButton ), supports_export ); gtk_toggle_button_set_active( stopButton, TRUE ); gtk_widget_set_sensitive( GTK_WIDGET( stopButton ), FALSE ); gtk_toggle_button_set_active( pauseButton, FALSE ); gtk_widget_set_sensitive( GTK_WIDGET( pauseButton ), FALSE ); } exportPage->exportMutex = false; /* TODO: Activate and deactive buttons as needed */ cerr << ">> Export::activate()" << endl; if ( EXPORT_SCENE_LIST & actions ) { // cerr << "Export::activate() - SCENE_LIST" << endl; return SCENE_LIST; } else { // cerr << "Export::activate() - NO SCENE_LIST" << endl; return 0; } }

double Export::calculateAdjustedRate (  PlayList *  playlist, double  outputRate, int  begin, int  end, int  every )  [protected]

Determine a new audio sampling rate that will try to maximize the proper number of audio samples for the duration because DV often contains unlocked audio. Also, edits can accumulate sample count differences. Parameters: playlist  the current project file outputRate  the frequency to which all audio is being conformed begin  first frame to be exported (*) end  last frame to be exported (*) every  step for frames to be exported Definition at line 647 of file export.cc. References actions, AUDIO_RESAMPLE_SRC_SINC_FASTEST, common, doPause(), EXPORT_PAUSE, exportPage, GetFramePool(), Frame::GetFrameRate(), PageExport::isExporting, PageExport::isPausing, nextUpdateTime, pauseTime, AsyncAudioResample< input_t, output_t >::Process(), KinoCommon::setStatusBar(), and PageExport::updateProgress(). Referenced by ExportPipe::doExport(), ExportMJPEG::doExport(), ExportAVI::doExport(), ExportAudio::doExport(), and Export1394::doExport(). { Frame& frame = *GetFramePool()->GetFrame(); playlist->GetFrame( begin, frame ); double seconds = double( end - begin + 1 ) / frame.GetFrameRate(); int64_t idealSamples = int64_t( seconds * outputRate + 0.5 ); int64_t actualSamples = 0; double adjustedRate = 0.0; struct timeval tv; if ( 0 != gettimeofday( &tv, NULL ) ) { cerr << ">>> Export::calculateAdjustedRate: Error calling gettimeofday?" << endl; } double now = tv.tv_sec + tv.tv_usec / 1000000.0; double nextUpdateTime = now - 1.0; char buf[ 512 ]; int n = -1, frameNum = 0; AsyncAudioResample<int16_ne_t,int16_le_t>* resampler = new AsyncAudioResample<int16_ne_t,int16_le_t>( AUDIO_RESAMPLE_SRC_SINC_FASTEST, playlist, outputRate, begin, end, every ); // Determine the actual number of samples while ( exportPage->isExporting && n != 0 ) { n = resampler->Process( outputRate, frame.CalculateNumberSamples( int(outputRate), frameNum++ ) ); actualSamples += n; if ( 0 == gettimeofday( &tv, NULL ) ) { now = tv.tv_sec + tv.tv_usec / 1000000.0; if ( now > nextUpdateTime ) { snprintf( buf, 512, "%s (%02d%%)", _("Locking audio"), int( 100.0 * frameNum / (end - begin + 1) ) ); common->setStatusBar( buf ); nextUpdateTime = now + 1.0; } } exportPage->updateProgress( -1 ); /* Check pause - make sure we ignore time paused in export. */ if ( EXPORT_PAUSE & actions && exportPage->isPausing ) { doPause(); } } GetFramePool()->DoneWithFrame( &frame ); if ( exportPage->isExporting ) { // If there are less actual samples than ideal then increase the // rate to make resampler increase the number of samples. // cerr << "calcAdjustedRate secs " << seconds << " ideal " << idealSamples << " actual " << actualSamples; adjustedRate = outputRate + ( idealSamples - actualSamples ) / seconds; } if ( 0 != gettimeofday( &tv, NULL ) ) cerr << ">>> Export::innerLoopUpdate: Error calling gettimeofday?" << endl; double foo = tv.tv_sec + tv.tv_usec / 1000000.0; pauseTime += ( foo - now ); cerr << ">>> output rate is " << outputRate << ", adjusted rate is " << adjustedRate << endl; return adjustedRate; }

void Export::clean (   )  [virtual]

Reimplemented in Export1394, ExportAVI, and ExportPipe. Definition at line 394 of file export.cc. { cerr << ">>> Export::clean()" << endl; }

gulong Export::deactivate (   )

Definition at line 373 of file export.cc. References EXPORT_SCENE_LIST, onDeactivate(), and SCENE_LIST. { cerr << "Export::deactivate()" << endl; if ( EXPORT_SCENE_LIST & onDeactivate() ) { // cerr << "Export::deactivate() - SCENE_LIST" << endl; return SCENE_LIST; } else { // cerr << "Export::deactivate() - NO SCENE_LIST" << endl; return 0; } }

virtual enum export_result Export::doExport (  PlayList *  playlist, int  begin, int  end, int  every, bool  preview )  [protected, pure virtual]

The actual method that does the export. Children overwrites this. Parameters: playlist  to extract frames and other information from This is duplicated when the export starts. This allows for the user to continue editing while export is undergoing. In other words, done expect the "real" playlist to stay the same during export. begin  first frame to be exported end  last frame to be exported every  increment for frames to be exported preview  - if true, a preview is supposed to take place, not an actual export. Returns: a result code. see enum export_result. Implemented in Export1394, ExportAudio, ExportAVI, ExportMJPEG, ExportPipe, and ExportStills. Referenced by startExport().

void Export::doPause (   )  [protected, virtual]

Do the actual pause. This one is meant to be overwritten if needed, say if you need to perform some actions before entering a pause Definition at line 539 of file export.cc. References exportPage, and PageExport::isPausing. Referenced by calculateAdjustedRate(), and innerLoopUpdate(). { struct timespec ts; ts.tv_sec = 0; ts.tv_nsec = 1000 * 1000 * 20; /* 20 ms + sched overhead */ while ( exportPage->isPausing ) { // cerr << ">>> Export::doPause()" << endl; while ( gtk_events_pending() ) { gtk_main_iteration(); } /* Lets try not to hog the CPU */ nanosleep( &ts, NULL ); } }

char * Export::formatSecs (  char *  buf, int  size, double  seconds )  [static]

Format seconds. Definition at line 557 of file export.cc. Referenced by innerLoopUpdate(), startExport(), PageMagick::StartRender(), and PageMagick::UpdateStatus(). { int _seconds = ( int ) rint( seconds ); int secs = _seconds % 60; int mins = ( _seconds / 60 ) % 60; int hours = ( _seconds / 3600 ); if ( hours > 0 ) { snprintf( buf, size, "%i:%02i:%02i", hours, mins, secs ); } else { if ( mins > 0 ) { snprintf( buf, size, "%i:%02i", mins, secs ); } else { snprintf( buf, size, "%i", secs ); } } return buf; }

void Export::innerLoopUpdate (  int  progress, int  begin, int  end, int  every, int  currentFrame = -1, const char *  activity = _("Exporting") )  [protected]

Every child should call this method once every loop It will check for pausing, update the statusbar and the progressbar It is recommended that you call it the beginning of your innermost loop likely before exporting any actual frame data. Parameters marked with * should really be the ones passed to doExport (Perhaps these should really be stored in this object... hmmm Parameters: progress  the number of frames processed thus far begin  first frame to be exported (*) end  last frame to be exported (*) every  step for frames to be exported currentFrame  the frame to be exported (usually loop parameter) this should be in playList counting - ie, 1 will be added before the user sees it. -1 (default) = use progress value. activity  a short description of what is happening Definition at line 582 of file export.cc. References actions, common, doPause(), EXPORT_PAUSE, exportPage, formatSecs(), PageExport::isPausing, nextUpdateTime, pauseTime, KinoCommon::setStatusBar(), startTime, and PageExport::updateProgress(). Referenced by ExportStills::doExport(), ExportPipe::doExport(), ExportMJPEG::doExport(), ExportAVI::doExport(), ExportAudio::doExport(), and Export1394::doExport(). { char buf[ 512 ]; struct timeval tv; if ( 0 != gettimeofday( &tv, NULL ) ) { cerr << ">>> Export::innerLoopUpdate: Error calling gettimeofday?" << endl; } double now = tv.tv_sec + tv.tv_usec / 1000000.0; gfloat com_ratio = ( gfloat ) ( progress - begin ) / ( gfloat ) ( end + 1 - begin ) ; if ( currentFrame == -1 ) currentFrame = progress; /* Figure out how much time we have spend */ if ( 0 == startTime ) { /* First time */ startTime = now; nextUpdateTime = now - 1; snprintf( buf, 512, _( "%s frame %i." ), activity, currentFrame ); } else { /* Not first time We do not care to use difftime on this... */ double time_so_far = now - startTime - pauseTime; double total_est = time_so_far / com_ratio; /* Write the time values into buffers */ char buf1[ 16 ]; char buf2[ 16 ]; char buf3[ 16 ]; snprintf( buf, 512, _( "%s frame %i. Time used: %s, estimated: %s, left: %s" ), activity, currentFrame + 1, formatSecs( buf1, 16, time_so_far ), formatSecs( buf2, 16, total_est ), formatSecs( buf3, 16, total_est - time_so_far ) ); } /* Update status message TODO: Do filesystem checks first.... */ if ( now > nextUpdateTime ) { common->setStatusBar( buf ); nextUpdateTime = now + 0.25; } /* Update progressbar - assuming currentFrame have yet to be exported Updating the progressbar will handle any pending events. */ exportPage->updateProgress( com_ratio ); /* Check pause - make sure we ignore time paused in export. */ if ( EXPORT_PAUSE & actions && exportPage->isPausing ) { doPause(); if ( 0 != gettimeofday( &tv, NULL ) ) { cerr << ">>> Export::innerLoopUpdate: Error calling gettimeofday?" << endl; } double foo = tv.tv_sec + tv.tv_usec / 1000000.0; pauseTime += ( foo - now ); } }

gulong Export::onActivate (   )  [protected, virtual]

By default we support the stop, and pause buttons, as well as EXPORT_SCENE_LIST stop is implicit (not defined in fact) You should override this method, if you do not support pause or export, do support preview or do not support the EXPORT_SCENE_LIST. Reimplemented in Export1394, ExportMJPEG, and ExportPipe. Definition at line 265 of file export.cc. References EXPORT_EXPORT, EXPORT_PAUSE, and EXPORT_SCENE_LIST. Referenced by activate(). { return EXPORT_SCENE_LIST | EXPORT_EXPORT | EXPORT_PAUSE; }

gulong Export::onDeactivate (   )  [protected, virtual]

Definition at line 271 of file export.cc. Referenced by deactivate(). { return 0; }

void Export::onRangeChange (  GtkSpinButton *  widget  )

Callback function for the start and end spinners. Also, make sure that start is less than end. This is only used to provide a sane GUI Parameters: widget  the widget that generated the event (I hope...) Definition at line 503 of file export.cc. References endSpin, and startSpin. { /* Make sure that start <= end */ GtkAdjustment * startAdjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( startSpin ) ); GtkAdjustment *endAdjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( endSpin ) ); if ( widget == startSpin ) { if ( endAdjust->value < startAdjust->value ) { gtk_adjustment_set_value ( endAdjust, startAdjust->value ); } } else { if ( widget == endSpin ) { if ( startAdjust->value > endAdjust->value ) { gtk_adjustment_set_value ( startAdjust, endAdjust->value ); } } else { cerr << ">>> Export::onRangeChange: internal error: widget passed is unknown" << endl; } } }

void Export::pauseExport (   )  [virtual]

Definition at line 491 of file export.cc. { cerr << ">>> Export::pauseExport()" << endl; }

void Export::selectScene (  int  i  )  [virtual]

Put the scene begin and end frame numbers into spinners. Parameters: i  the numerical index position of the scene in the playlist When the user selects a scene from the scenelist (on pages that supports this), the from-to controls are updated to reflect the scenes start and end points. This is handled here Definition at line 408 of file export.cc. References actions, common, endSpin, EXPORT_SCENE_LIST, exportPage, GetFramePool(), KinoCommon::getPageEditor(), KinoCommon::getPlayList(), PageExport::isExporting, menuRange, KinoCommon::moveToFrame(), selectSection(), KinoCommon::setCurrentScene(), KinoCommon::showFrameMoreInfo(), and startSpin. { cerr << ">>> Export::selectScene() " << i << endl; /* Sanity check */ if ( !( EXPORT_SCENE_LIST & actions ) ) { cerr << ">>> Export::selectScene: internal consistency error. " << "selectScene, even though page does not support scene list " << actions << endl; return ; } if ( exportPage->isExporting ) return; /* Set the start selection spinner */ GtkAdjustment *adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( startSpin ) ); vector <int> scene = common->getPageEditor() ->GetScene(); if ( scene.size( ) != 0 ) { int begin = 0; int end = 0; begin = i == 0 ? 0 : scene[ i - 1 ]; adjust->lower = 0; adjust->upper = scene[ scene.size() - 1 ] - 1; gtk_spin_button_set_value( GTK_SPIN_BUTTON( startSpin ), begin ); g_signal_emit_by_name( adjust, "changed" ); /* Set the end selection spinner */ adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( endSpin ) ); adjust->lower = 0; adjust->upper = scene[ scene.size() - 1 ] - 1; end = scene[ i ] - 1; gtk_spin_button_set_value( GTK_SPIN_BUTTON( endSpin ), end ); g_signal_emit_by_name( adjust, "changed" ); Frame &frame = *( GetFramePool( ) ->GetFrame( ) ); FileHandler *media; common->getPlayList() ->GetMediaObject( begin, &media ); common->getPlayList() ->GetFrame( begin, frame ); GetFramePool( ) ->DoneWithFrame( &frame ); common->moveToFrame( begin ); common->showFrameMoreInfo( frame, media ); common->setCurrentScene( begin ); } /* Set the range button active */ if ( gtk_option_menu_get_history( menuRange ) != 2 ) gtk_option_menu_set_history( menuRange, 2 ); else selectSection( 2 ); }

void Export::selectSection (  int   )  [virtual]

Definition at line 461 of file export.cc. References common, endEntry, endSpin, exportPage, KinoCommon::getPageExport(), PageExport::getWidget(), lookup_widget(), startEntry, and startSpin. Referenced by activate(), Export(), and selectScene(). { GtkWidget * label = lookup_widget( exportPage->getWidget(), "label177" ); switch ( i ) { case 2: gtk_widget_show( GTK_WIDGET( startSpin ) ); gtk_widget_show( GTK_WIDGET( startEntry ) ); gtk_widget_show( GTK_WIDGET( endSpin ) ); gtk_widget_show( GTK_WIDGET( endEntry ) ); gtk_widget_show( GTK_WIDGET( label ) ); common->getPageExport()->timeFormatChanged(); break; default: gtk_widget_hide( GTK_WIDGET( startSpin ) ); gtk_widget_hide( GTK_WIDGET( startEntry ) ); gtk_widget_hide( GTK_WIDGET( endSpin ) ); gtk_widget_hide( GTK_WIDGET( endEntry ) ); gtk_widget_hide( GTK_WIDGET( label ) ); break; } }

void Export::start (   )  [virtual]

Empty methods - here for tracking during development. Reimplemented in Export1394, ExportAVI, ExportMJPEG, and ExportPipe. Definition at line 390 of file export.cc. { cerr << ">>> Export::start()" << endl; }

void Export::startExport (  bool  preview = false  )

********************************************************************** Definition at line 88 of file export.cc. References actions, common, doExport(), endSpin, everySpin, EXPORT_EXPORT, EXPORT_PAUSE, EXPORT_PREVIEW, EXPORT_RESULT_ABORT, EXPORT_RESULT_FAILURE, EXPORT_RESULT_SUCCESS, exportButton, PageExport::exportMutex, exportPage, formatSecs(), KinoCommon::g_currentFrame, KinoCommon::getPlayList(), KinoCommon::getWidget(), PageExport::isExporting, lookup_widget(), menuRange, pauseButton, pauseTime, previewButton, PageExport::resetProgress(), KinoCommon::setStatusBar(), startSpin, startTime, stopButton, and PageExport::updateProgress(). { bool supports_preview = actions & EXPORT_PREVIEW; bool supports_export = actions & EXPORT_EXPORT; bool supports_pause = actions & EXPORT_PAUSE; /* Make sure the user can only click relevant buttons exportPage->exportMutex is a protection against the buttons going into a wild events generating loop. */ exportPage->exportMutex = true; /* When exporting, export is pressed and can not be pressed pause and stop can be pressed, preview can not */ gtk_toggle_button_set_active( previewButton, FALSE ); gtk_widget_set_sensitive( GTK_WIDGET( previewButton ), FALSE ); gtk_toggle_button_set_active( exportButton, TRUE ); gtk_widget_set_sensitive( GTK_WIDGET( exportButton ), FALSE ); gtk_toggle_button_set_active( stopButton, FALSE ); gtk_widget_set_sensitive( GTK_WIDGET( stopButton ), TRUE ); gtk_toggle_button_set_active( pauseButton, FALSE ); gtk_widget_set_sensitive( GTK_WIDGET( pauseButton ), supports_pause ); exportPage->exportMutex = false; /* Make the tabbed notebook inaccesible during export */ GtkNotebook * tmp = GTK_NOTEBOOK( lookup_widget( common->getWidget(), "notebook_export" ) ); if ( !tmp ) { cerr << "Export::startExport. Unable to access the notebook_export widget!" << endl; } else { gtk_widget_set_sensitive ( GTK_WIDGET( tmp ), FALSE ); } GtkWidget * tmpframe = GTK_WIDGET ( lookup_widget ( common->getWidget(), "vbox_export_range" ) ); if ( !tmpframe ) { cerr << "Export::startExport. Unable to acces the frame_export_range widget!" << endl; } else { gtk_widget_set_sensitive ( GTK_WIDGET( tmpframe ), FALSE ); } /* Allow gtk to handle pending events - I am not sure this is strictly needed, but there seems to be some lag from pressing buttons until their state is updated.... this might help. */ while ( gtk_events_pending() ) { gtk_main_iteration(); } /* Get a temporary playlist */ PlayList playlist( *( common->getPlayList() ) ); /* Set begin, end and every based on the range selections */ int begin = 0; int end = 0; int every = 1; switch ( gtk_option_menu_get_history( menuRange ) ) { case 0: begin = 0; end = common->getPlayList() ->GetNumFrames() - 1; break; case 1: begin = end = common->g_currentFrame; break; case 2: begin = gtk_spin_button_get_value_as_int( startSpin ); end = gtk_spin_button_get_value_as_int( endSpin ); break; } every = gtk_spin_button_get_value_as_int( everySpin ); /* Reset the progess stuff */ exportPage->resetProgress(); /* Reset the time measuring stuff */ startTime = 0.0; pauseTime = 0.0; /* Reset the statusmessage */ common->setStatusBar( _( "Starting export" ) ); /* Do the actual work */ enum export_result status = doExport( &playlist, begin, end, every, preview ); struct timeval tv; if ( 0 != gettimeofday( &tv, NULL ) ) { cerr << ">>> Export::startExport - error calling gettimeofday?" << endl; } double now = tv.tv_sec + tv.tv_usec / 1000000.0; char buf[ 17 ]; string message; //snprintf(buf, 512, "Export finished/failed/stopped - time: %s", // formatSecs(buf1, 16, now - startTime)); switch ( status ) { case EXPORT_RESULT_SUCCESS: message = _( "Export finished - time: " ); break; case EXPORT_RESULT_FAILURE: message = _( "Export failed - time: " ); break; case EXPORT_RESULT_ABORT: message = _( "Export stopped - time: " ); break; } message += formatSecs( buf, 16, now - startTime ); common->setStatusBar( message.c_str() ); /* Enable the common controls and buttons again */ if ( tmp ) { gtk_widget_set_sensitive ( GTK_WIDGET( tmp ), TRUE ); } if ( tmpframe ) { gtk_widget_set_sensitive ( GTK_WIDGET( tmpframe ), TRUE ); } /* Set the progess to 100% - even in case of errors - the process have stopped.... */ exportPage->updateProgress( ( gfloat ) 1.0 ); /* Set the buttons to allow a new export session. export is available stop is pressed, but not available pause is not available */ exportPage->exportMutex = true; gtk_toggle_button_set_active( previewButton, FALSE ); gtk_widget_set_sensitive( GTK_WIDGET( previewButton ), supports_preview ); gtk_toggle_button_set_active( exportButton, FALSE ); gtk_widget_set_sensitive( GTK_WIDGET( exportButton ), supports_export ); gtk_toggle_button_set_active( stopButton, TRUE ); gtk_widget_set_sensitive( GTK_WIDGET( stopButton ), FALSE ); gtk_toggle_button_set_active( pauseButton, FALSE ); gtk_widget_set_sensitive( GTK_WIDGET( pauseButton ), FALSE ); exportPage->exportMutex = false; /* We are no longer exporting at this point */ exportPage->isExporting = false; while ( gtk_events_pending() ) { gtk_main_iteration(); } }

void Export::stopExport (   )  [virtual]

Fallbacks for children that does not overwrite. Definition at line 487 of file export.cc. { cerr << ">>> Export::stopExport()" << endl; }

---

Member Data Documentation

gulong Export::actions [protected]

Definition at line 84 of file export.h. Referenced by activate(), calculateAdjustedRate(), innerLoopUpdate(), selectScene(), and startExport().

KinoCommon* Export::common [protected]

Definition at line 91 of file export.h. Referenced by activate(), ExportPipe::activateTool(), ExportMJPEG::activateTool(), calculateAdjustedRate(), ExportMJPEG::createAuthorXml(), ExportStills::doExport(), ExportPipe::doExport(), ExportMJPEG::doExport(), ExportAVI::doExport(), Export1394::doExport(), Export(), Export1394::Export1394(), ExportAudio::ExportAudio(), ExportAVI::ExportAVI(), ExportMJPEG::ExportMJPEG(), ExportPipe::ExportPipe(), ExportStills::ExportStills(), innerLoopUpdate(), selectScene(), selectSection(), ExportPipe::selectTool(), ExportMJPEG::start(), Export1394::start(), and startExport().

GtkEntry* Export::endEntry [protected]

Definition at line 98 of file export.h. Referenced by Export(), and selectSection().

GtkSpinButton* Export::endSpin [protected]

Definition at line 97 of file export.h. Referenced by activate(), Export(), onRangeChange(), selectScene(), selectSection(), and startExport().

GtkSpinButton* Export::everySpin [protected]

Definition at line 99 of file export.h. Referenced by Export(), and startExport().

GtkToggleButton* Export::exportButton [protected]

Definition at line 104 of file export.h. Referenced by activate(), Export(), and startExport().

PageExport* Export::exportPage [protected]

Definition at line 90 of file export.h. Referenced by activate(), calculateAdjustedRate(), ExportStills::doExport(), ExportPipe::doExport(), ExportMJPEG::doExport(), ExportAVI::doExport(), ExportAudio::doExport(), Export1394::doExport(), doPause(), Export(), ExportAudio::ExportAudio(), ExportAVI::ExportAVI(), ExportMJPEG::ExportMJPEG(), innerLoopUpdate(), selectScene(), selectSection(), Export1394::start(), and startExport().

GtkOptionMenu* Export::menuRange [protected]

Definition at line 94 of file export.h. Referenced by activate(), Export(), selectScene(), and startExport().

double Export::nextUpdateTime [protected]

Definition at line 111 of file export.h. Referenced by calculateAdjustedRate(), and innerLoopUpdate().

GtkToggleButton* Export::pauseButton [protected]

Definition at line 106 of file export.h. Referenced by activate(), Export(), and startExport().

double Export::pauseTime [protected]

Definition at line 110 of file export.h. Referenced by calculateAdjustedRate(), innerLoopUpdate(), and startExport().

GtkToggleButton* Export::previewButton [protected]

Definition at line 103 of file export.h. Referenced by activate(), Export(), and startExport().

GtkEntry* Export::startEntry [protected]

Definition at line 96 of file export.h. Referenced by Export(), and selectSection().

GtkSpinButton* Export::startSpin [protected]

Definition at line 95 of file export.h. Referenced by activate(), Export(), onRangeChange(), selectScene(), selectSection(), and startExport().

double Export::startTime [protected]

Variables used to measure time during the export. Definition at line 109 of file export.h. Referenced by innerLoopUpdate(), and startExport().

GtkToggleButton* Export::stopButton [protected]

Definition at line 105 of file export.h. Referenced by activate(), Export(), and startExport().

---

The documentation for this class was generated from the following files:

• export.h
• export.cc

---