KinoCommon Class Reference

This class is the main GUI class. More...

#include <kino_common.h>

Collaboration diagram for KinoCommon:

[legend]List of all members.

Public Member Functions
	KinoCommon (GtkWidget *widget)
	Constructor for KinoCommon - initialises all GUI widgets.
	~KinoCommon ()
	Destructor for the kino common object.
GtkWidget *	getWidget ()
PlayList *	getPlayList ()
int	getCurrentScene ()
bool	newFile (bool prompt=true)
	Carries out a New File request in the kino application.
void	bulkLoad (int, char *[])
	Loads all files specified in the command line style arguments.
std::string	importFile (const char *filename)
	Give option to import a file by transcoding to DV.
void	insertFile ()
	Inserts a file at the current position.
void	appendFile ()
	Appends a file after the current position.
void	loadFile ()
	Opens a file.
bool	savePlayListAs ()
	Save the current play list with a different name to the original loaded (or previously saved as) play list file name.
bool	savePlayList ()
	Save the current play list to the file used to load the playlist originally.
void	saveFrame ()
	Save the current frame as a still frame.
void	publishPlayList ()
void	publishFrame ()
void	loadPlayList (char *)
void	changePageRequest (int page)
	Sends change page request to the gui.
void	setCurrentPage (int page)
	Carries out a change page - this should be triggered by changePageRequest to ensure that the GUI stays in sync with the common structure.
Page *	getCurrentPage ()
	Returns the current Page object.
Page *	getPage (int page)
	Returns the Page object associated to the specified notebook page.
void	activateWidgets ()
	Activate or deactivate the widgets at the request of the previous page.
PageEditor *	getPageEditor ()
	Returns the Page associated to the Editor page.
PageCapture *	getPageCapture ()
	Returns the Page associated to the Capture page.
PageTimeline *	getPageTimeline ()
	Returns the Page associated to the Timeline page.
PageBttv *	getPageBttv ()
	Returns the 'BTTV' page (test code for extending hardware support).
PageExport *	getPageExport ()
	Returns the Export page.
PageTrim *	getPageTrim ()
	Returns the Trim page.
PageMagick *	getPageMagick ()
	Returns the Magick page.
PageUndefined *	getPageUndefined ()
	Returns the Page associated to the Undefined page.
int	moveToFrame ()
	Move to the current frame.
int	moveToFrame (int)
	Move to the frame specified.
int	moveByFrames (int)
	Move the frame relative to the number specified.
void	showFrameInfo (int)
	Relay the current frame info to the GUI.
void	showFrameMoreInfo (Frame &, FileHandler *)
	Display detailed information about this frame and its file.
void	keyboardFeedback (const char *, const char *)
	Relay the current command and any message associated to it.
gboolean	processKeyboard (GdkEventKey *event)
	Trigger the keyboard action of the current page.
gboolean	processCommand (char *)
	Trigger a menu command action of the current page.
void	selectScene (int)
	Trigger the select scene action of the current page.
void	videoStartOfMovie ()
	Trigger the start of movie action of the current page.
void	videoPreviousScene ()
	Trigger the previous scene action of the current page.
void	videoStartOfScene ()
	Trigger the start of scene action of the current page.
void	videoRewind ()
	Trigger the rewind action of the current page.
void	videoBack (int step=-1)
	Trigger the back action of the current page.
void	videoPlay ()
	Trigger the play action of the current page.
void	videoForward (int step=1)
	Trigger the forward action of the current page.
void	videoFastForward ()
	Trigger the fast forward action of the current page.
void	videoNextScene ()
	Trigger the next scene action of the current page.
void	videoEndOfScene ()
	Trigger the end of scene action of the current page.
void	videoEndOfMovie ()
	Trigger the end movie action of the current page.
void	videoPause ()
	Trigger the pause action of the current page.
void	videoStop ()
	Trigger the stop action of the current page.
void	videoShuttle (int)
	Bi-directional variable-speed playback.
void	windowMoved ()
void	visibilityChanged (gboolean)
void	toggleComponents (component_enum, bool)
	Set the state of toggle buttons.
component_enum	getComponentState ()
	Get the current component state data.
void	commitComponentState (component_enum=(component_enum) 0)
	Set the component state data and commit it.
char *	getFileToOpen (char *title, bool isDVFile, GtkWidget *widget)
	Handles the modal dialog for collecting a file to open.
char *	getFileToSaveFormat (char *title, GtkWidget *widget, int &format)
char *	getFileToOpen (char *title, bool isDVFile=true)
char *	getFileToSave (char *title)
char *	getFileToSaveFormat (char *title, int &format)
void	setPreviewSize (float factor, bool noWarning=false)
	Resize the video preview area to a percentage of source image size.
void	loadSplash (GtkDrawingArea *)
	Load the splash image into the video preview area.
void	clearPreview (GtkDrawingArea *)
	Make the video preview area black.
void	setWindowTitle ()
	Sets the document name in the window title.
void	saveFrame (int, char *)
	Save the specified frame to the specified file.
bool	loadMediaObject (char *, int)
	Loads the specified media file before the specified frame.
void	packIt (const char *, const char *)
	Set the video display to be fixed size or scalable.
void	setStatusBar (const char *,...)
	Helper function for the pages.
void	setMoreInfo (bool state)
SMIL::Time::TimeFormat	getTimeFormat () const
void	setTimeFormat (SMIL::Time::TimeFormat format)
SMIL::MediaClippingTime &	getTime ()
void	setCurrentScene (int frame)
string	getLastDirectory ()
void	setLastDirectory (const string &value)
void	updateRecentFiles ()
bool	exitKino ()
int	checkFile (char *)
	Determines the format of the file.
Static Public Member Functions
static GtkWindow *	getWidgetWindow (GtkWidget *widget)
Public Attributes
int	g_currentFrame
gboolean	hasListChanged
Protected Member Functions
void	start ()
	Trigger the start action of the current page.
void	clean ()
	Trigger the clean action of the current page.
void	setFileEditted (char *)
void	setCurrentDirectoryFromFile (char *)
void	saveAVI (char *)
bool	loadPlayList (char *, int)
	Loads the specified play list before the specified frame.
bool	savePlayList (char *)
	Saves the playlist.
void	fetchProjectMetadata (const std::string &projectKey)
	Uses libml2 to fetch the metadata from a CMS.
Private Attributes
GtkWidget *	widget
GtkWidget *	edit_menu
GtkWidget *	view_menu
GtkNotebook *	notebook
GtkEntry *	command
GtkButton *	video_start_movie_button
GtkButton *	video_start_scene_button
GtkButton *	video_rewind_button
GtkButton *	video_back_button
GtkButton *	video_play_button
GtkButton *	video_stop_button
GtkButton *	video_forward_button
GtkButton *	video_fast_forward_button
GtkButton *	video_end_scene_button
GtkButton *	video_end_movie_button
GtkRange *	video_shuttle
GtkStatusbar *	statusbar
PlayList	playlist
int	currentPage
PageEditor *	editor
PageCapture *	capture
PageTimeline *	timeline
PageBttv *	bttv
PageExport *	exportPage
PageTrim *	trimPage
PageMagick *	magickPage
PageUndefined *	undefined
char	tempFileName [PATH_MAX+NAME_MAX]
char	playlistFileName [PATH_MAX+NAME_MAX]
gulong	component_state
bool	is_component_state_changing
string	last_directory
bool	showMoreInfo
int	currentScene
SMIL::MediaClippingTime	time
std::vector< GtkWidget * >	recentMenuItems

---

Detailed Description

This class is the main GUI class.

As such it is responsible for providing the functionality for all GUI actions relating to widgets which are outside of an individual notebook page (ie: the menu, scene list, transport controls, command line, frame info and the notebook itself).

It is also responsible for holding the current play list.

NB: I would like to make this class more dynamic, especially in terms of notebook pages. Ideally, a notebook page would become a plug in, with each Page object being registered with this class (and a subsequent notebook page being added to the GUI). Glade (and libglade) could be used in such a scenario, but it would necessitate a separate glade project per page (I think... haven't really looked at how best to do this yet). The advantage would be that not only could third party plug-ins be developed, but irrelevant notebook pages could be discarded (ie: if you have no firewire capture card, then that page could be excluded).

Definition at line 108 of file kino_common.h.

---

Constructor & Destructor Documentation

KinoCommon::KinoCommon (  GtkWidget *  widget  )

Constructor for KinoCommon - initialises all GUI widgets. Parameters: widget  top level widget for the main window Definition at line 90 of file kino_common.cc. References bttv, capture, component_state, currentPage, currentScene, edit_menu, editor, exportPage, g_currentFrame, Preferences::getInstance(), hasListChanged, is_component_state_changing, lookup_widget(), magickPage, notebook, setTimeFormat(), statusbar, SMIL::Time::TIME_FORMAT_FRAMES, SMIL::Time::TIME_FORMAT_NONE, timeline, trimPage, undefined, video_back_button, video_end_movie_button, video_end_scene_button, video_fast_forward_button, video_forward_button, video_play_button, video_rewind_button, video_shuttle, video_start_movie_button, video_start_scene_button, VIDEO_STOP, video_stop_button, and view_menu. : last_directory( "" ) { cerr << "> Kino Common being built" << endl; // Initialise class variables from GUI components this->widget = widget; this->edit_menu = lookup_widget( widget, "edit" ); this->view_menu = lookup_widget( widget, "view1" ); this->notebook = GTK_NOTEBOOK( lookup_widget( widget, "main_notebook" ) ); this->video_start_movie_button = GTK_BUTTON( lookup_widget( widget, "video_start_movie_button" ) ); this->video_start_scene_button = GTK_BUTTON( lookup_widget( widget, "video_start_scene_button" ) ); this->video_rewind_button = GTK_BUTTON( lookup_widget( widget, "video_rewind_button" ) ); this->video_back_button = GTK_BUTTON( lookup_widget( widget, "video_back_button" ) ); this->video_play_button = GTK_BUTTON( lookup_widget( widget, "video_play_button" ) ); this->video_stop_button = GTK_BUTTON( lookup_widget( widget, "video_stop_button" ) ); this->video_forward_button = GTK_BUTTON( lookup_widget( widget, "video_forward_button" ) ); this->video_fast_forward_button = GTK_BUTTON( lookup_widget( widget, "video_fast_forward_button" ) ); this->video_end_scene_button = GTK_BUTTON( lookup_widget( widget, "video_end_scene_button" ) ); this->video_end_movie_button = GTK_BUTTON( lookup_widget( widget, "video_end_movie_button" ) ); this->video_shuttle = GTK_RANGE( lookup_widget( widget, "hscale_shuttle" ) ); this->statusbar = GTK_STATUSBAR( lookup_widget( widget, "statusbar" ) ); // Create page objects this->editor = new PageEditor( this ); this->capture = new PageCapture( this ); this->timeline = new PageTimeline( this ); this->undefined = new PageUndefined( this ); this->bttv = new PageBttv( this ); this->exportPage = new PageExport( this ); this->trimPage = new PageTrim( this ); this->magickPage = new PageMagick( this ); // Initialise other class variables strcpy( this->tempFileName, "" ); this->g_currentFrame = -1; this->hasListChanged = TRUE; this->currentScene = -1; this->currentPage = -1; this->component_state = VIDEO_STOP; this->is_component_state_changing = false; SMIL::Time::TimeFormat timeFormat = static_cast< SMIL::Time::TimeFormat >( Preferences::getInstance().timeFormat ); GtkWidget *timemenu = lookup_widget( widget, "optionmenu_time_format" ); if ( timeFormat == SMIL::Time::TIME_FORMAT_NONE ) setTimeFormat( SMIL::Time::TIME_FORMAT_FRAMES ); gtk_option_menu_set_history( GTK_OPTION_MENU( timemenu ), Preferences::getInstance().timeFormat - 1 ); }

KinoCommon::~KinoCommon (   )

Destructor for the kino common object. Definition at line 143 of file kino_common.cc. References bttv, capture, clean(), editor, exportPage, GetFileMap(), magickPage, timeline, trimPage, and undefined. { cerr << "> Kino Common being destroyed" << endl; clean(); delete this->editor; delete this->capture; delete this->timeline; delete this->undefined; delete this->bttv; delete this->exportPage; delete this->trimPage; delete this->magickPage; GetFileMap() ->Clear(); cerr << "> Kino Common destroyed" << endl; }

---

Member Function Documentation

void KinoCommon::activateWidgets (   )

Activate or deactivate the widgets at the request of the previous page. This method is always called immediately after the current pages start method and can be called at the discretion of the page if required. Definition at line 1994 of file kino_common.cc. References EDIT_MENU, getCurrentPage(), GetStoryboard(), lookup_widget(), SCENE_LIST, VIDEO_BACK, video_back_button, video_end_movie_button, VIDEO_END_OF_MOVIE, video_end_scene_button, VIDEO_FAST_FORWARD, video_fast_forward_button, VIDEO_FORWARD, video_forward_button, VIDEO_NEXT_SCENE, VIDEO_PLAY, video_play_button, VIDEO_REWIND, video_rewind_button, VIDEO_SHUTTLE, video_shuttle, video_start_movie_button, VIDEO_START_OF_MOVIE, VIDEO_START_OF_SCENE, video_start_scene_button, VIDEO_STOP, video_stop_button, and widget. Referenced by PageCapture::applyAVCState(), on_preferences_dialog_ok_button_clicked(), PageExport::setCurrentMode(), PageMagick::ShowCurrentStatus(), PageCapture::start(), start(), PageCapture::startCapture(), and PageMagick::StartRender(). { component_enum pattern = ( component_enum ) ( this->getCurrentPage()->activate() ^ this->getCurrentPage()->deactivate() ); gtk_widget_set_sensitive( lookup_widget( widget, "undo" ), pattern & EDIT_MENU ); gtk_widget_set_sensitive( lookup_widget( widget, "redo" ), pattern & EDIT_MENU ); gtk_widget_set_sensitive( lookup_widget( widget, "copy_current_scene" ), pattern & EDIT_MENU ); gtk_widget_set_sensitive( lookup_widget( widget, "cut_current_scene" ), pattern & EDIT_MENU ); gtk_widget_set_sensitive( lookup_widget( widget, "paste_before_current_frame" ), pattern & EDIT_MENU ); gtk_widget_set_sensitive( lookup_widget( widget, "split_scene" ), pattern & EDIT_MENU ); gtk_widget_set_sensitive( lookup_widget( widget, "join_scenes" ), pattern & EDIT_MENU ); gtk_widget_set_sensitive( lookup_widget( widget, "button_undo" ), pattern & EDIT_MENU ); gtk_widget_set_sensitive( lookup_widget( widget, "button_redo" ), pattern & EDIT_MENU ); gtk_widget_set_sensitive( lookup_widget( widget, "button_cut" ), pattern & EDIT_MENU ); gtk_widget_set_sensitive( lookup_widget( widget, "button_copy" ), pattern & EDIT_MENU ); gtk_widget_set_sensitive( lookup_widget( widget, "button_paste" ), pattern & EDIT_MENU ); gtk_widget_set_sensitive( lookup_widget( widget, "button_split" ), pattern & EDIT_MENU ); gtk_widget_set_sensitive( lookup_widget( widget, "button_join" ), pattern & EDIT_MENU ); GetStoryboard() ->setSensitive( pattern & SCENE_LIST ); gtk_widget_set_sensitive( GTK_WIDGET( video_start_movie_button ), pattern & VIDEO_START_OF_MOVIE ); gtk_widget_set_sensitive( GTK_WIDGET( video_start_scene_button ), pattern & VIDEO_START_OF_SCENE ); gtk_widget_set_sensitive( GTK_WIDGET( video_rewind_button ), pattern & VIDEO_REWIND ); gtk_widget_set_sensitive( GTK_WIDGET( video_back_button ), pattern & VIDEO_BACK ); gtk_widget_set_sensitive( GTK_WIDGET( video_play_button ), pattern & VIDEO_PLAY ); gtk_widget_set_sensitive( GTK_WIDGET( video_stop_button ), pattern & VIDEO_STOP ); gtk_widget_set_sensitive( GTK_WIDGET( video_forward_button ), pattern & VIDEO_FORWARD ); gtk_widget_set_sensitive( GTK_WIDGET( video_fast_forward_button ), pattern & VIDEO_FAST_FORWARD ); gtk_widget_set_sensitive( GTK_WIDGET( video_end_scene_button ), pattern & VIDEO_NEXT_SCENE ); gtk_widget_set_sensitive( GTK_WIDGET( video_end_movie_button ), pattern & VIDEO_END_OF_MOVIE ); gtk_widget_set_sensitive( GTK_WIDGET( video_shuttle ), pattern & VIDEO_SHUTTLE ); }

void KinoCommon::appendFile (   )

Appends a file after the current position. Definition at line 751 of file kino_common.cc. References AVI, changePageRequest(), checkFile(), g_currentFrame, getFileToOpen(), getPageEditor(), getPlayList(), hasListChanged, importFile(), loadMediaObject(), loadPlayList(), modal_message(), moveToFrame(), PAGE_EDITOR, PLAYLIST, QT, RAW_DV, setWindowTitle(), and UNKNOWN_FORMAT. Referenced by PageEditor::processCommand(). { changePageRequest( PAGE_EDITOR ); char * filename = this->getFileToOpen( _( "Choose a DV or SMIL file to append" ) ); if ( filename && strcmp( filename, "" ) ) { switch ( checkFile( filename ) ) { case AVI: case RAW_DV: case QT: if ( loadMediaObject( filename, g_currentFrame + 1 ) ) { g_currentFrame++; hasListChanged = TRUE; getPlayList() ->SetDirty( true ); break; } // Else, ask to import case UNKNOWN_FORMAT: { const std::string& importedFile = importFile( filename ); if ( loadMediaObject( const_cast<char*>( importedFile.c_str() ), g_currentFrame + 1 ) ) { g_currentFrame++; hasListChanged = TRUE; getPlayList() ->SetDirty( true ); break; } else { modal_message( _( "Failed to load media file \"%s\"" ), importedFile.c_str() ); } break; } case PLAYLIST: // Insert the new smil if ( loadPlayList( filename, g_currentFrame + 1 ) ) { g_currentFrame++; hasListChanged = TRUE; getPlayList() ->SetDirty( true ); getPageEditor() ->snapshot(); } break; } } setWindowTitle(); moveToFrame( ); }

void KinoCommon::bulkLoad (  int  argc, char *  argv[] )

Loads all files specified in the command line style arguments. Parameters: argc  number of arguments argv  arguments Definition at line 1433 of file kino_common.cc. References AVI, checkFile(), currentPage, g_currentFrame, getPageEditor(), getPlayList(), hasListChanged, importFile(), loadMediaObject(), loadPlayList(), lookup_widget(), modal_message(), PAGE_TRIM, PLAYLIST, QT, RAW_DV, setWindowTitle(), UNKNOWN_FORMAT, url_decode(), and widget. { char temp[ PATH_MAX + NAME_MAX ]; char filename[ PATH_MAX + NAME_MAX ]; for ( int i = 1; i < argc; ++i ) { /* Get the real name of the file, to make sure that we store absolute paths in smil files */ if ( NULL != realpath( url_decode( temp, argv[ i ] ), filename ) ) { switch ( checkFile( filename ) ) { case AVI: case RAW_DV: case QT: // a little hook to make the trimmer load the clip for insert edting if ( currentPage == PAGE_TRIM ) { gtk_entry_set_text( GTK_ENTRY( lookup_widget( widget, "entry_trim_clip" ) ), filename ); } else if ( loadMediaObject( filename, this->getPlayList() ->GetNumFrames() ) ) { if ( g_currentFrame == -1 ) g_currentFrame = 0; this->hasListChanged = TRUE; } else { cerr << "KinoCommon::bulkLoad: Failed to load " << filename << endl; } break; case PLAYLIST: { int last_count = getPlayList( ) ->GetNumFrames( ); string last_doc_name = getPlayList( ) ->GetDocName( ); if ( loadPlayList( filename, last_count ) ) { if ( last_count == 0 && last_doc_name == "" ) { getPlayList() ->SetDocName( filename ); getPlayList() ->SetDirty( false ); } else { getPlayList() ->SetDirty( true ); } getPageEditor() ->snapshot(); if ( g_currentFrame == -1 ) g_currentFrame = 0; this->hasListChanged = TRUE; } } break; case UNKNOWN_FORMAT: { const std::string& importedFile = importFile( filename ); if ( currentPage == PAGE_TRIM ) { gtk_entry_set_text( GTK_ENTRY( lookup_widget( widget, "entry_trim_clip" ) ), importedFile.c_str() ); } else if ( loadMediaObject( const_cast<char*>( importedFile.c_str() ), this->getPlayList() ->GetNumFrames() ) ) { if ( g_currentFrame == -1 ) g_currentFrame = 0; hasListChanged = TRUE; getPlayList() ->SetDirty( true ); } else { modal_message( _( "Failed to load media file \"%s\"" ), importedFile.c_str() ); } } break; } } else { cerr << "KinoCommon::bulkLoad: Unable to resolve " << filename << endl; } } setWindowTitle( ); }

void KinoCommon::changePageRequest (  int  page  )

Sends change page request to the gui. Parameters: page  page to change to Definition at line 408 of file kino_common.cc. References notebook. Referenced by appendFile(), insertFile(), loadFile(), newFile(), on_iconview_timeline_item_activated(), on_iconview_timeline_selection_changed(), PageTrim::processCommand(), PageTimeline::processCommand(), PageMagick::processCommand(), PageExport::processCommand(), PageEditor::processCommand(), PageCapture::processCommand(), PageTrim::processKeyboard(), PageTimeline::processKeyboard(), PageMagick::processKeyboard(), PageExport::processKeyboard(), and PageCapture::processKeyboard(). { gtk_notebook_set_page( notebook, page ); }

int KinoCommon::checkFile (  char *  FileName  )

Determines the format of the file. It is required that a file be at least 20 bytes for it to load. Note that it is currently required that mediafiles have either a .dv or .avi suffix since the PlayList uses the suffixes .avi and .dv to determine what FileHandler to create. Smil files are allowed to load without suffixes. (Correct?) Parameters: filename  file to check Returns: AVI, PLAYLIST, RAW_DV or UNKNOWN_FORMAT Definition at line 1240 of file kino_common.cc. References AVI, PLAYLIST, QT, RAW_DV, and UNKNOWN_FORMAT. Referenced by appendFile(), bulkLoad(), generate_file_preview(), insertFile(), loadFile(), on_combo_trim_clip_entry_changed(), and on_combo_trim_clip_entry_focus_out_event(). { // Try reading a few bytes from the file ... std::ifstream file( FileName ); std::vector<char> buffer( 22, '\0' ); file.read( &buffer[ 0 ], buffer.size() ); // If it didn't work, we're done ... if ( file.bad() ) { cerr << "> Error reading file: " << FileName << endl; return UNKNOWN_FORMAT; } // If the file is shorter than our buffer, we're done ... if ( file.eof() ) { cerr << "> File size < " << buffer.size() << " bytes: " << FileName << endl; return UNKNOWN_FORMAT; } // Start looking at file suffixes ... const std::string filename( FileName ); const std::string suffix( filename.begin() + filename.rfind( "." ), filename.end() ); if ( suffix == ".avi" ) { return AVI; } else if ( suffix == ".dv" || suffix == ".dif" ) { // This bit of magic brought to you from the dvgrab AVI iso handler ... const unsigned char * const p = reinterpret_cast<unsigned char*>( &buffer[ 0 ] ); const int section_type = p[ 0 ] >> 5; const int dif_sequence = p[ 1 ] >> 4; if ( 0 == section_type && 0 == dif_sequence ) return RAW_DV; return UNKNOWN_FORMAT; } else if ( suffix == ".mov" ) { return QT; } // Check to see if it's SMIL ... const std::string smil_magic( "<?xml version=\"1.0\"?>" ); if ( std::string( buffer.begin(), buffer.begin() + smil_magic.size() ) == smil_magic ) return PLAYLIST; // No can do! return UNKNOWN_FORMAT; }

void KinoCommon::clean (   )  [protected]

Trigger the clean action of the current page. Definition at line 1747 of file kino_common.cc. References getCurrentPage(). Referenced by newFile(), setCurrentPage(), and ~KinoCommon(). { getCurrentPage() ->clean(); }

void KinoCommon::clearPreview (  GtkDrawingArea *  drawable  )

Make the video preview area black. Parameters: widget  the GtkDrawingArea to clear. Definition at line 2247 of file kino_common.cc. References widget. Referenced by PageTrim::windowMoved(), and PageCapture::windowMoved(). { GtkWidget * widget = GTK_WIDGET( drawable ); if ( widget->window && GDK_IS_DRAWABLE( widget->window ) ) { gdk_draw_rectangle ( widget->window, widget->style->black_gc, TRUE, widget->allocation.x, widget->allocation.y, widget->allocation.width, widget->allocation.height ); } }

void KinoCommon::commitComponentState (  component_enum  pattern = ( component_enum ) 0  )

Set the component state data and commit it. You can set component state at the same time too. See the toggleComponents() method. Parameters: pattern  A set of component_enums to set true Definition at line 2091 of file kino_common.cc. References component_state, and is_component_state_changing. Referenced by PageCapture::applyAVCState(), PageCapture::start(), start(), PageCapture::startCapture(), PageMagick::StartRender(), videoBack(), videoEndOfMovie(), videoEndOfScene(), videoFastForward(), videoForward(), videoNextScene(), videoPause(), PageMagick::videoPlay(), videoPlay(), videoPreviousScene(), videoRewind(), videoShuttle(), videoStartOfMovie(), videoStartOfScene(), and videoStop(). { this->component_state |= pattern; this->is_component_state_changing = false; }

bool KinoCommon::exitKino (   )

Definition at line 2303 of file kino_common.cc. References newFile(). { return newFile( false ); }

void KinoCommon::fetchProjectMetadata (  const std::string &  projectKey  )  [protected]

Uses libml2 to fetch the metadata from a CMS. Added for tagesschau.de. It uses config items newProjectURI to make an HTTP request and newProjectXPath to extract the project ID, and expands metaValues containing xpaths. Parameters: projectKey  a project name or identifier to put into the newProjectURI. Definition at line 168 of file kino_common.cc. References Preferences::getInstance(), getPlayList(), and modal_message(). Referenced by loadFile(), loadPlayList(), and newFile(). { if ( projectKey == "" ) return; // Fetch the project metadata from CMS char uri[1024]; uri[1023] = '\0'; snprintf( uri, 1023, Preferences::getInstance().newProjectURI, projectKey.c_str() ); cerr << "Composed Project URI " << uri << endl; xmlNanoHTTPInit(); void *httpContext = xmlNanoHTTPOpen( uri, NULL ); int code = 0; if ( httpContext && ( code = xmlNanoHTTPReturnCode( httpContext ) ) == 200 ) { char *buffer = (char*) calloc( 1, 1000 ); int size = 0; int nread; while ( ( nread = xmlNanoHTTPRead( httpContext, buffer + size, 999 ) ) > 0 ) { size += nread; if ( nread == 999 ) { buffer = ( char* )realloc( buffer, size + 999 ); buffer[ size + 1 ] = '\0'; } } // Parse the response xmlDocPtr doc = xmlParseMemory( buffer, size ); xmlXPathInit(); xmlXPathContextPtr xpathContext = xmlXPathNewContext( doc ); if ( xpathContext ) { xmlXPathObjectPtr xpathResult; // Extract the project ID if ( strcmp( Preferences::getInstance().newProjectXPath, "" ) ) { xpathResult = xmlXPathEval( (xmlChar*) Preferences::getInstance().newProjectXPath, xpathContext ); if ( xpathResult ) { if ( xpathResult->type == XPATH_NODESET && !xmlXPathNodeSetIsEmpty( xpathResult->nodesetval ) ) { getPlayList()->SetDocId( (char*) xmlXPathCastToString( xpathResult ) ); cerr << "newProject ID = " << xmlXPathCastToString( xpathResult ) << endl; if ( strcmp( reinterpret_cast< char* >( xmlXPathCastToString( xpathResult ) ), "" ) == 0 ) modal_message( _("The server returned an empty response.\n\nPlease choose File/New to query the server again.") ); } else modal_message( _("Failed to parse project metadata:\nthe result of newProjectXPath is empty") ); xmlXPathFreeObject( xpathResult ); } else modal_message( _("Failed to parse project metadata:\nbad newProjectXPath expression") ); } // Expand metaValues map< string, vector< std::pair< std::string, std::string > > >& metaValuesMap = Preferences::getInstance().metaValues; map< string, vector< std::pair< std::string, std::string > > >::iterator metaValuesMapIter; for ( metaValuesMapIter = metaValuesMap.begin(); metaValuesMapIter != metaValuesMap.end(); ++metaValuesMapIter ) { if ( metaValuesMapIter->second.size() > 0 ) { const string labelPath = metaValuesMapIter->second[0].first; const string valuePath = metaValuesMapIter->second[0].second; // Expand the label if ( labelPath.length() > 5 && labelPath.substr( 0, 6 ) == "xpath:" ) { // remove the xpath from the values metaValuesMapIter->second.erase( metaValuesMapIter->second.begin() ); xpathResult = xmlXPathEval( (xmlChar*) labelPath.substr( 6 ).c_str(), xpathContext ); if ( xpathResult ) { if ( xpathResult->type == XPATH_NODESET ) { for ( int i = 0; i < xmlXPathNodeSetGetLength( xpathResult->nodesetval ); i++ ) { string label( (char *) xmlXPathCastNodeToString( xmlXPathNodeSetItem( xpathResult->nodesetval, i ) ) ); metaValuesMapIter->second.push_back( make_pair( label, label ) ); } } xmlXPathFreeObject( xpathResult ); } else modal_message( _("Failed to parse project metadata:\nbad metaValues XPath expression") ); } // Expand the value if ( valuePath.length() > 5 && valuePath.substr( 0, 6 ) == "xpath:" ) { xpathResult = xmlXPathEval( (xmlChar*) valuePath.substr( 6 ).c_str(), xpathContext ); if ( xpathResult ) { if ( xpathResult->type == XPATH_NODESET ) { for ( int i = 0; i < xmlXPathNodeSetGetLength( xpathResult->nodesetval ); i++ ) metaValuesMapIter->second[ i ].second = (char *) xmlXPathCastNodeToString( xmlXPathNodeSetItem( xpathResult->nodesetval, i ) ); } xmlXPathFreeObject( xpathResult ); } else modal_message( _("Failed to parse project metadata:\nbad metaValues XPath expression") ); } } } xmlXPathFreeContext( xpathContext ); } free( buffer ); } else if ( httpContext ) { modal_message( "Server responded with error %d", code ); } if ( httpContext ) xmlNanoHTTPClose( httpContext ); xmlNanoHTTPCleanup(); }

component_enum KinoCommon::getComponentState (   )

Get the current component state data. Definition at line 2079 of file kino_common.cc. References component_state. Referenced by PageCapture::applyAVCState(), PageTrim::processKeyboard(), PageCapture::processKeyboard(), start(), PageMagick::StartRender(), PageTrim::videoBack(), PageMagick::videoBack(), PageEditor::videoBack(), PageTrim::videoEndOfMovie(), PageMagick::videoEndOfMovie(), PageEditor::videoEndOfMovie(), PageTrim::videoFastForward(), PageEditor::videoFastForward(), PageTrim::videoForward(), PageMagick::videoForward(), PageEditor::videoForward(), PageMagick::videoNextScene(), PageTrim::videoPause(), PageTrim::videoPlay(), PageMagick::videoPlay(), PageEditor::videoPlay(), PageMagick::videoPreviousScene(), PageTrim::videoRewind(), PageEditor::videoRewind(), videoShuttle(), PageMagick::videoStartOfMovie(), PageTrim::videoStop(), PageMagick::videoStop(), and PageEditor::videoStop(). { return ( component_enum ) this->component_state; }

Page * KinoCommon::getCurrentPage (   )

Returns the current Page object. Returns: the current Page object (will be PageUndefined if current page is invalid). Definition at line 475 of file kino_common.cc. References getPage(), and getPageUndefined(). Referenced by activateWidgets(), clean(), loadFile(), loadPlayList(), moveToFrame(), on_preferences_dialog_ok_button_clicked(), processCommand(), processKeyboard(), selectScene(), setTimeFormat(), showFrameInfo(), start(), videoBack(), videoEndOfMovie(), videoEndOfScene(), videoFastForward(), videoForward(), videoNextScene(), videoPause(), videoPlay(), videoPreviousScene(), videoRewind(), videoShuttle(), videoStartOfMovie(), videoStartOfScene(), videoStop(), visibilityChanged(), and windowMoved(). { Page * ret = getPage( this->currentPage ); if ( ret == NULL ) ret = getPageUndefined(); return ret; }

int KinoCommon::getCurrentScene (   )  [inline]

Definition at line 179 of file kino_common.h. References currentScene. Referenced by on_tool_change(), showScenesThread(), and Storyboard::Storyboard(). { return this->currentScene; }

char* KinoCommon::getFileToOpen (  char *  title, bool  isDVFile = true )  [inline]

Definition at line 258 of file kino_common.h. References getFileToOpen(), and getWidget(). { return getFileToOpen( title, isDVFile, getWidget() ); }

char * KinoCommon::getFileToOpen (  char *  title, bool  isDVFile, GtkWidget *  widget )

Handles the modal dialog for collecting a file to open. The file is not opened, but returned by this method. Parameters: title  title of the window Returns: a string inidicating the selected file (an empty string denotes no selection) Definition at line 1079 of file kino_common.cc. References directory_utils::get_directory_from_file(), getPlayList(), getWidgetWindow(), last_directory, tempFileName, and update_preview_cb(). Referenced by appendFile(), getFileToOpen(), insertFile(), loadFile(), ImageCreateFromFile::on_button_file_clicked(), AudioMix::on_button_mix_file_clicked(), AudioDub::on_button_sub_file_clicked(), and on_button_trim_open_clicked(). { GtkWidget *dialog; GtkDrawingArea *preview; GtkFileFilter *filter; dialog = gtk_file_chooser_dialog_new( title, getWidgetWindow(widget), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, static_cast<gchar*>( NULL ) ); gtk_dialog_set_alternative_button_order( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1 ); // gtk_file_chooser_set_select_multiple( GTK_FILE_CHOOSER(dialog), TRUE ); if ( isDVFile ) { preview = ( GtkDrawingArea* )gtk_drawing_area_new(); gtk_widget_set_size_request( GTK_WIDGET(preview), 160, 120 ); gtk_file_chooser_set_preview_widget( GTK_FILE_CHOOSER(dialog), GTK_WIDGET(preview) ); g_signal_connect( dialog, "update-preview", G_CALLBACK(update_preview_cb), preview ); filter = gtk_file_filter_new(); gtk_file_filter_set_name( filter, "All Files" ); gtk_file_filter_add_pattern( filter, "*" ); gtk_file_chooser_add_filter( GTK_FILE_CHOOSER(dialog), filter ); filter = gtk_file_filter_new(); gtk_file_filter_set_name( filter, "SMIL Files (*.smil, *.kino)" ); gtk_file_filter_add_pattern( filter, "*.smil" ); gtk_file_filter_add_pattern( filter, "*.kino" ); gtk_file_chooser_add_filter( GTK_FILE_CHOOSER(dialog), filter ); filter = gtk_file_filter_new(); gtk_file_filter_set_name( filter, "Raw DV Files (*.dv, *.dif)" ); gtk_file_filter_add_pattern( filter, "*.dv" ); gtk_file_filter_add_pattern( filter, "*.dif" ); gtk_file_chooser_add_filter( GTK_FILE_CHOOSER(dialog), filter ); filter = gtk_file_filter_new(); gtk_file_filter_set_name( filter, "AVI Files (*.avi)" ); gtk_file_filter_add_pattern( filter, "*.avi" ); gtk_file_chooser_add_filter( GTK_FILE_CHOOSER(dialog), filter ); #ifdef HAVE_LIBQUICKTIME filter = gtk_file_filter_new(); gtk_file_filter_set_name( filter, "Quicktime Files (*.mov)" ); gtk_file_filter_add_pattern( filter, "*.mov" ); gtk_file_chooser_add_filter( GTK_FILE_CHOOSER(dialog), filter ); #endif } gtk_window_set_modal( GTK_WINDOW( dialog ), TRUE ); if ( last_directory == "" ) { string directory = getPlayList() ->GetProjectDirectory( ); if ( directory != "" ) gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( dialog ), ( char * ) ( directory + "/" ).c_str() ); last_directory = directory; } else { gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( dialog ), ( char * ) ( last_directory + "/" ).c_str() ); } if (gtk_dialog_run( GTK_DIALOG( dialog ) ) == GTK_RESPONSE_ACCEPT) { gchar *filename = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER( dialog )); if ( filename ) { strncpy( tempFileName, filename, sizeof(tempFileName) ); last_directory = directory_utils::get_directory_from_file( filename ); g_free( filename ); } else strcpy( tempFileName, "" ); } else strcpy( tempFileName, "" ); gtk_widget_destroy( dialog ); return tempFileName; }

char* KinoCommon::getFileToSave (  char *  title  )  [inline]

Definition at line 262 of file kino_common.h. References getFileToSaveFormat(), and getWidget(). Referenced by on_button_export_audio_file_clicked(), on_button_export_avi_file_clicked(), on_button_export_mjpeg_file_clicked(), on_button_export_pipe_file_clicked(), on_button_export_stills_file_clicked(), on_button_magick_file_clicked(), on_button_v4l_file_clicked(), on_capture_file_button_clicked(), publishFrame(), PageCapture::saveFrame(), and saveFrame(). { int format = 0; return getFileToSaveFormat( title, getWidget(), format ); }

char* KinoCommon::getFileToSaveFormat (  char *  title, int &  format )  [inline]

Definition at line 267 of file kino_common.h. References getFileToSaveFormat(), and getWidget(). { return getFileToSaveFormat( title, getWidget(), format ); }

char * KinoCommon::getFileToSaveFormat (  char *  title, GtkWidget *  widget, int &  format )

Definition at line 1163 of file kino_common.cc. References getPlayList(), getWidgetWindow(), last_directory, and tempFileName. Referenced by getFileToSave(), getFileToSaveFormat(), on_button_capture_open_clicked(), and savePlayListAs(). { GtkWidget *dialog; GtkComboBox* formatCombo = NULL; dialog = gtk_file_chooser_dialog_new( title, getWidgetWindow(widget), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, static_cast<gchar*>( NULL ) ); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1); gtk_window_set_modal( GTK_WINDOW( dialog ), TRUE ); gtk_dialog_set_default_response( GTK_DIALOG( dialog ), GTK_RESPONSE_ACCEPT ); if ( format ) { GtkWidget* hbox = gtk_hbox_new( FALSE, 6 ); GtkWidget* label = gtk_label_new_with_mnemonic( _("F_ormat:") ); formatCombo = GTK_COMBO_BOX( gtk_combo_box_new_text() ); gtk_widget_show( hbox ); gtk_widget_show( label ); gtk_widget_show( GTK_WIDGET( formatCombo ) ); gtk_combo_box_append_text( formatCombo, "SMIL 2.0" ); gtk_combo_box_append_text( formatCombo, "Kino < 0.9.1 XML" ); gtk_combo_box_append_text( formatCombo, "MJPEG Tools ELI" ); gtk_combo_box_append_text( formatCombo, "SRT subtitle" ); gtk_combo_box_set_active( formatCombo, 0 ); gtk_box_pack_start( GTK_BOX(hbox), label, FALSE, FALSE, 0 ); gtk_box_pack_start( GTK_BOX(hbox), GTK_WIDGET(formatCombo), FALSE, FALSE, 0 ); gtk_file_chooser_set_extra_widget( GTK_FILE_CHOOSER( dialog ), hbox ); } if ( last_directory == "" ) { string directory = getPlayList() ->GetProjectDirectory( ); if ( directory != "" ) gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( dialog ), ( char * ) ( directory + "/" ).c_str() ); last_directory = directory; } else { gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( dialog ), ( char * ) ( last_directory + "/" ).c_str() ); } if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { char *filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); if ( filename ) { strncpy (tempFileName, filename, sizeof(tempFileName)); g_free (filename); } else strcpy( tempFileName, "" ); } else strcpy(tempFileName, ""); if ( format ) format = gtk_combo_box_get_active( GTK_COMBO_BOX(formatCombo) ); gtk_widget_destroy (dialog); return tempFileName; }

string KinoCommon::getLastDirectory (   )  [inline]

Definition at line 295 of file kino_common.h. References PlayList::GetProjectDirectory(), last_directory, and playlist. { if ( last_directory == "" ) last_directory = playlist.GetProjectDirectory( ); return ( last_directory + "/" ); }

Page * KinoCommon::getPage (  int  page  )

Returns the Page object associated to the specified notebook page. Parameters: page  index of Page object to return Returns: the Page object associated to the given notebook page or NULL if invalid. Definition at line 438 of file kino_common.cc. References getPageBttv(), getPageCapture(), getPageEditor(), getPageExport(), getPageMagick(), getPageTimeline(), getPageTrim(), PAGE_BTTV, PAGE_CAPTURE, PAGE_EDITOR, PAGE_EXPORT, PAGE_MAGICK, PAGE_TIMELINE, and PAGE_TRIM. Referenced by getCurrentPage(), and newFile(). { Page * ret = NULL; switch ( page ) { case PAGE_EDITOR: ret = getPageEditor(); break; case PAGE_CAPTURE: ret = getPageCapture(); break; case PAGE_TIMELINE: ret = getPageTimeline(); break; case PAGE_TRIM: ret = getPageTrim(); break; case PAGE_EXPORT: ret = getPageExport(); break; case PAGE_MAGICK: ret = getPageMagick(); break; case PAGE_BTTV: ret = getPageBttv(); break; } return ret; }

PageBttv * KinoCommon::getPageBttv (   )

Returns the 'BTTV' page (test code for extending hardware support). Returns: the Page object requested Definition at line 528 of file kino_common.cc. References bttv. Referenced by getPage(), on_v4l_capture_page_record_button_clicked(), and on_v4l_capture_page_stop_button_clicked(). { return bttv; }

PageCapture * KinoCommon::getPageCapture (   )

Returns the Page associated to the Capture page. Returns: the Page object requested Definition at line 498 of file kino_common.cc. References capture. Referenced by avcThread(), captureThread(), getPage(), on_capture_page_avc_button_clicked(), AVC::ResetHandler(), saveFrame(), setPreviewSize(), and videoThread(). { return capture; }

PageEditor * KinoCommon::getPageEditor (   )

Returns the Page associated to the Editor page. Returns: the Page object requested Definition at line 488 of file kino_common.cc. References editor. Referenced by appendFile(), audioThread(), bulkLoad(), PageCapture::collectFiles(), ExportMJPEG::createAuthorXml(), ExportAVI::doExport(), getPage(), getSceneFromPath(), PageTrim::getSceneIndex(), insertFile(), PageTrim::insertScene(), loadFile(), loadMediaObject(), loadPlayList(), PageTrim::movedToFrame(), PageMagick::movedToFrame(), Storyboard::moveScene(), newFile(), PageTrim::processCommand(), readThread(), PageTrim::saveScene(), PageTrim::selectScene(), PageTimeline::selectScene(), PageMagick::selectScene(), Export::selectScene(), setCurrentScene(), showScenesThread(), PageTimeline::start(), PageMagick::StartRender(), PageCapture::stopCapture(), and videoThread(). { return editor; }

PageExport * KinoCommon::getPageExport (   )

Returns the Export page. Returns: the Page object requested Definition at line 538 of file kino_common.cc. References exportPage. Referenced by getPage(), on_spinbutton_export_range_start_end_changed(), and Export::selectSection(). { return exportPage; }

PageMagick * KinoCommon::getPageMagick (   )

Returns the Magick page. Returns: the Page object requested Definition at line 558 of file kino_common.cc. References magickPage. Referenced by GetKeyFrameController(), getPage(), GetSelectedFramesForFX(), PageMagickAudioTransition::Initialise(), PageMagickAudioFilter::Initialise(), PageMagickFilter::Initialise(), PageMagickTransition::Initialise(), PageMagickCreate::Initialise(), newFile(), on_hscale_transition_end_button_press_event(), on_hscale_transition_end_button_release_event(), on_hscale_transition_start_button_press_event(), on_hscale_transition_start_button_release_event(), on_notebook_magick_switch_page(), on_notebook_magick_switch_video_page(), on_spinbutton_magick_end_value_changed(), on_spinbutton_magick_limit_value_changed(), on_spinbutton_magick_start_value_changed(), on_time_range_changed(), on_togglebutton_magick_start_toggled(), GDKImageTransitionRepository::SelectionChange(), GDKImageFilterRepository::SelectionChange(), GDKImageCreateRepository::SelectionChange(), GDKAudioTransitionRepository::SelectionChange(), and GDKAudioFilterRepository::SelectionChange(). { return magickPage; }

PageTimeline * KinoCommon::getPageTimeline (   )

Returns the Page associated to the Timeline page. Returns: the Page object requested Definition at line 508 of file kino_common.cc. References timeline. Referenced by getPage(), and on_timeline_ok_button_pressed(). { return timeline; }

PageTrim * KinoCommon::getPageTrim (   )

Returns the Trim page. Returns: the Page object requested Definition at line 548 of file kino_common.cc. References trimPage. Referenced by audioThread(), getPage(), moveByFrames(), moveToFrame(), on_button_trim_in_reset_clicked(), on_button_trim_in_set_clicked(), on_button_trim_insert_after_clicked(), on_button_trim_insert_before_clicked(), on_button_trim_out_reset_clicked(), on_button_trim_out_set_clicked(), on_combo_trim_clip_entry_changed(), on_combo_trim_clip_entry_focus_out_event(), on_menuitem_trim_insert_activate(), on_menuitem_trim_update_activate(), on_trim_value_changed_event(), PageTrim::processCommand(), readThread(), and videoThread(). { return trimPage; }

PageUndefined * KinoCommon::getPageUndefined (   )

Returns the Page associated to the Undefined page. Returns: the Page object requested Definition at line 518 of file kino_common.cc. References undefined. Referenced by getCurrentPage(). { return undefined; }

PlayList* KinoCommon::getPlayList (   )  [inline]

Definition at line 174 of file kino_common.h. References playlist. Referenced by _getOneSecond(), Export::activate(), appendFile(), PageMagick::AudioThread(), bulkLoad(), PageCapture::collectFiles(), PageEditor::CopyFrames(), PageEditor::DeleteFrames(), ExportPipe::doExport(), fetchProjectMetadata(), PageMagickInfo::GetAnteFrame(), GetCurrentPlayList(), getFileToOpen(), getFileToSaveFormat(), PageMagickAudioTransition::GetFrame(), PageMagickOverwrite::GetFrame(), getOneSecond(), PageMagickInfo::GetPostFrame(), PageTrim::getSceneIndex(), importFile(), PageMagickInfo::Initialise(), PageMagickCreate::Initialise(), insertFile(), PageTrim::insertScene(), PageTrim::loadFile(), loadFile(), loadMediaObject(), loadPlayList(), PageTrim::loadScene(), PageTrim::movedToFrame(), PageMagick::movedToFrame(), Storyboard::moveScene(), moveToFrame(), newFile(), on_name_edited(), on_name_show_popup(), on_spinbutton_magick_start_value_changed(), on_value_edited(), PageEditor::PasteFrames(), PageTrim::processCommand(), PageTimeline::processCommand(), PageEditor::processCommand(), publishFrame(), readThread(), PageEditor::ResetBar(), saveFrame(), savePlayList(), savePlayListAs(), PageTrim::saveScene(), PageTrim::selectScene(), PageTimeline::selectScene(), PageMagick::selectScene(), Export::selectScene(), PageTrim::setMode(), setPreviewSize(), setWindowTitle(), PageEditor::showFrame(), PageMagick::showFrameInfo(), PageEditor::showFrameInfo(), showScenesThread(), PageEditor::snapshot(), PageTrim::start(), PageTimeline::start(), PageMagick::start(), PageCapture::start(), PageBttv::start(), Export::startExport(), PageMagick::StartRender(), PageCapture::stopCapture(), PageTimeline::Thread(), PageEditor::videoEndOfMovie(), PageEditor::videoEndOfScene(), PageEditor::videoNextScene(), PageEditor::videoPreviousScene(), PageEditor::videoStartOfScene(), PageMagick::VideoThread(), and PageEditor::windowMoved(). { return & playlist; }

SMIL::MediaClippingTime& KinoCommon::getTime (   )  [inline]

Definition at line 290 of file kino_common.h. References time. Referenced by ExportMJPEG::createAuthorXml(), on_end_spin_value_changed(), on_entry_export_end_activate(), on_entry_export_start_activate(), on_entry_magick_end_activate(), on_entry_magick_limit_activate(), on_entry_magick_start_activate(), on_entry_timeline_end_activate(), on_entry_timeline_start_activate(), on_entry_trim_in_activate(), on_entry_trim_out_activate(), on_spinbutton_export_range_end_value_changed(), on_spinbutton_export_range_start_value_changed(), on_spinbutton_magick_end_value_changed(), on_spinbutton_magick_limit_value_changed(), on_spinbutton_magick_start_value_changed(), on_spinbutton_trim_in_value_changed(), on_spinbutton_trim_out_value_changed(), on_start_spin_value_changed(), PageTrim::showFrameInfo(), PageMagick::showFrameInfo(), PageEditor::showFrameInfo(), PageCapture::showFrameInfo(), and PageTimeline::Thread(). { return time; }

SMIL::Time::TimeFormat KinoCommon::getTimeFormat (   )  const [inline]

Definition at line 285 of file kino_common.h. References Preferences::getInstance(). Referenced by on_end_spin_value_changed(), on_entry_export_end_activate(), on_entry_export_start_activate(), on_entry_magick_end_activate(), on_entry_magick_limit_activate(), on_entry_magick_start_activate(), on_entry_timeline_end_activate(), on_entry_timeline_start_activate(), on_entry_trim_in_activate(), on_entry_trim_out_activate(), on_spinbutton_export_range_end_value_changed(), on_spinbutton_export_range_start_value_changed(), on_spinbutton_magick_end_value_changed(), on_spinbutton_magick_limit_value_changed(), on_spinbutton_magick_start_value_changed(), on_spinbutton_trim_in_value_changed(), on_spinbutton_trim_out_value_changed(), on_start_spin_value_changed(), PageTrim::showFrameInfo(), PageMagick::showFrameInfo(), PageEditor::showFrameInfo(), PageCapture::showFrameInfo(), showScenesThread(), and PageTimeline::Thread(). { return static_cast< SMIL::Time::TimeFormat >( Preferences::getInstance().timeFormat ); }

GtkWidget* KinoCommon::getWidget (   )  [inline]

Definition at line 169 of file kino_common.h. References widget. Referenced by ExportPipe::activateTool(), ExportMJPEG::activateTool(), PageEditor::clean(), ExportStills::doExport(), ExportPipe::doExport(), ExportMJPEG::doExport(), ExportAVI::doExport(), Export1394::doExport(), Export::Export(), Export1394::Export1394(), ExportAudio::ExportAudio(), ExportAVI::ExportAVI(), ExportMJPEG::ExportMJPEG(), ExportPipe::ExportPipe(), ExportStills::ExportStills(), getFileToOpen(), getFileToSave(), getFileToSaveFormat(), GetKinoWidgetWindow(), PageExport::getWidget(), importFile(), PageTrim::insertScene(), PageTrim::loadScene(), modal_confirm(), modal_message(), modal_prompt(), PageTrim::movedToFrame(), on_optionmenu_jogshuttle_action_clicked(), on_optionmenu_jogshuttle_firstsecond_button_clicked(), packIt(), PageCapture::PageCapture(), PageEditor::PageEditor(), PageExport::PageExport(), PageMagick::PageMagick(), PageTimeline::PageTimeline(), PageTrim::PageTrim(), PageMagick::processCommand(), PageExport::processCommand(), PageCapture::processKeyboard(), PageTrim::saveScene(), PageTimeline::selectScene(), ExportPipe::selectTool(), setCurrentPage(), PageTrim::setMode(), setPreviewSize(), PageMagick::showFrameInfo(), PageCapture::showFrameInfo(), PageTrim::start(), PageTimeline::start(), PageMagick::start(), ExportMJPEG::start(), PageExport::start(), PageEditor::start(), PageCapture::start(), PageBttv::start(), start(), Export::startExport(), Storyboard::Storyboard(), PageTimeline::Thread(), PageTrim::timeFormatChanged(), PageTimeline::timeFormatChanged(), PageExport::timeFormatChanged(), and PageMagick::~PageMagick(). { return this->widget; }

GtkWindow * KinoCommon::getWidgetWindow (  GtkWidget *  widget  )  [static]

Definition at line 74 of file kino_common.cc. Referenced by getFileToOpen(), getFileToSaveFormat(), GetKinoWidgetWindow(), importFile(), modal_confirm_with_parent(), modal_message_with_parent(), and modal_prompt_with_parent(). { if(widget) if(GTK_IS_WINDOW(widget)) return GTK_WINDOW(widget); else return getWidgetWindow(widget->parent); else return NULL; }

std::string KinoCommon::importFile (  const char *  filename  )

Give option to import a file by transcoding to DV. Definition at line 566 of file kino_common.cc. References ASPECT_169, AUDIO_32KHZ, AUDIO_44KHZ, AUDIO_48KHZ, command, g_currentFrame, Frame::GetAudioInfo(), GetFramePool(), Preferences::getInstance(), getPlayList(), getWidget(), getWidgetWindow(), Frame::IsPAL(), lookup_widget(), modal_confirm(), NORM_NTSC, NORM_PAL, NORM_UNSPECIFIED, StringUtils::replaceAll(), and widget. Referenced by appendFile(), bulkLoad(), insertFile(), loadFile(), and on_combo_trim_clip_entry_changed(). { std::string importedFile( filename ); if ( modal_confirm( GTK_STOCK_OK, NULL, _("\"%s\" is not a DV file. Do you want to import it?"), filename ) == GTK_RESPONSE_ACCEPT ) { char * args[ 7 ]; int pid, status = -1; GError *gerror = NULL; gboolean visible = TRUE; GtkWidget *dialog = lookup_widget( widget, "import_window" ); GtkProgressBar *progressBar = GTK_PROGRESS_BAR( lookup_widget( widget, "progressbar_import" ) ); char *kinoHome = getenv("KINO_HOME"); string homeFile; int testHomeFile = 0; if ( kinoHome ) homeFile = string( kinoHome ) + string( "/import/media.sh" ); else homeFile = string( getenv( "HOME" ) ) + string( "/kino/import/media.sh" ); gtk_window_set_transient_for( GTK_WINDOW( dialog ), GTK_WINDOW( getWidgetWindow( getWidget() ) ) ); gtk_progress_bar_pulse( progressBar ); gtk_widget_show_all( dialog ); // Check if media is loaded if ( g_currentFrame == -1 ) { // Use Preferences/Defaults if ( Preferences::getInstance().defaultNormalisation == NORM_UNSPECIFIED ) { switch ( modal_confirm( "PAL", "NTSC", _("Please choose a video standard") ) ) { case GTK_RESPONSE_ACCEPT: Preferences::getInstance().defaultNormalisation = NORM_PAL; break; case GTK_RESPONSE_CLOSE: Preferences::getInstance().defaultNormalisation = NORM_NTSC; break; default: // Do nothing - action cancelled gtk_widget_hide( dialog ); return importedFile; } } args[ 3 ] = const_cast<char*>( Preferences::getInstance().defaultNormalisation == NORM_PAL ? "pal" : "ntsc" ); args[ 4 ] = const_cast<char*>( Preferences::getInstance().defaultAspect == ASPECT_169 ? "16:9" : "4:3" ); switch ( Preferences::getInstance().defaultAudio ) { case AUDIO_32KHZ: args[ 5 ] = "32000"; break; case AUDIO_44KHZ: args[ 5 ] = "44100"; break; case AUDIO_48KHZ: args[ 5 ] = "48000"; break; } } else { // Use first frame Frame& frame = *GetFramePool()->GetFrame(); AudioInfo ainfo; std::ostringstream strstream; this->getPlayList() ->GetFrame( 0, frame ); frame.GetAudioInfo( ainfo ); strstream << ainfo.frequency; args[ 3 ] = const_cast<char*>( frame.IsPAL() ? "pal" : "ntsc" ); args[ 4 ] = const_cast<char*>( frame.IsWide() ? "16:9" : "4:3" ); args[ 5 ] = const_cast<char*>( strstream.str().c_str() ); GetFramePool()->DoneWithFrame( &frame ); } importedFile = StringUtils::replaceAll( importedFile, "\"", "\\\"") + std::string( ".dv" ); args[ 0 ] = DATADIR "/kino/scripts/import/media.sh"; args[ 1 ] = const_cast<char*>( filename ); args[ 2 ] = const_cast<char*>( importedFile.c_str() ); args[ 6 ] = NULL; // Allow a script in home directory to override testHomeFile = open( homeFile.c_str(), O_RDONLY ); if ( testHomeFile > -1 ) { close( testHomeFile ); args[ 0 ] = const_cast< char* >( homeFile.c_str() ); } std::ostringstream command; command << "\"" << args[0] << "\" \"" << args[1] << "\" \"" << args[2] << "\" " << args[3] << " " << args[4] << " " << args[5]; args[ 0 ] = "/bin/sh"; args[ 1 ] = "-c"; args[ 2 ] = const_cast< char* >( command.str().c_str() ); args[ 3 ] = NULL; g_spawn_async_with_pipes( ".", args, NULL, G_SPAWN_DO_NOT_REAP_CHILD, NULL, NULL, &pid, NULL, NULL, NULL, &gerror ); // Check for cancellation or child exit while ( ! WIFEXITED( status ) && visible ) { timespec ts = { 0, 100000000L }; while ( gtk_events_pending() ) gtk_main_iteration(); nanosleep( &ts, NULL ); gtk_progress_bar_pulse( progressBar ); g_object_get( G_OBJECT( dialog ), "visible", &visible, static_cast<gchar*>( NULL ) ); waitpid( pid, &status, WNOHANG ); } if ( ! WIFEXITED( status ) ) { kill( pid, SIGTERM ); waitpid( pid, &status, WNOHANG ); if ( ! WIFEXITED( status ) ) { timespec ts = { 0, 100000000L }; nanosleep( &ts, NULL ); kill( pid, SIGKILL ); waitpid( pid, &status, 0 ); } } gtk_widget_hide( dialog ); } return importedFile; }

void KinoCommon::insertFile (   )

Inserts a file at the current position. Definition at line 701 of file kino_common.cc. References AVI, changePageRequest(), checkFile(), g_currentFrame, getFileToOpen(), getPageEditor(), getPlayList(), hasListChanged, importFile(), loadMediaObject(), loadPlayList(), modal_message(), moveToFrame(), PAGE_EDITOR, PLAYLIST, QT, RAW_DV, setWindowTitle(), and UNKNOWN_FORMAT. Referenced by PageEditor::processCommand(). { changePageRequest( PAGE_EDITOR ); char * filename = this->getFileToOpen( _( "Choose a DV or SMIL file to insert" ) ); if ( filename && strcmp( filename, "" ) ) { switch ( checkFile( filename ) ) { case AVI: case RAW_DV: case QT: if ( loadMediaObject( filename, g_currentFrame == -1 ? 0 : g_currentFrame ) ) { hasListChanged = TRUE; getPlayList() ->SetDirty( true ); break; } // Else, ask to import case UNKNOWN_FORMAT: { const std::string& importedFile = importFile( filename ); if ( loadMediaObject( const_cast<char*>( importedFile.c_str() ), g_currentFrame == -1 ? 0 : g_currentFrame ) ) { hasListChanged = TRUE; getPlayList() ->SetDirty( true ); } else { modal_message( _( "Failed to load media file \"%s\"" ), importedFile.c_str() ); } break; } case PLAYLIST: if ( loadPlayList( filename, g_currentFrame ) ) { hasListChanged = TRUE; getPlayList() ->SetDirty( true ); getPageEditor() ->snapshot(); } break; } } setWindowTitle(); moveToFrame( ); }

void KinoCommon::keyboardFeedback (  const char *  cmd, const char *  msg )

Relay the current command and any message associated to it. Parameters: cmd  command msg  message; Definition at line 1576 of file kino_common.cc. References setStatusBar(). Referenced by PageTrim::processCommand(), PageTimeline::processCommand(), PageMagick::processCommand(), PageExport::processCommand(), PageEditor::processCommand(), PageCapture::processCommand(), PageMagick::processKeyboard(), PageExport::processKeyboard(), PageEditor::processKeyboard(), PageCapture::processKeyboard(), PageTrim::videoShuttle(), and PageEditor::videoShuttle(). { char s[ 256 ]; strcpy( s, cmd ); strcat( s, " " ); strcat( s, msg ); setStatusBar( s ); }

void KinoCommon::loadFile (   )

Opens a file. An AVI or a PLAYLIST causes a newFile to called prior to the load and a PLAYLIST becomes the currently editted file. Definition at line 807 of file kino_common.cc. References AVI, changePageRequest(), checkFile(), currentScene, fetchProjectMetadata(), g_currentFrame, getCurrentPage(), GetEditorBackup(), getFileToOpen(), getPageEditor(), getPlayList(), hasListChanged, importFile(), loadMediaObject(), loadPlayList(), modal_message(), moveToFrame(), newFile(), PAGE_EDITOR, PLAYLIST, QT, RAW_DV, setWindowTitle(), and UNKNOWN_FORMAT. { changePageRequest( PAGE_EDITOR ); char * filename = this->getFileToOpen( _( "Choose a DV or SMIL file" ) ); bool askNewFile = true; if ( filename && strcmp( filename, "" ) ) { switch ( checkFile( filename ) ) { case AVI: case RAW_DV: case QT: askNewFile = false; if ( newFile( ) ) { GetEditorBackup() ->Clear(); if ( loadMediaObject( filename, 0 ) ) { g_currentFrame = 0; hasListChanged = TRUE; break; } // Else, ask to import } else break; case UNKNOWN_FORMAT: if ( ( askNewFile && newFile( ) ) || ! askNewFile ) { const std::string& importedFile = importFile( filename ); GetEditorBackup() ->Clear(); if ( loadMediaObject( const_cast<char*>( importedFile.c_str() ), 0 ) ) { g_currentFrame = 0; hasListChanged = TRUE; } else { modal_message( _( "Failed to load media file \"%s\"" ), importedFile.c_str() ); } } break; case PLAYLIST: if ( newFile( false ) ) { GetEditorBackup() ->Clear(); if ( loadPlayList( filename, 0 ) ) { g_currentFrame = 0; hasListChanged = TRUE; getPageEditor( ) ->snapshot( ); getPlayList( ) ->SetDocName( filename ); getPlayList( ) ->SetDirty( false ); fetchProjectMetadata( getPlayList()->GetDocId() ); } } break; } } setWindowTitle(); this->currentScene = 0; this->getCurrentPage()->clean(); this->getCurrentPage()->start(); moveToFrame( ); }

bool KinoCommon::loadMediaObject (  char *  file, int  before )

Loads the specified media file before the specified frame. Parameters: file  file to load before  frame to insert at Definition at line 1325 of file kino_common.cc. References getPageEditor(), getPlayList(), and PlayList::LoadMediaObject(). Referenced by appendFile(), bulkLoad(), PageCapture::collectFiles(), insertFile(), loadFile(), and PageCapture::stopCapture(). { PlayList newList; bool result = true; try { if ( newList.LoadMediaObject( file ) ) { this->getPlayList() ->InsertPlayList( newList, before ); getPageEditor() ->snapshot(); } else { result = false; } } catch ( string s ) { cerr << "Could not load file " << file << ", because an exception has occurred: " << endl; cerr << s << endl; result = false; } return result; }

bool KinoCommon::loadPlayList (  char *  file, int  before )  [protected]

Loads the specified play list before the specified frame. Parameters: file  file to load before  frame to insert at Definition at line 1360 of file kino_common.cc. References PlayList::GetDocId(), PlayList::GetDocTitle(), getPlayList(), PlayList::LoadPlayList(), and modal_message(). { PlayList newList; bool result = newList.LoadPlayList( file ); if ( result ) { this->getPlayList() ->InsertPlayList( newList, before ); // propogate these new attributes if ( newList.GetDocId() != "" ) this->getPlayList()->SetDocId( newList.GetDocId().c_str() ); if ( newList.GetDocTitle() != "" ) this->getPlayList()->SetDocTitle( newList.GetDocTitle().c_str() ); } else modal_message( _( "Could not load the SMIL file \"%s\"" ), file ); return result; }

void KinoCommon::loadPlayList (  char *   )

Definition at line 2410 of file kino_common.cc. References currentScene, fetchProjectMetadata(), g_currentFrame, directory_utils::get_directory_from_file(), getCurrentPage(), GetEditorBackup(), getPageEditor(), getPlayList(), hasListChanged, moveToFrame(), newFile(), setLastDirectory(), and setWindowTitle(). Referenced by appendFile(), bulkLoad(), insertFile(), loadFile(), and on_open_recent_activate(). { if ( newFile( false ) ) { GetEditorBackup() ->Clear(); if ( loadPlayList( filename, 0 ) ) { g_currentFrame = 0; hasListChanged = TRUE; getPageEditor( ) ->snapshot( ); getPlayList( ) ->SetDocName( filename ); getPlayList( ) ->SetDirty( false ); fetchProjectMetadata( getPlayList()->GetDocId() ); } } setWindowTitle(); this->currentScene = 0; this->getCurrentPage()->clean(); this->getCurrentPage()->start(); moveToFrame( ); setLastDirectory( directory_utils::get_directory_from_file( filename ) ); }

void KinoCommon::loadSplash (  GtkDrawingArea *  drawable  )

Load the splash image into the video preview area. Parameters: widget  the GtkDrawingArea into which to render the image. Definition at line 2215 of file kino_common.cc. References create_pixbuf(). Referenced by PageEditor::newFile(), PageTrim::showFrame(), PageEditor::showFrame(), and PageEditor::windowMoved(). { if ( drawable && ( ( GtkWidget* ) drawable )->window ) { GdkGC *gc = gdk_gc_new( ( ( GtkWidget* ) drawable ) ->window ); if ( gc ) { GdkPixbuf *splash = create_pixbuf( "about.jpeg" ); if ( splash ) { int width = ( ( GtkWidget* ) drawable ) ->allocation.width; int height = ( ( GtkWidget* ) drawable ) ->allocation.height; GdkPixbuf *image = gdk_pixbuf_scale_simple( splash, width, height, GDK_INTERP_BILINEAR ); if ( image ) { gdk_draw_pixbuf( ( ( GtkWidget * ) drawable ) ->window, gc, image, 0, 0, 0, 0, -1, -1, GDK_RGB_DITHER_NORMAL, 0, 0 ); g_object_unref( image ); } g_object_unref( splash ); } g_object_unref( gc ); } } }

int KinoCommon::moveByFrames (  int  frames  )

Move the frame relative to the number specified. Parameters: frames  requested frame offset Returns: the frame actually moved to Definition at line 1645 of file kino_common.cc. References currentPage, g_currentFrame, getPageTrim(), moveToFrame(), and PAGE_TRIM. Referenced by PageMagick::processCommand(), PageEditor::processCommand(), PageTrim::videoBack(), PageEditor::videoBack(), PageTrim::videoForward(), and PageEditor::videoForward(). { if ( frames == 0 ) return g_currentFrame; int frame = g_currentFrame + frames; if ( currentPage == PAGE_TRIM ) frame = getPageTrim() ->getPosition() + frames; return moveToFrame( frame ); }

int KinoCommon::moveToFrame (  int  frame  )

Move to the frame specified. Corrects the frame specified to be within the range of the current play list and informs the currently selected page of the change. Parameters: frame  requested frame Returns: the frame actually moved to Definition at line 1617 of file kino_common.cc. References currentPage, g_currentFrame, getCurrentPage(), getPlayList(), PAGE_MAGICK, and PAGE_TRIM. { if ( currentPage == PAGE_TRIM || currentPage == PAGE_MAGICK ) { getCurrentPage()->movedToFrame( frame ); return frame; } if ( frame >= 0 && frame < getPlayList() ->GetNumFrames() ) g_currentFrame = frame; else if ( frame >= getPlayList() ->GetNumFrames() ) g_currentFrame = getPlayList() ->GetNumFrames() - 1; else if ( frame < 0 && getPlayList() ->GetNumFrames() > 0 ) g_currentFrame = 0; else g_currentFrame = -1; getCurrentPage() ->movedToFrame( g_currentFrame ); return g_currentFrame; }

int KinoCommon::moveToFrame (   )

Move to the current frame. Corrects the frame specified to be within the range of the current play list and informs the currently selected page of the change. Parameters: frame  requested frame Returns: the frame actually moved to Definition at line 1595 of file kino_common.cc. References currentPage, PlayList::FindStartOfScene(), g_currentFrame, getPageTrim(), PAGE_MAGICK, PAGE_TRIM, and playlist. Referenced by appendFile(), insertFile(), loadFile(), loadPlayList(), moveByFrames(), Storyboard::moveScene(), on_iconview_timeline_item_activated(), on_iconview_timeline_selection_changed(), on_preferences_dialog_ok_button_clicked(), PageTrim::processCommand(), PageTimeline::processCommand(), PageEditor::processCommand(), PageEditor::selectScene(), Export::selectScene(), setCurrentPage(), setTimeFormat(), PageEditor::videoEndOfMovie(), PageEditor::videoEndOfScene(), PageEditor::videoNextScene(), PageEditor::videoPreviousScene(), PageEditor::videoStartOfMovie(), and PageEditor::videoStartOfScene(). { if ( currentPage == PAGE_TRIM ) { getPageTrim() ->movedToFrame( getPageTrim() ->getPosition() ); return getPageTrim() ->getPosition(); } else if ( currentPage == PAGE_MAGICK ) { return moveToFrame( g_currentFrame - playlist.FindStartOfScene( g_currentFrame ) ); } return moveToFrame( g_currentFrame ); }

bool KinoCommon::newFile (  bool  prompt = true  )

Carries out a New File request in the kino application. All notebook pages are informed of the action through their own newFile method. Definition at line 297 of file kino_common.cc. References changePageRequest(), clean(), currentScene, fetchProjectMetadata(), g_currentFrame, GetEditorBackup(), GetFileMap(), Preferences::getInstance(), getPage(), getPageEditor(), getPageMagick(), getPlayList(), GetStoryboard(), modal_confirm(), modal_prompt(), Page::newFile(), PAGE_EDITOR, savePlayList(), setWindowTitle(), and windowMoved(). Referenced by exitKino(), loadFile(), and loadPlayList(). { bool result = true; cerr << ">> Kino Common newFile" << endl; this->getPageMagick()->Stop(); this->changePageRequest( PAGE_EDITOR ); if ( getPlayList() ->IsDirty() ) { switch ( modal_confirm( GTK_STOCK_SAVE, GTK_STOCK_CLOSE, _("Save changes to project \"%s\" before closing?"), getPlayList()->GetDocName() == "" ? _("Untitled") : getPlayList()->GetDocName().c_str() ) ) { case GTK_RESPONSE_ACCEPT: result = savePlayList( ); break; case GTK_RESPONSE_CLOSE: result = true; break; default: // Do nothing - action cancelled result = false; break; } } if ( result ) { // Specifics for this class vector <string> list; PlayList clean; getPlayList( ) ->GetLastCleanPlayList( clean ); GetFileMap() ->GetUnusedFxFiles( clean, list ); if ( list.begin() != list.end() ) { string buffer; buffer = _( "The following fx rendered files are no longer used: \n\n" ); vector < string >::iterator it; for ( it = list.begin(); it != list.end(); it ++ ) buffer += *it + "\n"; buffer += _( "\nDo you want me to delete them now?" ); switch ( modal_confirm( GTK_STOCK_DELETE, GTK_STOCK_CLOSE, buffer.c_str() ) ) { case GTK_RESPONSE_ACCEPT: for ( it = list.begin(); it != list.end(); it ++ ) unlink( ( *it ).c_str() ); result = true; break; case GTK_RESPONSE_CLOSE: // Do nothing - leave files on the system result = true; break; default: // Do nothing - action cancelled result = false; break; } } if ( result ) { getPlayList() ->CleanPlayList( ); GetFileMap() ->Clear(); this->g_currentFrame = -1; this->currentScene = -1; this->setWindowTitle( ); // Call new File for each page Page *page = NULL; for ( int index = 0; ( page = getPage( index ) ) != NULL; index ++ ) page->newFile(); GetStoryboard() ->reset(); GetStoryboard() ->redraw(); this->windowMoved(); GetEditorBackup() ->Clear(); getPageEditor() ->snapshot(); } } // Prompt for the Project Name/Id if applicable // added for tagesschau.de if ( prompt && strcmp( Preferences::getInstance().newProjectURI, "" ) ) { if ( strstr( Preferences::getInstance().newProjectURI, "%" ) ) { char *response = modal_prompt( _("Enter a project name") ); if ( response ) { getPlayList()->SetDocTitle( response ); fetchProjectMetadata( response ); free( response ); } } else { fetchProjectMetadata( "_" ); } } return result; }

void KinoCommon::packIt (  const char *  packerNameInner, const char *  packerNameOuter )

Set the video display to be fixed size or scalable. Parameters: packerNameInner  The name of the GTK AspectFrame widget to adjust. packerNameOuter  The name of the GTK AspectFrame widget to adjust. Definition at line 2264 of file kino_common.cc. References Preferences::getInstance(), getWidget(), and lookup_widget(). Referenced by setPreviewSize(), PageTrim::start(), PageEditor::start(), and PageCapture::start(). { GdkColor color; gdk_color_parse ( "black", &color ); GtkWidget *packer = lookup_widget( getWidget(), packerNameOuter ); gtk_widget_modify_bg ( packer, GTK_STATE_NORMAL, &color ); packer = lookup_widget( getWidget(), packerNameInner ); gtk_widget_modify_bg ( packer, GTK_STATE_NORMAL, &color ); GtkWidget *parent = gtk_widget_get_parent( packer ); gtk_box_set_child_packing( GTK_BOX( parent ), packer, TRUE /* expand */, Preferences::getInstance().displayFixed ? FALSE : TRUE /* fill */, 0 /* padding */, GTK_PACK_START ); }

gboolean KinoCommon::processCommand (  char *  cmd  )

Trigger a menu command action of the current page. These can be either keyboard or command line style strings. Definition at line 1764 of file kino_common.cc. References getCurrentPage(). { return getCurrentPage() ->processCommand( cmd ); }

gboolean KinoCommon::processKeyboard (  GdkEventKey *  event  )

Trigger the keyboard action of the current page. Definition at line 1755 of file kino_common.cc. References getCurrentPage(). { return getCurrentPage() ->processKeyboard( event ); }

void KinoCommon::publishFrame (   )

Definition at line 2378 of file kino_common.cc. References command, common, currentPage, g_currentFrame, getFileToSave(), getPlayList(), modal_message(), PAGE_CAPTURE, and saveFrame(). { if ( currentPage == PAGE_CAPTURE ) { modal_message( _("Sorry, you can not publish still frames from Capture.") ); } else { char * filename = common->getFileToSave( _( "Save Still Frame" ) ); if ( strcmp( filename, "" ) ) { std::ostringstream command; GError *gerror = NULL; common->saveFrame( common->g_currentFrame, filename ); command << "\"" << DATADIR << "/kino/scripts/publish/frame.sh\" "; command << "\"" << filename << "\" "; command << "\"" << getPlayList()->GetDocId().c_str() << "\" "; command << "\"" << getPlayList()->GetSeqAttribute( g_currentFrame, "title" ) << "\" "; command << "\"" << getPlayList()->GetDocTitle().c_str() << "\" "; char * args[ 4 ]; args[ 0 ] = "/bin/sh"; args[ 1 ] = "-c"; args[ 2 ] = const_cast< char* >( command.str().c_str() ); args[ 3 ] = NULL; g_spawn_async_with_pipes( ".", args, NULL, (GSpawnFlags)0, NULL, NULL, NULL, NULL, NULL, NULL, &gerror ); } } }

void KinoCommon::publishPlayList (   )

Definition at line 2338 of file kino_common.cc. References command, PlayList::GetDocId(), PlayList::GetDocName(), PlayList::GetDocTitle(), playlist, savePlayList(), and PlayList::SavePlayList(). { std::ostringstream command; GError *gerror = NULL; if ( playlist.GetDocName() == "" ) { PlayList* copy = new PlayList( playlist ); char filename[] = "/tmp/kino.XXXXXX"; mkstemp( filename ); copy->SavePlayList( filename ); delete copy; command << "\"" << DATADIR << "/kino/scripts/publish/project.sh\" "; command << "\"" << filename << "\" "; command << "\"" << playlist.GetDocId().c_str() << "\" "; command << "\"" << playlist.GetDocTitle().c_str() << "\" "; char * args[ 4 ]; args[ 0 ] = "/bin/sh"; args[ 1 ] = "-c"; args[ 2 ] = const_cast< char* >( command.str().c_str() ); args[ 3 ] = NULL; g_spawn_sync( ".", args, NULL, (GSpawnFlags)0, NULL, NULL, NULL, NULL, NULL, &gerror ); unlink( filename ); } else { savePlayList(); command << "\"" << DATADIR << "/kino/scripts/publish/project.sh\" "; command << "\"" << playlist.GetDocName() << "\" "; command << "\"" << playlist.GetDocId().c_str() << "\" "; command << "\"" << playlist.GetDocTitle().c_str() << "\" "; char * args[ 4 ]; args[ 0 ] = "/bin/sh"; args[ 1 ] = "-c"; args[ 2 ] = const_cast< char* >( command.str().c_str() ); args[ 3 ] = NULL; g_spawn_async_with_pipes( ".", args, NULL, (GSpawnFlags)0, NULL, NULL, NULL, NULL, NULL, NULL, &gerror ); } }

void KinoCommon::saveAVI (  char *   )  [protected]

void KinoCommon::saveFrame (  int  abs_frame_num, char *  file )

Save the specified frame to the specified file. Parameters: abs_frame_num  the frame to save file  the file to save it to Definition at line 1525 of file kino_common.cc. References FRAME_MAX_HEIGHT, FRAME_MAX_WIDTH, GetFramePool(), getPlayList(), AspectRatioCalculator::height, Frame::IsPAL(), modal_message(), pixels, and AspectRatioCalculator::width. { Frame *frame = GetFramePool()->GetFrame(); if ( frame != NULL ) { unsigned char pixels[ FRAME_MAX_WIDTH * FRAME_MAX_HEIGHT * 4 ]; GError *gerror = NULL; this->getPlayList()->GetFrame( this->g_currentFrame, *frame ); frame->ExtractPreviewRGB( pixels ); GdkPixbuf *im = gdk_pixbuf_new_from_data ( pixels, GDK_COLORSPACE_RGB, FALSE, 8, frame->GetWidth(), frame->GetHeight(), frame->GetWidth() * 3, NULL, NULL ); // resample pixel aspect { int width = frame->GetWidth(); if ( frame->IsWide() ) width = frame->IsPAL() ? 1024 : 854; AspectRatioCalculator calc( width, frame->GetHeight(), frame->GetWidth(), frame->GetHeight(), frame->IsPAL(), frame->IsWide() ); GdkPixbuf *scaled = gdk_pixbuf_scale_simple( im, calc.width, calc.height, GDK_INTERP_HYPER ); g_object_unref( im ); im = scaled; } const std::string FileName( file ); const std::string suffix( FileName.begin() + FileName.rfind( "." ), FileName.end() ); if ( suffix == ".png" ) gdk_pixbuf_save( im, file, "png", &gerror, static_cast<gchar*>( NULL ) ); else gdk_pixbuf_save( im, file, "jpeg", &gerror, "quality", "80", static_cast<gchar*>( NULL ) ); if ( gerror != NULL ) { modal_message( gerror->message ); g_error_free( gerror ); } g_object_unref( im ); GetFramePool()->DoneWithFrame( frame ); } }

void KinoCommon::saveFrame (   )

Save the current frame as a still frame. Definition at line 975 of file kino_common.cc. References common, currentPage, g_currentFrame, getFileToSave(), getPageCapture(), PAGE_CAPTURE, and saveFrame(). Referenced by publishFrame(), and saveFrame(). { if ( currentPage == PAGE_CAPTURE ) { getPageCapture()->saveFrame(); } else { char * filename = common->getFileToSave( _( "Save Still Frame" ) ); if ( filename && strcmp( filename, "" ) ) common->saveFrame( common->g_currentFrame, filename ); } }

bool KinoCommon::savePlayList (  char *  file  )  [protected]

Saves the playlist. Parameters: file  file to save Definition at line 1387 of file kino_common.cc. References getPlayList(), modal_message(), and setWindowTitle(). { bool result = false; result = getPlayList() ->SavePlayList( file ); if ( result ) setWindowTitle( ); else modal_message( _( "Could not save the SMIL" ) ); return result; }

bool KinoCommon::savePlayList (   )

Save the current play list to the file used to load the playlist originally. If no file was originally used then use savePlayListAs to obtain one. Definition at line 961 of file kino_common.cc. References getPlayList(), and savePlayListAs(). Referenced by newFile(), PageTrim::processCommand(), PageTimeline::processCommand(), PageMagick::processCommand(), PageExport::processCommand(), PageEditor::processCommand(), PageCapture::processCommand(), publishPlayList(), and savePlayListAs(). { bool result = true; if ( getPlayList() ->GetDocName() == "" ) result = savePlayListAs( ); else result = savePlayList( ( char * ) ( getPlayList() ->GetDocName().c_str() ) ); return result; }

bool KinoCommon::savePlayListAs (   )

Save the current play list with a different name to the original loaded (or previously saved as) play list file name. Definition at line 878 of file kino_common.cc. References g_currentFrame, getFileToSaveFormat(), GetFramePool(), getPlayList(), Frame::IsPAL(), modal_confirm(), modal_message(), playlist, savePlayList(), and PlayList::SetDocName(). Referenced by savePlayList(). { bool result = false; int format = 1; char *filename = this->getFileToSaveFormat( _( "Save the movie" ), format ); if ( filename && strcmp( filename, "" ) ) { // Append an extension if not supplied char* extension = strrchr( filename, '.' ); switch ( format ) { case 0: // SMIL case 1: // Legacy XML if ( !extension || ( strcmp( extension, ".kino" ) && strcmp( extension, ".smil" ) && strcmp( extension, ".xml" ) ) ) strcat( filename, ".kino" ); break; case 2: // ELI if ( !extension || strcmp( extension, ".eli" ) ) strcat( filename, ".eli" ); break; case 3: // SRT - SubRip subtitle if ( !extension || strcmp( extension, ".srt" ) ) strcat( filename, ".srt" ); break; } // See if it exists already and warn user FILE *f = fopen( filename, "r" ); if ( f ) { fclose( f ); if ( modal_confirm( GTK_STOCK_SAVE, NULL, _("The file \"%s\" already exists. Do you want to continue?\n"), filename ) != GTK_RESPONSE_ACCEPT ) return result; } switch ( format ) { case 0: // SMIL playlist.SetDocName( filename ); result = savePlayList( filename ); break; case 1: // Legacy XML if ( !this->getPlayList()->SavePlayList( filename, true ) ) { modal_message( _( "Could not save the XML" ) ); result = false; } break; case 2: // ELI if ( g_currentFrame != -1 ) { Frame& frame = *GetFramePool()->GetFrame(); this->getPlayList() ->GetFrame( g_currentFrame, frame ); if ( !this->getPlayList() ->SavePlayListEli( filename, frame.IsPAL() ) ) { modal_message( _( "Could not save the ELI" ) ); result = false; } GetFramePool()->DoneWithFrame( &frame ); } else { modal_message( _( "Could not save the ELI" ) ); result = false; } break; case 3: // SRT - SubRip subtitle if ( !this->getPlayList()->SavePlayListSrt( filename ) ) { modal_message( _( "Could not save the subtitle" ) ); result = false; } break; } } return result; }

void KinoCommon::selectScene (  int   )

Trigger the select scene action of the current page. Definition at line 1772 of file kino_common.cc. References getCurrentPage(). Referenced by tree_view_row_select(). { getCurrentPage() ->selectScene( scene ); }

void KinoCommon::setCurrentDirectoryFromFile (  char *   )  [protected]

void KinoCommon::setCurrentPage (  int  page  )

Carries out a change page - this should be triggered by changePageRequest to ensure that the GUI stays in sync with the common structure. Parameters: page  page to change to Definition at line 419 of file kino_common.cc. References clean(), currentPage, getWidget(), moveToFrame(), and start(). { if ( this->currentPage != page ) { if ( this->currentPage != -1 ) clean(); this->currentPage = page; start(); moveToFrame(); gtk_widget_queue_draw( getWidget() ); } }

void KinoCommon::setCurrentScene (  int  frame  )

Definition at line 2321 of file kino_common.cc. References currentScene, getPageEditor(), GetStoryboard(), and scenes. Referenced by PageTrim::insertScene(), PageTrim::loadScene(), PageTrim::selectScene(), PageTimeline::selectScene(), PageMagick::selectScene(), Export::selectScene(), PageEditor::showFrameInfo(), and PageMagick::StartRender(). { if ( frame > -1 ) { int pos = 0; vector <int> scenes = getPageEditor() ->GetScene(); for ( pos = 0; pos < ( int ) scenes.size() && frame >= scenes[ pos ]; pos++ ) ; if ( pos != currentScene && pos > -1 ) { currentScene = pos; GetStoryboard() ->select( currentScene ); } } }

void KinoCommon::setFileEditted (  char *   )  [protected]

void KinoCommon::setLastDirectory (  const string &  value  )  [inline]

Definition at line 301 of file kino_common.h. References last_directory. Referenced by loadPlayList(). { last_directory = value; }

void KinoCommon::setMoreInfo (  bool  state  )  [inline]

Definition at line 281 of file kino_common.h. References showMoreInfo. { showMoreInfo = state; }

void KinoCommon::setPreviewSize (  float  factor, bool  noWarning = false )

Resize the video preview area to a percentage of source image size. Parameters: factor  The scaling factor from 0 to 1. If zero, then auto-size. If negative, then cycle to the next preset factor. noWarning  A boolean to indicate whether to suppress the warning dialog when Kino is unable to determine video size. Definition at line 2106 of file kino_common.cc. References ASPECT_169, currentPage, GetFramePool(), Preferences::getInstance(), getPageCapture(), getPlayList(), getWidget(), AspectRatioCalculator::height, Frame::IsPAL(), lookup_widget(), modal_message(), NORM_PAL, NORM_UNSPECIFIED, packIt(), PAGE_CAPTURE, widget, and AspectRatioCalculator::width. { static bool skip = false; int width = 720; int height = -1; bool isWide; bool isPAL; if ( skip ) return; // handle the cycle case if ( factor < 0 ) { factor = float( Preferences::getInstance().previewSize ) / 10.0; factor += 0.5; if ( factor > 1.0 ) factor = 0.0; } // save the new size Preferences::getInstance().previewSize = int( factor * 10 ); // handle fixed size factors if ( Preferences::getInstance().displayFixed != ( factor > 0 ) ) { Preferences::getInstance().displayFixed = ( factor > 0 ); packIt( "packer_edit", "packer_edit_outer" ); packIt( "packer_capture", "packer_capture_outer" ); packIt( "packer_trim", "packer_trim_outer" ); } skip = true; // set the menu radio item if ( factor == 0 ) gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( lookup_widget( widget, "menuitem_zoom_fit" ) ), TRUE ); else if ( factor == 0.5 ) gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( lookup_widget( widget, "menuitem_zoom_50percent" ) ), TRUE ); else gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( lookup_widget( widget, "menuitem_zoom_100percent" ) ), TRUE ); skip = false; // this sets a sane factor for zoom to fit if ( factor == 0 ) factor = 0.5; if ( currentPage == PAGE_CAPTURE ) { Frame *frame = getPageCapture()->getFrame(); if ( frame != NULL ) { width = frame->GetWidth(); if ( frame->IsWide() ) width = frame->IsPAL() ? 1024 : 854; AspectRatioCalculator calc( width, frame->GetHeight(), frame->GetWidth(), frame->GetHeight(), frame->IsPAL(), frame->IsWide() ); width = ( int ) ( calc.width * factor ); height = ( int ) ( calc.height * factor ); } } else if ( this->g_currentFrame != -1 ) { Frame& frame = *GetFramePool()->GetFrame(); this->getPlayList() ->GetFrame( this->g_currentFrame, frame ); width = frame.GetWidth(); if ( frame.IsWide() ) width = frame.IsPAL() ? 1024 : 854; AspectRatioCalculator calc( width, frame.GetHeight(), frame.GetWidth(), frame.GetHeight(), frame.IsPAL(), frame.IsWide() ); GetFramePool()->DoneWithFrame( &frame ); width = ( int ) ( calc.width * factor ); height = ( int ) ( calc.height * factor ); } else if ( Preferences::getInstance().defaultNormalisation != NORM_UNSPECIFIED ) { height = Preferences::getInstance().defaultNormalisation == NORM_PAL ? 576 : 480; isPAL = Preferences::getInstance().defaultNormalisation == NORM_PAL; isWide = Preferences::getInstance().defaultAspect == ASPECT_169; AspectRatioCalculator calc( width, height, width, height, isPAL, isWide ); width = ( int ) ( calc.width * factor ); height = ( int ) ( calc.height * factor ); } if ( height == -1 && ! noWarning ) { modal_message( _( "The project is empty and the default preferences for video creation have not been specified." ) ); } else if ( height != -1 ) { cerr << "> setting video preview size to " << width << "x" << height << endl; GtkWidget *frameArea = lookup_widget( getWidget(), "packer_edit" ); gtk_widget_set_size_request( frameArea, width + 4, height + 4 ); frameArea = lookup_widget( getWidget(), "packer_capture" ); gtk_widget_set_size_request( frameArea, width + 4, height + 4 ); frameArea = lookup_widget( getWidget(), "packer_trim" ); gtk_widget_set_size_request( frameArea, width + 4, height + 4 ); } }

void KinoCommon::setStatusBar (  const char *  ,   ... )

Helper function for the pages. Definition at line 2284 of file kino_common.cc. References statusbar. Referenced by PageCapture::applyAVCState(), Export::calculateAdjustedRate(), captureThread(), PageCapture::clean(), Export1394::doExport(), Export::innerLoopUpdate(), keyboardFeedback(), PageTrim::processCommand(), PageEditor::processCommand(), PageTrim::processKeyboard(), PageEditor::processKeyboard(), ExportMJPEG::start(), Export1394::start(), PageCapture::startCapture(), Export::startExport(), PageMagick::StartRender(), PageCapture::stopCapture(), PageMagick::UpdateStatus(), and videoThread(). { va_list list; va_start( list, msg ); static char prevMsg[ 1024 ] = ""; if ( strcmp( msg, "" ) == 0 ) gtk_statusbar_pop( statusbar, 1 ); else if ( strncmp( prevMsg, msg, 1023 ) != 0 ) { if ( vsnprintf( prevMsg, 1023, msg, list ) != 0 ) { gtk_statusbar_pop( statusbar, 1 ); gtk_statusbar_push( statusbar, 1, prevMsg ); } } }

void KinoCommon::setTimeFormat (  SMIL::Time::TimeFormat  format  )

Definition at line 2308 of file kino_common.cc. References common, g_currentFrame, getCurrentPage(), Preferences::getInstance(), GetStoryboard(), and moveToFrame(). Referenced by KinoCommon(). { Preferences::getInstance().timeFormat = static_cast< int >( format ); if ( g_currentFrame != -1 ) { common->moveToFrame(); GetStoryboard() ->reset(); GetStoryboard() ->redraw(); getCurrentPage() ->timeFormatChanged(); } }

void KinoCommon::setWindowTitle (   )

Sets the document name in the window title. Definition at line 1297 of file kino_common.cc. References Preferences::getInstance(), getPlayList(), lookup_widget(), and updateRecentFiles(). Referenced by appendFile(), bulkLoad(), PageEditor::DeleteFrames(), insertFile(), PageTrim::insertScene(), loadFile(), loadPlayList(), newFile(), PageEditor::PasteFrames(), PageEditor::processCommand(), savePlayList(), PageTrim::saveScene(), PageEditor::snapshot(), and PageCapture::stopCapture(). { GtkWidget * mainWindow = lookup_widget( this->getWidget(), "main_window" ); if ( mainWindow ) { char strbuf[ 1024 ]; if ( getPlayList() ->GetDocName( ) == "" ) strcpy( strbuf, _( "Untitled" ) ); else strcpy( strbuf, getPlayList() ->GetDocName( ).c_str() ); if ( getPlayList( ) ->IsDirty( ) ) strcat( strbuf, _(" (modified) ") ); strcat( strbuf, " - Kino" ); gtk_window_set_title( GTK_WINDOW( mainWindow ), strbuf ); } if ( getPlayList()->GetDocName( ) != "" && !getPlayList()->IsDirty() ) { Preferences::getInstance().addRecentFile( getPlayList()->GetDocName() ); updateRecentFiles(); } }

void KinoCommon::showFrameInfo (  int  i  )

Relay the current frame info to the GUI. Parameters: i  current frame Definition at line 1663 of file kino_common.cc. References getCurrentPage(). Referenced by PageTrim::showFrame(), and PageEditor::showFrame(). { getCurrentPage() ->showFrameInfo( i ); }

void KinoCommon::showFrameMoreInfo (  Frame &  frame, FileHandler *  media )

Display detailed information about this frame and its file. Parameters: i  current frame Definition at line 1674 of file kino_common.cc. References AVI_DV1_FORMAT, FileHandler::GetExtension(), FileHandler::GetFilename(), AVIHandler::GetFormat(), AVIHandler::GetOpenDML(), lookup_widget(), showMoreInfo, and widget. Referenced by PageTimeline::selectScene(), PageMagick::selectScene(), Export::selectScene(), PageTrim::showFrameInfo(), PageMagick::showFrameInfo(), and PageEditor::showFrameInfo(). { if ( showMoreInfo ) { GtkLabel *label = GTK_LABEL( lookup_widget( widget, "label_properties" ) ); char* s = new char[ 2048 ]; if ( media != NULL ) { TimeCode tc; AudioInfo ainfo; string format; frame.GetTimeCode( tc ); frame.GetAudioInfo( ainfo ); string ext = media->GetExtension(); if ( ext == ".dv" || ext == ".dif" ) format = "Raw DV"; else if ( ext == ".avi" ) { AVIHandler * avi = dynamic_cast< AVIHandler* >( media ); format = ( avi->GetFormat() == AVI_DV1_FORMAT ) ? "AVI, Type 1" : "AVI, Type 2"; if ( avi->GetOpenDML() ) format += ", OpenDML"; } else if ( ext == ".mov" ) format = "Quicktime"; else format = "unknown"; snprintf( s, 2048, _( "%s\n%s\n%2.2d:%2.2d:%2.2d:%2.2d\n%s\n%d bit, %d KHz, %d samples\n%d x %d, %s, %s, %2.2f fps" ), basename( media->GetFilename().c_str() ), frame.GetRecordingDate().c_str(), tc.hour, tc.min, tc.sec, tc.frame, format.c_str(), ainfo.quantization, ainfo.frequency / 1000, ainfo.samples, frame.GetWidth(), frame.GetHeight(), frame.IsPAL() ? "PAL" : "NTSC", frame.IsWide() ? "16:9" : "4:3", frame.GetFrameRate() ); } else sprintf( s, "\n\n\n" ); gtk_label_set_text( label, s ); delete[] s; } }

void KinoCommon::start (   )  [protected]

Trigger the start action of the current page. This method is also responsible for determining the state of the main page buttons and widgets. Definition at line 1730 of file kino_common.cc. References activateWidgets(), commitComponentState(), currentPage, getComponentState(), getCurrentPage(), getWidget(), lookup_widget(), PAGE_MAGICK, toggleComponents(), and VIDEO_STOP. Referenced by setCurrentPage(). { gtk_label_set_text( GTK_LABEL( lookup_widget( getWidget(), "position_label_current" ) ), "" ); gtk_label_set_text( GTK_LABEL( lookup_widget( getWidget(), "position_label_total" ) ), "" ); getCurrentPage() ->start(); activateWidgets(); toggleComponents( getComponentState(), false ); if ( currentPage != PAGE_MAGICK ) toggleComponents( VIDEO_STOP, true ); commitComponentState(); }

void KinoCommon::toggleComponents (  component_enum  pattern, bool  state )

Set the state of toggle buttons. The state of the buttons are retained in memory, and this method will set a flag that the state has changed (dirty), but has not yet been committed. The button commands will not respond while the state is dirty. Use commitComponentState() to commit the changes and let the buttons issue their commands once again. Parameters: pattern  A set of component_enums to toggle state  If true then lower the button, else raise the button Definition at line 2038 of file kino_common.cc. References component_state, is_component_state_changing, lookup_widget(), VIDEO_BACK, video_back_button, video_end_movie_button, VIDEO_END_OF_MOVIE, video_end_scene_button, VIDEO_FAST_FORWARD, video_fast_forward_button, VIDEO_FORWARD, video_forward_button, VIDEO_NEXT_SCENE, VIDEO_PLAY, video_play_button, VIDEO_REWIND, video_rewind_button, video_start_movie_button, VIDEO_START_OF_MOVIE, VIDEO_START_OF_SCENE, video_start_scene_button, VIDEO_STOP, video_stop_button, and widget. Referenced by PageCapture::applyAVCState(), PageCapture::start(), start(), PageMagick::StartRender(), PageTrim::videoBack(), PageMagick::videoBack(), PageEditor::videoBack(), PageCapture::videoBack(), PageTrim::videoEndOfMovie(), PageMagick::videoEndOfMovie(), PageEditor::videoEndOfMovie(), PageCapture::videoEndOfMovie(), PageTrim::videoEndOfScene(), PageEditor::videoEndOfScene(), PageCapture::videoEndOfScene(), PageTrim::videoFastForward(), PageEditor::videoFastForward(), PageCapture::videoFastForward(), PageTrim::videoForward(), PageMagick::videoForward(), PageEditor::videoForward(), PageCapture::videoForward(), PageTrim::videoNextScene(), PageMagick::videoNextScene(), PageEditor::videoNextScene(), PageCapture::videoNextScene(), PageTrim::videoPause(), PageTrim::videoPlay(), PageMagick::videoPlay(), PageEditor::videoPlay(), PageCapture::videoPlay(), PageTrim::videoPreviousScene(), PageMagick::videoPreviousScene(), PageEditor::videoPreviousScene(), PageCapture::videoPreviousScene(), PageTrim::videoRewind(), PageEditor::videoRewind(), PageCapture::videoRewind(), PageTrim::videoShuttle(), PageEditor::videoShuttle(), videoShuttle(), PageTrim::videoStartOfMovie(), PageMagick::videoStartOfMovie(), PageEditor::videoStartOfMovie(), PageCapture::videoStartOfMovie(), PageTrim::videoStartOfScene(), PageEditor::videoStartOfScene(), PageCapture::videoStartOfScene(), PageTrim::videoStop(), PageMagick::videoStop(), PageEditor::videoStop(), and PageCapture::videoStop(). { this->is_component_state_changing = true; if ( state ) this->component_state |= pattern; else this->component_state ^= pattern; if ( pattern & VIDEO_START_OF_MOVIE ) gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( video_start_movie_button ), state ); if ( pattern & VIDEO_START_OF_SCENE ) gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( video_start_scene_button ), state ); if ( pattern & VIDEO_REWIND ) gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( video_rewind_button ), state ); if ( pattern & VIDEO_BACK ) gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( video_back_button ), state ); if ( pattern & VIDEO_PLAY ) { gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( video_play_button ), state ); if ( state ) gtk_image_set_from_file( GTK_IMAGE( lookup_widget( widget, "pixmap_play_pause" ) ), DATADIR "/kino/stock_media-pause-16.png" ); else gtk_image_set_from_file( GTK_IMAGE( lookup_widget( widget, "pixmap_play_pause" ) ), DATADIR "/kino/stock_media-play-16.png" ); } if ( pattern & VIDEO_STOP ) gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( video_stop_button ), state ); if ( pattern & VIDEO_FORWARD ) gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( video_forward_button ), state ); if ( pattern & VIDEO_FAST_FORWARD ) gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( video_fast_forward_button ), state ); if ( pattern & VIDEO_NEXT_SCENE ) gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( video_end_scene_button ), state ); if ( pattern & VIDEO_END_OF_MOVIE ) gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( video_end_movie_button ), state ); }

void KinoCommon::updateRecentFiles (   )

Definition at line 2439 of file kino_common.cc. References count, Preferences::getInstance(), lookup_widget(), on_open_recent_activate(), recentMenuItems, StringUtils::replaceAll(), and widget. Referenced by setWindowTitle(). { GtkWidget* menu = lookup_widget( widget, "file_menu" ); vector< std::string >& recentFiles = Preferences::getInstance().recentFiles; int count = recentFiles.size(); const int menuPosition = Preferences::getInstance().enablePublish ? 12 : 10; if ( recentMenuItems.empty() && !recentFiles.empty() ) { GtkWidget* widget = gtk_separator_menu_item_new(); gtk_menu_shell_insert( GTK_MENU_SHELL( menu ), widget, menuPosition ); gtk_widget_show( widget ); } for ( vector< GtkWidget* >::iterator i = recentMenuItems.begin(); i != recentMenuItems.end(); i++ ) { gtk_container_remove( GTK_CONTAINER( menu ), *i ); gtk_widget_destroy( *i ); } recentMenuItems.clear(); for ( vector< std::string >::iterator i = recentFiles.begin(); i != recentFiles.end(); i++, count-- ) { std::ostringstream ss; ss << "_" << count << ". " << StringUtils::replaceAll( basename( ( *i ).c_str() ), "_", "__" ) << std::ends; GtkWidget* widget = gtk_menu_item_new_with_mnemonic( ss.str().c_str() ); g_signal_connect( G_OBJECT( widget ), "activate", G_CALLBACK( on_open_recent_activate ), gpointer( (*i).c_str() ) ); gtk_menu_shell_insert( GTK_MENU_SHELL( menu ), widget, menuPosition ); gtk_widget_show( widget ); recentMenuItems.push_back( widget ); } }

void KinoCommon::videoBack (  int  step = -1  )

Trigger the back action of the current page. Definition at line 1836 of file kino_common.cc. References commitComponentState(), getCurrentPage(), and is_component_state_changing. Referenced by PageCapture::processCommand(). { if ( ! is_component_state_changing ) { getCurrentPage() ->videoBack(step); commitComponentState(); } }

void KinoCommon::videoEndOfMovie (   )

Trigger the end movie action of the current page. Definition at line 1920 of file kino_common.cc. References commitComponentState(), getCurrentPage(), and is_component_state_changing. Referenced by PageTrim::processCommand(), PageMagick::processCommand(), PageEditor::processCommand(), and PageCapture::processCommand(). { if ( ! is_component_state_changing ) { getCurrentPage() ->videoEndOfMovie(); commitComponentState(); } }

void KinoCommon::videoEndOfScene (   )

Trigger the end of scene action of the current page. Definition at line 1906 of file kino_common.cc. References commitComponentState(), getCurrentPage(), and is_component_state_changing. Referenced by PageTrim::processCommand(), PageMagick::processCommand(), PageEditor::processCommand(), and PageCapture::processCommand(). { if ( ! is_component_state_changing ) { getCurrentPage() ->videoEndOfScene(); commitComponentState(); } }

void KinoCommon::videoFastForward (   )

Trigger the fast forward action of the current page. Definition at line 1878 of file kino_common.cc. References commitComponentState(), getCurrentPage(), and is_component_state_changing. Referenced by PageCapture::processCommand(). { if ( ! is_component_state_changing ) { getCurrentPage() ->videoFastForward(); commitComponentState(); } }

void KinoCommon::videoForward (  int  step = 1  )

Trigger the forward action of the current page. Definition at line 1864 of file kino_common.cc. References commitComponentState(), getCurrentPage(), and is_component_state_changing. Referenced by PageCapture::processCommand(). { if ( ! is_component_state_changing ) { getCurrentPage() ->videoForward(step); commitComponentState(); } }

void KinoCommon::videoNextScene (   )

Trigger the next scene action of the current page. Definition at line 1892 of file kino_common.cc. References commitComponentState(), getCurrentPage(), and is_component_state_changing. Referenced by PageMagick::processCommand(), PageEditor::processCommand(), and PageCapture::processCommand(). { if ( ! is_component_state_changing ) { getCurrentPage() ->videoNextScene(); commitComponentState(); } }

void KinoCommon::videoPause (   )

Trigger the pause action of the current page. Definition at line 1934 of file kino_common.cc. References commitComponentState(), getCurrentPage(), and is_component_state_changing. Referenced by PageTrim::processCommand(), PageMagick::processCommand(), PageEditor::processCommand(), and PageCapture::processCommand(). { if ( ! is_component_state_changing ) { getCurrentPage() ->videoPause(); commitComponentState(); } }

void KinoCommon::videoPlay (   )

Trigger the play action of the current page. Definition at line 1850 of file kino_common.cc. References commitComponentState(), getCurrentPage(), and is_component_state_changing. Referenced by PageTrim::processCommand(), PageMagick::processCommand(), PageEditor::processCommand(), and PageCapture::processCommand(). { if ( ! is_component_state_changing ) { getCurrentPage() ->videoPlay(); commitComponentState(); } }

void KinoCommon::videoPreviousScene (   )

Trigger the previous scene action of the current page. Definition at line 1794 of file kino_common.cc. References commitComponentState(), getCurrentPage(), and is_component_state_changing. Referenced by PageMagick::processCommand(), PageEditor::processCommand(), and PageCapture::processCommand(). { if ( ! is_component_state_changing ) { getCurrentPage() ->videoPreviousScene(); commitComponentState(); } }

void KinoCommon::videoRewind (   )

Trigger the rewind action of the current page. Definition at line 1822 of file kino_common.cc. References commitComponentState(), getCurrentPage(), and is_component_state_changing. Referenced by PageCapture::processCommand(). { if ( ! is_component_state_changing ) { getCurrentPage() ->videoRewind(); commitComponentState(); } }

void KinoCommon::videoShuttle (  int  angle  )

Bi-directional variable-speed playback. Parameters: angle  A number from -15 (fastest reverse) to 15 (fastest forward) Definition at line 1964 of file kino_common.cc. References commitComponentState(), getComponentState(), getCurrentPage(), Preferences::getInstance(), is_component_state_changing, and toggleComponents(). { if ( ! is_component_state_changing ) { toggleComponents( getComponentState(), false ); if ( ! Preferences::getInstance().dropFrame ) // this has bad thread interaction with dropFrame playback gtk_range_set_value( this->video_shuttle, angle ); getCurrentPage() ->videoShuttle( angle ); commitComponentState(); } }

void KinoCommon::videoStartOfMovie (   )

Trigger the start of movie action of the current page. Definition at line 1780 of file kino_common.cc. References commitComponentState(), getCurrentPage(), and is_component_state_changing. Referenced by PageTrim::processCommand(), PageMagick::processCommand(), PageEditor::processCommand(), and PageCapture::processCommand(). { if ( ! is_component_state_changing ) { getCurrentPage() ->videoStartOfMovie(); commitComponentState(); } }

void KinoCommon::videoStartOfScene (   )

Trigger the start of scene action of the current page. Definition at line 1808 of file kino_common.cc. References commitComponentState(), getCurrentPage(), and is_component_state_changing. Referenced by PageTrim::processCommand(), PageMagick::processCommand(), PageEditor::processCommand(), and PageCapture::processCommand(). { if ( ! is_component_state_changing ) { getCurrentPage() ->videoStartOfScene(); commitComponentState(); } }

void KinoCommon::videoStop (   )

Trigger the stop action of the current page. Definition at line 1948 of file kino_common.cc. References commitComponentState(), getCurrentPage(), and is_component_state_changing. Referenced by PageTrim::processCommand(), PageMagick::processCommand(), PageEditor::processCommand(), PageCapture::processCommand(), PageMagick::processKeyboard(), PageEditor::processKeyboard(), PageCapture::processKeyboard(), and PageEditor::showFrame(). { if ( ! is_component_state_changing ) { getCurrentPage() ->videoStop(); commitComponentState(); } }

void KinoCommon::visibilityChanged (  gboolean   )

Definition at line 1984 of file kino_common.cc. References getCurrentPage(). { getCurrentPage() ->visibilityChanged( visible ); }

void KinoCommon::windowMoved (   )

Definition at line 1979 of file kino_common.cc. References getCurrentPage(). Referenced by newFile(). { getCurrentPage() ->windowMoved(); }

---

Member Data Documentation

PageBttv* KinoCommon::bttv [private]

Definition at line 142 of file kino_common.h. Referenced by getPageBttv(), KinoCommon(), and ~KinoCommon().

PageCapture* KinoCommon::capture [private]

Definition at line 140 of file kino_common.h. Referenced by getPageCapture(), KinoCommon(), and ~KinoCommon().

GtkEntry* KinoCommon::command [private]

Definition at line 118 of file kino_common.h. Referenced by importFile(), publishFrame(), and publishPlayList().

gulong KinoCommon::component_state [private]

Definition at line 154 of file kino_common.h. Referenced by commitComponentState(), getComponentState(), KinoCommon(), and toggleComponents().

int KinoCommon::currentPage [private]

Definition at line 136 of file kino_common.h. Referenced by bulkLoad(), KinoCommon(), moveByFrames(), moveToFrame(), publishFrame(), saveFrame(), setCurrentPage(), setPreviewSize(), and start().

int KinoCommon::currentScene [private]

Definition at line 158 of file kino_common.h. Referenced by getCurrentScene(), KinoCommon(), loadFile(), loadPlayList(), newFile(), and setCurrentScene().

GtkWidget* KinoCommon::edit_menu [private]

Definition at line 115 of file kino_common.h. Referenced by KinoCommon().

PageEditor* KinoCommon::editor [private]

Definition at line 139 of file kino_common.h. Referenced by getPageEditor(), KinoCommon(), and ~KinoCommon().

PageExport* KinoCommon::exportPage [private]

Definition at line 143 of file kino_common.h. Referenced by getPageExport(), KinoCommon(), and ~KinoCommon().

int KinoCommon::g_currentFrame

Definition at line 223 of file kino_common.h. Referenced by _getOneSecond(), appendFile(), audioThread(), bulkLoad(), PageCapture::collectFiles(), getOneSecond(), importFile(), PageMagickCreate::Initialise(), insertFile(), PageTrim::insertScene(), KinoCommon(), loadFile(), loadPlayList(), moveByFrames(), PageEditor::movedToFrame(), moveToFrame(), newFile(), PageTrim::processCommand(), PageTimeline::processCommand(), PageEditor::processCommand(), PageCapture::processCommand(), publishFrame(), readThread(), saveFrame(), savePlayListAs(), PageTrim::saveScene(), PageTrim::selectScene(), PageTimeline::selectScene(), PageMagick::selectScene(), setTimeFormat(), PageTrim::showFrame(), PageEditor::showFrame(), PageMagick::showFrameInfo(), PageEditor::showFrameInfo(), PageTrim::start(), PageTimeline::start(), PageMagick::start(), PageEditor::start(), Export::startExport(), PageCapture::stopCapture(), PageEditor::videoEndOfScene(), PageEditor::videoNextScene(), PageEditor::videoPreviousScene(), PageEditor::videoStartOfScene(), videoThread(), and PageEditor::windowMoved().

gboolean KinoCommon::hasListChanged

Definition at line 224 of file kino_common.h. Referenced by appendFile(), bulkLoad(), PageCapture::collectFiles(), PageEditor::DeleteFrames(), PageEditor::DrawBar(), insertFile(), PageTrim::insertScene(), KinoCommon(), loadFile(), loadPlayList(), PageTrim::movedToFrame(), PageMagick::movedToFrame(), PageEditor::PasteFrames(), PageTrim::processCommand(), PageEditor::processCommand(), PageTrim::saveScene(), and PageCapture::stopCapture().

bool KinoCommon::is_component_state_changing [private]

Definition at line 155 of file kino_common.h. Referenced by commitComponentState(), KinoCommon(), toggleComponents(), videoBack(), videoEndOfMovie(), videoEndOfScene(), videoFastForward(), videoForward(), videoNextScene(), videoPause(), videoPlay(), videoPreviousScene(), videoRewind(), videoShuttle(), videoStartOfMovie(), videoStartOfScene(), and videoStop().

string KinoCommon::last_directory [private]

Definition at line 156 of file kino_common.h. Referenced by getFileToOpen(), getFileToSaveFormat(), getLastDirectory(), and setLastDirectory().

PageMagick* KinoCommon::magickPage [private]

Definition at line 145 of file kino_common.h. Referenced by getPageMagick(), KinoCommon(), and ~KinoCommon().

GtkNotebook* KinoCommon::notebook [private]

Definition at line 117 of file kino_common.h. Referenced by changePageRequest(), and KinoCommon().

PlayList KinoCommon::playlist [private]

Definition at line 133 of file kino_common.h. Referenced by getLastDirectory(), getPlayList(), moveToFrame(), publishPlayList(), and savePlayListAs().

char KinoCommon::playlistFileName[PATH_MAX+NAME_MAX] [private]

Definition at line 150 of file kino_common.h.

std::vector< GtkWidget* > KinoCommon::recentMenuItems [private]

Definition at line 160 of file kino_common.h. Referenced by updateRecentFiles().

bool KinoCommon::showMoreInfo [private]

Definition at line 157 of file kino_common.h. Referenced by setMoreInfo(), and showFrameMoreInfo().

GtkStatusbar* KinoCommon::statusbar [private]

Definition at line 130 of file kino_common.h. Referenced by KinoCommon(), and setStatusBar().

char KinoCommon::tempFileName[PATH_MAX+NAME_MAX] [private]

Definition at line 149 of file kino_common.h. Referenced by getFileToOpen(), and getFileToSaveFormat().

SMIL::MediaClippingTime KinoCommon::time [private]

Definition at line 159 of file kino_common.h. Referenced by getTime().

PageTimeline* KinoCommon::timeline [private]

Definition at line 141 of file kino_common.h. Referenced by getPageTimeline(), KinoCommon(), and ~KinoCommon().

PageTrim* KinoCommon::trimPage [private]

Definition at line 144 of file kino_common.h. Referenced by getPageTrim(), KinoCommon(), and ~KinoCommon().

PageUndefined* KinoCommon::undefined [private]

Definition at line 146 of file kino_common.h. Referenced by getPageUndefined(), KinoCommon(), and ~KinoCommon().

GtkButton* KinoCommon::video_back_button [private]

Definition at line 122 of file kino_common.h. Referenced by activateWidgets(), KinoCommon(), and toggleComponents().

GtkButton* KinoCommon::video_end_movie_button [private]

Definition at line 128 of file kino_common.h. Referenced by activateWidgets(), KinoCommon(), and toggleComponents().

GtkButton* KinoCommon::video_end_scene_button [private]

Definition at line 127 of file kino_common.h. Referenced by activateWidgets(), KinoCommon(), and toggleComponents().

GtkButton* KinoCommon::video_fast_forward_button [private]

Definition at line 126 of file kino_common.h. Referenced by activateWidgets(), KinoCommon(), and toggleComponents().

GtkButton* KinoCommon::video_forward_button [private]

Definition at line 125 of file kino_common.h. Referenced by activateWidgets(), KinoCommon(), and toggleComponents().

GtkButton* KinoCommon::video_play_button [private]

Definition at line 123 of file kino_common.h. Referenced by activateWidgets(), KinoCommon(), and toggleComponents().

GtkButton* KinoCommon::video_rewind_button [private]

Definition at line 121 of file kino_common.h. Referenced by activateWidgets(), KinoCommon(), and toggleComponents().

GtkRange* KinoCommon::video_shuttle [private]

Definition at line 129 of file kino_common.h. Referenced by activateWidgets(), and KinoCommon().

GtkButton* KinoCommon::video_start_movie_button [private]

Definition at line 119 of file kino_common.h. Referenced by activateWidgets(), KinoCommon(), and toggleComponents().

GtkButton* KinoCommon::video_start_scene_button [private]

Definition at line 120 of file kino_common.h. Referenced by activateWidgets(), KinoCommon(), and toggleComponents().

GtkButton* KinoCommon::video_stop_button [private]

Definition at line 124 of file kino_common.h. Referenced by activateWidgets(), KinoCommon(), and toggleComponents().

GtkWidget* KinoCommon::view_menu [private]

Definition at line 116 of file kino_common.h. Referenced by KinoCommon().

GtkWidget* KinoCommon::widget [private]

Definition at line 114 of file kino_common.h. Referenced by activateWidgets(), bulkLoad(), clearPreview(), getWidget(), importFile(), setPreviewSize(), showFrameMoreInfo(), toggleComponents(), and updateRecentFiles().

---

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

• kino_common.h
• kino_common.cc

---