Merge lp:~nico-inattendu/luciole/bug_727175 into lp:luciole

[NicoInattendu]

fix for bug bug #727175

Correction for bug #727175.

Timeline mode change by default

Inhibit Acquisition mode ?

=== modified file 'luciole/ctrl/base.py'
--- luciole/ctrl/base.py	2010-12-15 05:23:57 +0000
+++ luciole/ctrl/base.py	2011-03-05 15:01:33 +0000
@@ -30,10 +30,20 @@
 from pitivi.signalinterface import Signallable
 from pitivi.log.loggable import Loggable
 # local application/library specific imports
+from luciole.base.exceptions import LucioException
+
+
+
+class ProjectModeError(LucioException) :
+    """ ProjectMode Error class"""
+    
+    def __init__(self, *params):
+        LucioException.__init__(self, *params)
+
 
 
 class ProjectMode(Signallable, Loggable) :
-    """ Base class """
+    """ Base/abstact for project modes class """
     __signals__ = {}
     
     def __init__(self, ctrl_project,  mode_type = None) :
@@ -78,7 +88,8 @@
     def active_viewer(self) :
         """ Meta function.
             active displays associted to mode """
-        pass
+        self.debug('active viewer')
+    
     
     def prepare(self, project) :
         """ Meta function.
@@ -97,7 +108,6 @@
         release """
         self.debug('Release')
         self._viewer.setPipeline(None)
-        pass
         
 
         

=== modified file 'luciole/ctrl/ctrl_acq.py'
--- luciole/ctrl/ctrl_acq.py	2011-02-27 18:32:53 +0000
+++ luciole/ctrl/ctrl_acq.py	2011-03-05 15:01:33 +0000
@@ -31,8 +31,6 @@
 
 # related third party imports
 import gst
-from pitivi.signalinterface import Signallable
-from pitivi.log.loggable import Loggable
 from pitivi.signalgroup import SignalGroup
 from pitivi.action import ViewAction
 from pitivi.pipeline import Pipeline
@@ -47,6 +45,10 @@
 from luciole.ctrl.base import ProjectMode
 
 class ProjectModeAcquisition(ProjectMode) :
+    """ 
+    class in charge of Acquisition.
+    High level class 
+    """
     MODES = (   "INVALID",
                 "NO_ACQUISITION",
                 "ACQUISITION",
@@ -63,10 +65,13 @@
                 }
 
     def __init__(self, ctrl_project) :
-        self._mode ="INVALID"
+        self._mode = "INVALID"
         ProjectMode.__init__(self, ctrl_project, "ACQUISITION") 
         self.gui_signals = SignalGroup()
     
+        self._source_factory = None
+        self._view_action = None
+    
     def prepare(self, project) :
         """ prepare acquistion """
         ProjectMode.prepare(self, project)
@@ -83,7 +88,8 @@
                         WebcamSourceFactory(capture_path = _capture_path,
                                             with_mixer = False)
 
-                self.debug(' webcam filter : %s',self.project.props['webcam_data']) 
+                self.debug('webcam filter : %s', 
+                        self.project.props['webcam_data']) 
                 self._set_webcam_params(
                         self.project.props['webcam_data'],
                         self._source_factory)
@@ -102,12 +108,15 @@
                 self._view_action.addProducers(self._source_factory)
                 
                 self._mode = "NO_ACQUISITION"
-                self.debug('emit acquirer-ready, Webcam factory : %s, pipeline : %s',
-                        self._source_factory, self._pipeline )
+                self.debug(
+                    'emit acquirer-ready, Webcam factory : %s, pipeline : %s',
+                    self._source_factory, self._pipeline )
                 self.emit('acquirer-ready')
 
 
     def release(self) :
+        """ release ctrl_acq used objects 
+        """
         ProjectMode.release(self)
         self.debug('releasing acquisition')
         self._disconnect_from_factory(self._source_factory)
@@ -118,6 +127,7 @@
         self._view_action = None
 
     def active_viewer(self) :
+        """ set gui viewer with acquisition view """
         if self._viewer :
             self._viewer.setPipeline(None)
             self._viewer.hideSlider()
@@ -140,21 +150,25 @@
 
         if self._mode == "NO_ACQUISITION" :
             if with_mixer == True :
-                self._source_factory.active_mixer(True)
-                self._mode = "ACQUISITION_WITH_MIXER"
+                pass
+            # TODO :  deactivated code mixer does not work
+                #self._source_factory.active_mixer(True)
+                #self._mode = "ACQUISITION_WITH_MIXER"
             else :
                 #self._source_factory.active_mixer(False)
                 self._mode = "ACQUISITION"
                 
             self._pipeline.play()
-            self.debug('send acquisition-started - mode : %s',self._mode )
+            self.debug('send acquisition-started - mode : %s', self._mode)
             self.emit('acquisition-started', with_mixer)
 
 
         else :
-            self.error("Cannot start acquisition. Controller in incorrect mode (%s)", 
+            self.error("Cannot start acquisition."
+                        "Controller in incorrect mode (%s)", 
             self._mode)
-    
+
+
     def stop(self) :
         """ stop acquisition """
         self.debug('stop acquisition - mode  %s', self._mode)
@@ -170,9 +184,10 @@
             self.error(
             "Cannot stop acquistion. Controller in incorrect mode (%s)", 
             self._mode)
-   
+    
 
     def do_snapshot(self) :
+        """ make/request image snapshot """
         if self._mode in ("ACQUISITION", "ACQUISITION_WITH_MIXER") :
             self._source_factory.capture()
 
@@ -182,6 +197,8 @@
             self._mode)
 
     def active_mixer(self, is_active) :
+        """ active the mixer (onion skin)"""
+
         # check with current mixer status 
         self.debug('active_mixer : %s', is_active)
         if self.project.props['is-mixer-active'] == is_active :
@@ -230,18 +247,27 @@
         self.project.props['is-mixer-active'] = is_active
         
     def _connect_to_factory(self, factory, _capture_path) :
-        factory.connect("image-capture-done", self._image_capture_done_cb, _capture_path )
-    
+        """ connect to acqusistion factory signals """
+        factory.connect("image-capture-done",
+                        self._image_capture_done_cb,
+                        _capture_path )
     def _disconnect_from_factory(self, factory) :
+        """ disconnect signals from factory """
         factory.disconnect_by_function(self._image_capture_done_cb)
 
     def _image_capture_done_cb( self, factory, _capture_path) :
+        """ image capture done callback, 
+            signal received from factory """
+
         self.debug('RX image-capture-done')
         _rush_image = self._process_snapshot(_capture_path)
         self.debug('emit snapshot-taken : %s', _rush_image.name)
         self.emit('snapshot-taken', _rush_image)
 
     def _process_snapshot(self, capture_path) :
+        """ 
+        process image capture to insert in the luciole project 
+        """
          # get acquired image name
         _acq_image = capture_path
 
@@ -320,315 +346,4 @@
 
 
 
-# TODO : suppress CtrlAcq
-
-class CtrlAcq(Signallable, Loggable) :
-    MODES = (   "INVALID",
-                "NO_ACQUISITION",
-                "ACQUISITION",
-                "ACQUISITION_WITH_MIXER",
-                )
-
-    
-    __signals__ = {
-                    'acquirer-ready' : ['acquirer'],
-                    'acquirer-error' : ['msg'],
-                    'acquisition-started' : ['with_mixer'],
-                    'acquisition-stopped' : [],
-                    'snapshot-on-progress' : [],
-                    'snapshot-taken' : ['rush_image'],
-                }
-
-
-    def __init__(self, ctrl_project) :
-        """ initialize the acquirer   """
-        Signallable.__init__(self)
-        Loggable.__init__(self)
-        self.ctrl_project = ctrl_project
-        
-        self.acquirer = None
-        self.project = None
-        self._mode = "INVALID"
-        
-        # signal connections 
-        self._connect_to_project(self.ctrl_project)
-        
-        self.gui_signals = SignalGroup()   
-        
-        self.debug('CtrlAcq intialized : %s %s',self.ctrl_project, ctrl_project  )
-
-   
-    def init_acquirer(self, project) :
-        self.debug("Init acquirer")
-        _project = project.props
-        if _project != None :
-            # Create acquisition object
-            _acq_obj = None     
-            # remark;  acquisition object for webcam and dv cam
-            if _project['hardtype'] == LCONST.WEBCAM :
-                # init webcam factory 
-                self.factory = WebcamSourceFactory()
-                self.debug('Webcam factory : %s', self.factory )
-                self.pipeline = PTV_PPLN.Pipeline()
-                self.view_action = ViewAction()
-                self.view_action.addProducers(self.factory)
-                
-                self.viewer = self.ctrl_project.gui._get_drawarea()
-                self.viewer.hideSlider()
-                self.viewer.setPipeline(None)
-                self.viewer.setAction(self.view_action)
-                self.viewer.setPipeline(self.pipeline, "ACQUISITION")
-                #self.viewer.play()
-                # just for debug 
-                _acq_obj =self.pipeline
-
- 
-
-            elif _project['hardtype'] == LCONST.DVCAM :
-                # default acquisition load i.e. DVCAM
-                _acq_obj =  LACQ.Acquisition(
-                                    self._get_drawarea(self.ctrl_project.gui),
-                                    False,
-                                    _project['hardtype'],
-                                    project_dir = _project['project_dir'],
-                                    cb_error = self._on_error_acqusition,
-                                    cb_capture_done = self._on_done_snaphot)
-            else :
-                # Nothing to do
-                self.emit('acquirer-error', 'No valid acquirer found' )
-        if _acq_obj != None :
-            self._mode = "NO_ACQUISITION"
-            # for mixer initialisation set image to mix with the last image 
-            # of the capture view. only if capture image is not empty
-            if len(_project['capture_images'] ) > 0 :
-                _last_image_path = \
-                    os.path.join(   _project['project_dir'],
-                                    _project['rush_dir'],
-                                    _project['capture_images'][-1])
-                if os.path.exists(_last_image_path) : 
-                    _acq_obj.Image2Mix = _last_image_path
-            
-            self.emit('acquirer-ready', _acq_obj )
-        self.acquirer = _acq_obj
-
-    
-    def start_acquisition(self) :
-        if self._mode == "NO_ACQUISITION" :
-            self.pipeline.play()
-            self._mode = "ACQUISITION"
-            self.emit('acquisition-started', False)
-        else :
-            self.error(
-            "Cannot start acquisition. Controller in incorrect mode (%s)", 
-            self._mode)
-    
-    def stop_acquisition(self) :
-        if self._mode in ("ACQUISITION", "ACQUISITION_WITH_MIXER") :
-            if self._mode == "ACQUISITION_WITH_MIXER" :
-                pass
-                #self.acquirer.deactive_onion_skin()
-            self.pipeline.stop()
-            
-            self._mode = "NO_ACQUISITION"
-            self.debug('emit acquisition-stopped')
-            self.emit('acquisition-stopped')
-        else :
-            self.error(
-            "Cannot stop acquistion. Controller in incorrect mode (%s)", 
-            self._mode)
-
-    def active_mixer(self) :
-        if self._mode == "ACQUISITION" :
-            # the active onion skin stop the acquistion
-            self.acquirer.active_onion_skin()
-            # so start acqusition
-            self.acquirer.start_acqusition()
-
-            self._mode = "ACQUISITION_WITH_MIXER"
-            self.emit('acquisition-started', True)
-        else :
-            self.error(
-            "Cannot active mixer. Controller in incorrect mode (%s)", 
-            self._mode)
-
-
-    def deactive_mixer(self) :
-        if self._mode == "ACQUISITION_WITH_MIXER" :
-            # deactivate onion skin stop the acquistion
-            self.acquirer.deactive_onion_skin()
-            # so start acqusition
-            self.acquirer.start_acqusition()
-
-            self._mode = "ACQUISITION"
-            self.emit('acquisition-started', False)
-        else :
-            self.error(
-            "Cannot deactive mixer. Controller in incorrect mode (%s)", 
-            self._mode)
-    
-    def take_snapshot(self) :
-        if self._mode in ("ACQUISITION", "ACQUISITION_WITH_MIXER") :
-            if self.acquirer.is_streaming_active == True :
-                
-                self.debug('emit snapshot-on-progress')
-                self.emit('snapshot-on-progress')
-                self.acquirer.capture_image()
-
-
-
-    def release(self) :
-        # ensure acquisition stop
-        self.debug('Enterin release in mode=%s', self._mode)
-        if self._mode in ("ACQUISITION","ACQUISITION_WITH_MIXER") :
-            self.debug('Force acquistion stop : %s',  self._mode)
-            self.stop_acquisition()
-        else :
-            self.debug('Bad state  : %s',  self._mode)
-        self.acquirer.release()
-
-        #self._disconnect_from_project(self.ctrl_project)
-        #self._disconnect_from_gui(self.ctrl_project.gui)
-        #self.gui_signals.disconnectAll()
-
-    def _connect_to_project(self, ctrl_project) :
-        ctrl_project.connect('project-loaded', self._project_loaded_cb)
-        ctrl_project.connect('project-closed', self._project_closed_cb)
-    """
-    def _disconnect_from_project(self, ctrl_project) :
-        ctrl_project.disconnect_by_function(self._project_loaded_cb)
-        ctrl_project.disconnect_by_function(self._project_closed_cb)
-    """    
-    def _project_closed_cb(self, project_ctrl) :
-        self.debug('RX project-closed')
-        self.release()
-
-
-    def _project_loaded_cb(self, project_ctrl, project) :
-        self.debug('RX project-loaded')
-        self.init_acquirer(project)
-        self._connect_to_gui(self.ctrl_project.gui)
-        self.pipeline.play()
-        self.project = project
-
-    """" 
-    def _connect_to_gui(self, gui) :
-        # connection GUI to ctrl_acq 
-        gui.connect('start-acqusition', self._start_acq_cb) 
-        gui.connect('stop-acqusition', self._stop_acq_cb)
-        gui.connect('take-snapshot', self._take_snapshot_cb)
-        gui.connect('active-mixer', self._active_mixer_cb)
-        gui.connect('deactive-mixer', self._deactive_mixer_cb)
-        
-        # connection ctrl_acq to gui
-        gui._project_mode.connect_to_ctrl('ACQUISITION', self)
-    """
-    
-    def _connect_to_gui(self, gui) :
-        self.gui_signals.connect(
-            gui, "start-acqusition", None, self._start_acq_cb)
-        self.gui_signals.connect(
-            gui, "stop-acqusition", None, self._stop_acq_cb)
-        self.gui_signals.connect(
-            gui, "take-snapshot", None, self._take_snapshot_cb)
-        self.gui_signals.connect(
-            gui, "active-mixer", None, self._active_mixer_cb)
-        self.gui_signals.connect(
-            gui, "deactive-mixer", None, self._deactive_mixer_cb)
-        
-        # connection ctrl_acq to gui
-        gui._project_mode.connect_to_ctrl('ACQUISITION', self)
-
-
-    def _disconnect_from_gui(self,gui) :
-        # dicconnection GUI to ctrl_acq 
-        gui.disconnect_by_function(self._start_acq_cb) 
-        gui.disconnect_by_function(self._stop_acq_cb)
-        gui.disconnect_by_function(self._take_snapshot_cb)
-        gui.disconnect_by_function(self._active_mixer_cb)
-        gui.disconnect_by_function(self._deactive_mixer_cb)
-
-
-    def _start_acq_cb(self, gui) :
-        if self.ctrl_project.mode == 'ACQUISITION' :
-            self.start_acquisition()
-            
-    def _stop_acq_cb(self, gui) :
-        if self.ctrl_project.mode == 'ACQUISITION' :
-            self.stop_acquisition()
-
-    def _take_snapshot_cb(self, gui) :
-        if self.ctrl_project.mode == 'ACQUISITION' :
-            self.take_snapshot()        
-
-    def _active_mixer_cb(self, gui) :
-        self.active_mixer()
-    
-    def _deactive_mixer_cb(self, gui) :
-        self.deactive_mixer()
-
-    def _on_error_acqusition(self, message) :
-        """
-        callback error 
-        propagate it to main controller.
-        """
-        print " acqusistion error\n ", message
-        self.emit('acquirer-error', message)
-
-    def _on_done_snaphot(self, *unsued) :
-        """ 
-        callback when snaphot done.
-        """ 
-        _rush_image = self._process_snapshot()
-        self.debug('emit snapshot-taken : %s', _rush_image.name)
-        self.emit('snapshot-taken', _rush_image)
-
-    def _process_snapshot(self) :
-         # get acquired image name
-        _acq_image = self.acquirer.image2save
-
-        # build temp impage path
-        _temp_dir = os.path.join(self.project.props['project_dir'], 'tmp')
-        # copy name
-        _ac_image_temp = os.path.join(_temp_dir, _acq_image)
-        # resized copy name
-        _ac_image_temp_rz = \
-            os.path.join(_temp_dir, LCONST.ACQUIRED_IMAGE_NAME_RZ)
-
-        # build rush image name
-        _basename = LCONST.RUSH_FILENAME_TPL % self.project.rush.rush_index
-        _rush_image = \
-            os.path.join(self.project.props['project_dir'],
-                        self.project.props['rush_dir'],
-                        _basename)
-
-        try :  
-            # 1. move image acquired image to tmp dir
-            LT.movef(_acq_image, _ac_image_temp)
-
-            # 2. resize image result is in _ac_image_temp_rz
-            _rz_obj = LI.ImageResize(_ac_image_temp, _ac_image_temp_rz )
-            _rz_obj.convert()
-            
-            # 3. move resized image to rush dire 
-            LT.movef(_ac_image_temp_rz, _rush_image)
-        
-        except LEXCEP.LucioException, _err_msg :
-            self.error(_err_msg)
-        else : 
-            # 4. append image to rush list
-            _rush_image = self.project.rush.append(_basename)
-            
-            # always update the image 2 mix, even if mixer is not active
-            # used to memorize the last capture 
-            self.acquirer.Image2Mix = _rush_image.path
-            
-            # project modified
-            self.ctrl_project.is_modified = True
-            
-            return _rush_image
-
-    def _get_drawarea(self, gui) :
-        _da =  gui._get_drawarea()
-        self.debug(" Drawarea used : %s", _da)
-        return _da
 

=== modified file 'luciole/ctrl/ctrl_app.py'
--- luciole/ctrl/ctrl_app.py	2011-02-27 18:32:53 +0000
+++ luciole/ctrl/ctrl_app.py	2011-03-05 15:01:33 +0000
@@ -27,7 +27,6 @@
    Main application controller
 """
 # standard library imports
-import sys
 import os
 import os.path
 import locale
@@ -40,21 +39,14 @@
 
 from pitivi.signalinterface import Signallable
 from pitivi.log.loggable import Loggable
-from pitivi.log import log
 
 # local application/library specific imports
-import luciole.base.app_logging as LOGGING
-import luciole.base.exceptions as LEXCEP
 import luciole.base.options as OPTIONS
 import luciole.conf as LCONF
 import luciole.constants as LCONST
-import luciole.ctrl.constants as CTRL_CONST
-import luciole.ctrl.import_image as CTRL_IMPORT
 import luciole.ctrl.ctrl_project as CTRL_PROJECT
-import luciole.gui.constants as GUI_CONST
 import luciole.gui.main_window as GUI_MAIN
 import luciole.gui.gui_ctrl as GUI_CTRL
-import luciole.info as INFO 
 import luciole.media.lgst.play_sound as LSOUND
 #####
 
@@ -72,97 +64,128 @@
         self._connect_gui_and_project()
 
     def _connect_gui_and_project(self) :
-        
+        """ conect gui signals to project """ 
         # application high level actions 
         self.gui.gui_actions.connect('open-project', self._open_project_cb)
         self.gui.gui_actions.connect('new-project', self._new_project_cb)
         self.gui.gui_actions.connect('quit-app', self._quit_cb) 
         
         # Project level actions  
-        self.gui.gui_actions.connect('save-project', self._save_project_cb) 
-        self.gui.gui_actions.connect('save-as-project', self._save_as_project_cb) 
-        self.gui.gui_actions.connect('close-project', self._close_project_cb) 
-        self.gui.gui_actions.connect('acquisition-mode', self._acq_mode_cb) 
-        self.gui.gui_actions.connect('timeline-mode', self._timeline_mode_cb) 
-        self.gui.gui_actions.connect('import-sound', self._import_sound_cb) 
-        self.gui.gui_actions.connect('image-view', self._image_view_cb) 
-        self.gui.gui_actions.connect('import-images', self._import_images_cb) 
-        self.gui.gui_actions.connect('show-project-properties', self._show_project_properties_cb) 
+        self.gui.gui_actions.connect('save-project',
+                self._save_project_cb) 
+        self.gui.gui_actions.connect('save-as-project', 
+                self._save_as_project_cb) 
+        self.gui.gui_actions.connect('close-project',
+                self._close_project_cb) 
+        self.gui.gui_actions.connect('acquisition-mode',
+                self._acq_mode_cb) 
+        self.gui.gui_actions.connect('timeline-mode',
+                self._timeline_mode_cb) 
+        self.gui.gui_actions.connect('import-sound',
+                self._import_sound_cb) 
+        self.gui.gui_actions.connect('image-view',
+                self._image_view_cb) 
+        self.gui.gui_actions.connect('import-images',
+                self._import_images_cb) 
+        self.gui.gui_actions.connect('show-project-properties',
+                self._show_project_properties_cb) 
 
 
         # Acqusition actions
-        self.gui.gui_actions.connect('start-acquistion', self._start_acq_cb) 
-        self.gui.gui_actions.connect('stop-acquistion', self._stop_acq_cb) 
-        self.gui.gui_actions.connect('take-snapshot', self._take_snapshot_cb)
-        self.gui.gui_actions.connect('active-mixer', self._active_mixer_cb)
+        self.gui.gui_actions.connect('start-acquistion', 
+                self._start_acq_cb) 
+        self.gui.gui_actions.connect('stop-acquistion',
+                self._stop_acq_cb) 
+        self.gui.gui_actions.connect('take-snapshot',
+                self._take_snapshot_cb)
+        self.gui.gui_actions.connect('active-mixer',
+                self._active_mixer_cb)
         
         # Timeline actions
-        self.gui.gui_actions.connect('change-timeline-order', self._change_timeline_order_cb) 
-        self.gui.gui_actions.connect('insert-image-on-timeline', self._insert_image_on_timeline_cb) 
-        self.gui.gui_actions.connect('remove-image-on-timeline', self._remove_image_on_timeline_cb) 
-        self.gui.gui_actions.connect('active-sound', self._active_sound_cb) 
-        self.gui.gui_actions.connect('deactive-sound', self._deactive_sound_cb) 
-        self.gui.gui_actions.connect('sound-stop-with-video', self._sound_stop_with_video_cb) 
-        self.gui.gui_actions.connect('change-framerate', self._change_framerate_cb) 
+        self.gui.gui_actions.connect('change-timeline-order',
+                self._change_timeline_order_cb) 
+        self.gui.gui_actions.connect('insert-image-on-timeline',
+                self._insert_image_on_timeline_cb) 
+        self.gui.gui_actions.connect('remove-image-on-timeline',
+                self._remove_image_on_timeline_cb) 
+        self.gui.gui_actions.connect('active-sound',
+                self._active_sound_cb) 
+        self.gui.gui_actions.connect('deactive-sound',
+                self._deactive_sound_cb) 
+        self.gui.gui_actions.connect('sound-stop-with-video',
+                self._sound_stop_with_video_cb) 
+        self.gui.gui_actions.connect('change-framerate', 
+                self._change_framerate_cb) 
         
 
-
-
     #
     #  application high level callbacks 
     #
     
     def _open_project_cb(self, gui, path) :
-        self.debug('RX close-project signal')
+        """ GUI open project callback"""
+        self.debug('RX open-project signal')
         self.project_ctrl.open(path)
     
     def _new_project_cb(self, gui ) :
+        """ GUI new project callback"""
         self.debug('RX new-project signal' )
         self.project_ctrl.new_project()
 
 
     def _quit_cb(self, gui): 
+        """ GUI quit callback"""
         self.app.quit()
         return True
     #
     # Project level callbacks 
     #
     def _save_project_cb(self, gui) :
+        """ GUI save project callback"""
         self.debug('RX save-project signal')
         self.project_ctrl.save()
 
     def _save_as_project_cb(self, gui, path) :
+        """ GUI save as project callback"""
         self.debug('RX save-as-project signal')
         self.project_ctrl.save(path)
 
 
     def _close_project_cb(self, gui) :
+        """ GUI close project callback"""
         self.debug('RX close-project signal')
         self.project_ctrl.close()
 
         
     def _acq_mode_cb(self, gui) :
+        """ GUI acquisition mode callback"""
         self.debug('RX acquisition-mode signal')
         self.project_ctrl.acquisition_mode()
 
     def _timeline_mode_cb(self, gui) :
+        """ GUI timeline mode callback"""
         self.debug('RX timeline-mode signal')
-        self.project_ctrl.timleline_mode()
+        self.project_ctrl.timeline_mode()
     
     def _import_sound_cb(self, gui, path) :
+        """ GUI import sound callback"""
         self.debug('RX import-sound signal : %s', path)
         self.project_ctrl.ctrl_tmln.add_sound_track(path)
     
     def _image_view_cb(self, gui, origin, image_name, position = 0) :
-        self.debug('RX image-view signal : origin %s image %s', origin, image_name)
+        """ GUI image view callback"""
+        self.debug('RX image-view signal : origin %s image %s',
+                origin, 
+                image_name)
         self.project_ctrl.img_vw_mode(origin, image_name, position)
     
     def _import_images_cb(self, gui, paths) :
-        self.debug('RX import-images signal : %s',paths  )
+        """ GUI import images callback"""
+        self.debug('RX import-images signal : %s', paths  )
         self.project_ctrl.import_images(paths)
     
     def _show_project_properties_cb(self, gui) :
-        """ show project properties callback """
+        """ GUI show project properties callback """
         self.debug('RX show-project-properties' )
         self.project_ctrl.show_project_properties()
 
@@ -173,18 +196,22 @@
     # 
 
     def _start_acq_cb(self, gui) :
+        """ GUI start acqusisition callback"""
         self.debug(' RX start-acquistion signal')
         self.project_ctrl.ctrl_acq.start()
     
     def _stop_acq_cb(self, gui) :
+        """ GUI stop acqusisition callback"""
         self.debug(' RX stop-acquistion signal')
         self.project_ctrl.ctrl_acq.stop()
     
     def _take_snapshot_cb(self, gui) :
+        """ GUI take snapshot callback"""
         self.debug('RX take-snapshot signal')
         self.project_ctrl.ctrl_acq.do_snapshot()
 
     def _active_mixer_cb(self, gui, is_active) :
+        """ GUI active mixer callback"""
         self.debug('RX active-mixer signal : %s', is_active)
         self.project_ctrl.ctrl_acq.active_mixer(is_active)
 
@@ -192,31 +219,42 @@
     # Timeline callbacks
     # 
     def _change_timeline_order_cb(self, gui, objs, target):
-        self.debug('RX change-timeline-order signal - objs %s target %s', objs, target)
+        """ GUI change timeline sequence callback"""
+        self.debug(("RX change-timeline-order signal"
+                    " - objs %s target %s")
+                    , objs, target)
         self.project_ctrl.ctrl_tmln.change_order(objs, target)
 
     def _insert_image_on_timeline_cb(self, gui, objs, target):
-        self.debug('RX insert-image-on-timeline signal - objs %s target %s', objs, target)
+        """ GUI insert image on  timeline callback"""
+        self.debug(("RX insert-image-on-timeline signal"
+                    "- objs %s target %s"), 
+                    objs, target)
         self.project_ctrl.ctrl_tmln.insert(objs, target)
 
     def _remove_image_on_timeline_cb(self, gui, objs):
+        """ GUI remove image on  timeline callback"""
         self.debug('RX remove-image-on-timeline signal - objs %s', objs)
         self.project_ctrl.ctrl_tmln.remove(objs)
 
     def _active_sound_cb(self, gui) :
+        """ GUI active sound callback"""
         self.debug('RX active-sound signal') 
         self.project_ctrl.ctrl_tmln.add_sound_track_to_timeline()
 
     def _deactive_sound_cb(self, gui) :
+        """ GUI deactive sound callback"""
         self.debug('RX deactive-sound signal')
         self.project_ctrl.ctrl_tmln.remove_sound_track_from_timeline()
 
     def _sound_stop_with_video_cb(self, gui, is_stop) :
+        """ GUI sound stop with video callback"""
         self.debug('RX sound-stop-with-video, is_stop %s', is_stop)
         self.project_ctrl.ctrl_tmln.stop_sound_with_video(is_stop) 
     
     def _change_framerate_cb(self, gui, fpi) :
-        self.debug('RXchange-framerate, fpi %s', fpi)
+        """ GUI cahnge framerate callback"""
+        self.debug('RX change-framerate, fpi %s', fpi)
         self.project_ctrl.set_framerate(fpi)
 
 class CtrlApp(Signallable, Loggable) :
@@ -363,688 +401,8 @@
     def _quit_cb(self, project) :
         self.quit()
 
-class LucioleController(object):
-    """ 
-    Main luciole controller
-    """
-
-    def __init__(self, args) :
-        """ Controller initialisation.
-        
-        Is the main appication intialisation """
-        # init logging as early as possible so we can log startup code
-        enable_color = os.environ.get('PITIVI_DEBUG_NO_COLOR', '0') in ('', '0')
-        log.init('PITIVI_DEBUG', enable_color)
-        
-        #
-        # init attributes
-        #
-        self.ctrl_signals = None
-        self.__rusher = None
-
-        # parse program options 
-        self.__options = OPTIONS.options_parser()
-        
-        # init logging
-        self.logger = LOGGING.init_logging(
-                            self.__options.is_verbose, 
-                            log_to_file = self.__options.is_logfile
-                            )
-        self.logger.info("Starting luciole")
-        
-        # Init i18n 
-        self.__init_i18n()
-        
-        # load configuration : ie. saved user options
-        self.__configurer = LCONF.LucioleConf()
-        #  load GUI theme
-        self.__configurer.load_theme()
-        # create controller signals
-        self.__connect_signals()
-        # initialize gui and BTW threads        
-        self.__gui = GUI_CTRL.GuiController(self.ctrl_signals)
-        
-
-
-        # load recent projects
-        _cbs = None
-        _recent_mnger = self.__configurer.init_recent_manager(
-                                   self.__gui.file_recent_menu,
-                                   self.__gui.windows,
-                                   _cbs)
-        
-        # prepare callbacks for Project controller
-        _cbs = { 'done-rush' : self.on_done_rush,
-                'close-project' : self.on_close_project }
-
-        
-        # start project controller
-        self._project = \
-                CTRL_PROJECT.ProjectController(self.__gui,_recent_mnger ,_cbs)
-        
-        _cbs = {
-                'on-done-snapshot' : self.on_done_snapshot,
-                'on-error':self.on_error
-                }
-        self._viewer = CTRL_VIEWER.Viewer(self.__gui, _cbs)
-        
-        # display capture trash if option is set
-        if  self.__configurer.conf_options['CaptureTrashDisplay'] == 'yes' :
-            self.__gui.capture_trash = True
-
-
-
-        # conncet gui signals after the controller initialisation
-        self.__gui.connect_gui_signals()
-        # Connect GUI with app
-        self.__gui.connect_to_app_ctrl(self)
-       
-        # TODO : load timeline
-        #TMLN.Timeline()
-
-    def __connect_signals(self):
-        """ connect controller signals """
-        self.ctrl_signals = gobject.GObject()
-        for _signal in CTRL_CONST.CTRL_SIGNALS :
-            
-            # declare signal
-            gobject.signal_new(_signal, self.ctrl_signals,
-                       gobject.SIGNAL_RUN_LAST,
-                       gobject.TYPE_NONE,
-                       (gobject.TYPE_PYOBJECT,))
-
-            # Build signal callback function name from signal name 
-            # example : signal "change-alpha-mixer" 
-            #           have callback self.on_change_alpha_mixer 
-            _cb = 'self.on_' + _signal.replace('-', '_')
-            # connect signal
-            self.ctrl_signals.connect(_signal, eval(_cb))
-            
-
-    def on_change_alpha_mixer(self, *args) :
-        """ Request change mixer alpha value """
-        _args = self.__extract_signal_args(args) 
-        try :
-            self._viewer.change_mixer_alpha(_args['alpha'])
-        except  LEXCEP.LucioException, _err_msg :
-            raise LEXCEP.LucioException, _err_msg
-
-
-    def on_change_framerate(self,  *args) :
-        """ Request of framerate(fpi) change """
-        _args = self.__extract_signal_args(args) 
-        self._project.change_framerate(_args['framerate']) 
-        
-    def on_change_project(self, *args) :
-        """ Request for prohect change """
-        _args = self.__extract_signal_args(args)
-        for _key, _value in _args.iteritems() :
-            self._project.change_project(_key, _value)
-        
-    def on_close_project(self, *args ) :
-        """ Request for project close  """
-        _args = self.__extract_signal_args(args) 
-        # test if project exists
-        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
-            # check if project is modified 
-            if self._project.data['is_modified'] :
-                # ask for save it before close
-                _res = self.__gui.windows.\
-                    question_message(_('Save Project before closing'))
-                if _res : 
-                    self._project.save()
-                
-        # set viewer in default mode 
-        self._viewer.mode = self._viewer.DEFAULT
-        
-        # clear project controller 
-        self._project.mode = CTRL_CONST.NO_PROJECT
-        
-        # display close message 
-        _msg = _('Project %s is closed' % self._project.data['project_name'])
-        self.__gui.status_bar.display_message(_msg)
-
-
-    def on_create_project(self, *args) :
-        """ Request new project """
-        _args = self.__extract_signal_args(args) 
-        self._project.new()
-
-
-    def on_delete_capture(self, *args) :
-        """ Request delete on capture """
-        _args = self.__extract_signal_args(args) 
-        # remove on treeview
-        self.__gui.treeviews[LCONST.CAPTURE].remove()
-        
-        # The image selected for delete is displayed before delete
-        # so after go in default mode to nom more display the deleted image
-        self._viewer.mode = self._viewer.DEFAULT
-        
-        # change control widget in no acquisition mode
-        if self.__gui.control_widget.mode in\
-                ( GUI_CONST.ACQUISITION_ACTIVE,
-                GUI_CONST.ACQUISITION_ACTIVE_WITH_MIXER) :
-            self.__gui.control_widget.mode = GUI_CONST.ACQUISTION_INACTIVE
-
-
-    def on_delete_chrono(self, *args) :
-        """ Request delete on capture """
-        _args = self.__extract_signal_args(args) 
-        # remove on treeview
-        self.__gui.treeviews[LCONST.CHRONO].remove()
-        
-        # The image selected for delete is displayed before delete
-        # so after go in default mode to nom more display the deleted image
-        self._viewer.mode = self._viewer.DEFAULT
-
-        # change control widget in no acquisition mode
-        if self.__gui.control_widget.mode in \
-                ( GUI_CONST.ACQUISITION_ACTIVE,
-                GUI_CONST.ACQUISITION_ACTIVE_WITH_MIXER) :
-            self.__gui.control_widget.mode = GUI_CONST.ACQUISTION_INACTIVE
-
-
-    def on_display_about(self, *args) :
-        """ request display about """
-        _args = self.__extract_signal_args(args) 
-        # compute version
-        __version = "\n %s (%s)" % (INFO.VERSION, INFO.REVNO)
-        # display window
-        self.__gui.windows.about(__version)
-
-
-    def on_display_luciole_preferences(self, *args) :
-        """ Request display of application preferences """
-        _args = self.__extract_signal_args(args) 
-        _cbs = {'done-preferences' : self.on_done_preferences} 
-        self.__gui.windows.preferences(  self.__configurer.conf_options,
-                                        _cbs)
-                                        
-                                        
-        
-
-
-    def on_display_project_properties(self, *args) :
-        """ Request display project properties """
-        _args = self.__extract_signal_args(args) 
-        # test if project exists
-        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
-            # go in default mode before dispalying window
-            # due to webcam detection and avoid confilcts with acquisition
-            self._viewer.mode = self._viewer.DEFAULT
-            
-            # change control widget in no acquisition mode
-            self.__gui.control_widget.mode = GUI_CONST.ACQUISTION_INACTIVE
-
-            # display message 
-            self.__gui.status_bar.display_message(_('No Acquistion'))
-            
-            # launch project poperties window
-            _cbs = \
-            {'change-project-properties' : self.on_change_project_properties} 
-            self.__gui.windows.project_properties(self._project.data, _cbs) 
-
-
-    def on_export_to_tool(self, *args) :
-        """ Request export to tool  """
-        _args = self.__extract_signal_args(args) 
-        # test if project exists
-        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
-            self.__gui.windows.export_tool(self._project.data)
-
-
-    def on_export_to_video(self, *args) :
-        """ Request export to video  """
-        _args = self.__extract_signal_args(args) 
-        # test if project exists
-        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
-            self.__gui.windows.export_video(self._project.data)
-
-
-    def on_import_image(self, *args) :
-        """ Request image import """
-        _args = self.__extract_signal_args(args) 
-        # check if project exists
-        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
-            # open filename chooser dialog    
-            _filenames = self.__gui.windows.import_dialog()
-            
-            if _filenames != [] :
-                _cbs = { 'done-import' : self.on_done_import}
-                # start import controller
-                CTRL_IMPORT.ImportController(_filenames, 
-                                            self._project.data, 
-                                            self.__rusher,
-                                            self.__gui.status_bar,
-                                            _cbs)
-            else :
-                _msg = _("No files or valid files choosen for image import.")
-                self.__gui.windows.error_message( _msg)
-        else :
-            _msg = _("Impossible to import images when no project are loaded.")
-            self.__gui.windows.error_message( _msg)
- 
-    def on_move_down_chrono(self, *args) :
-        """ request to move down an image """
-        _args = self.__extract_signal_args(args) 
-        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
-            self.__gui.treeviews[LCONST.CHRONO].move_down()
-
-
-    def on_move_to_chrono(self, *args) :
-        """  request for move imge from capture to chrono"""
-        _args = self.__extract_signal_args(args) 
-        # get images to move from capture widget
-        _images_name = self.__gui.treeviews[LCONST.CAPTURE].images_to_move()
-        # append this images in chrono widget
-        _images_obj = \
-            [ self.__rusher.get_image(_image) for _image in _images_name ]
-        for _image in _images_obj :
-            self.__gui.treeviews[LCONST.CHRONO].append_image(_image)
- 
-
-    def on_move_up_chrono(self, *args) :
-        """ request to move up an image """
-        _args = self.__extract_signal_args(args) 
-        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
-            self.__gui.treeviews[LCONST.CHRONO].move_up()
-
-
-
-
-
-    def on_play_query_position(self, *args) :
-        """ Query for player position """
-        _args = self.__extract_signal_args(args) 
-        (_position, _duration) = self._viewer.play_query_position()
-        if _args['cb'] :
-            # callback call to gui 
-            _args['cb'](_position, _duration)
-
-
-    def on_play_video(self, *args) :
-        """ Play video request """
-        _args = self.__extract_signal_args(args) 
-        # test if project exists
-        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
-            try :
-                self._viewer.init_video_player(self._project.data)
-            except  LEXCEP.LucioException, _err_msg :
-                raise LEXCEP.LucioException, _err_msg
-            else :
-                self._viewer.mode = self._viewer.PLAYER
-                try :
-                    self._viewer.play_video(self._project.data)
-                except  LEXCEP.LucioException, _err_msg :
-                    raise LEXCEP.LucioException, _err_msg
-        else :
-            # send error message
-            msg =  _("Can not play animation : No project loaded")
-            self.__gui.windows.error_message( msg)
-
-
-    def on_quit_app(self, *args) :
-        """ Request quit application """
-        _args = self.__extract_signal_args(args) 
-        if self._project.mode == CTRL_CONST.PROJECT_LOADED and \
-                self._project.data['is_modified'] :
-            _msg = _('Project modified. Save project before exit ?')
-            _res = self.__gui.windows.question_message(_msg)
-            # if response is not a bool : cancel clicked
-            if isinstance(_res, bool) :
-                if _res :
-                    # if True save project before exit
-                    self._project.save()
-                GUI_CTRL.GuiController.quit()
-        else :
-            GUI_CTRL.GuiController.quit()
-
-    def on_save_as_project(self, *args) :
-        """  save as project request """
-        _args = self.__extract_signal_args(args) 
-        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
-            _dir = self.__gui.windows.dir_chooser()
-            if _dir != None :
-                # set viewer in default mode due to project reload
-                self._viewer.mode = self._viewer.DEFAULT
-                try : 
-                    self._project.save_as(_dir) 
-                except LEXCEP.LucioException, _err_msg :
-                    _msg = _('Impossible to save as project : %s' % _err_msg)
-                    self.__gui.windows.error_message(_msg)
-                else :
-                    _msg = _('Project saved as %s' % \
-                            self._project.data['project_name'])
-                    self.__gui.status_bar.display_message(_msg)
-
-
-    def on_save_project(self, *args) :
-        """ save project request """
-        _args = self.__extract_signal_args(args) 
-        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
-            try : 
-                self._project.save() 
-            except LEXCEP.LucioException, _err_msg :
-                _msg = _('Impossible to save project : %s' % _err_msg)
-                self.__gui.windows.error_message(_msg)
-            else :
-                _msg = _('Project %s saved' % \
-                        self._project.data['project_name'])
-                self.__gui.status_bar.display_message(_msg)
-                # update project name on Main bar
-                self.__gui.set_program_bar(self._project.data['project_name'],
-                                        self._project.data['is_modified'])
-
-
-    def on_start_acquisition(self, *args ) :
-        """Request for starting acqusisition """
-        _args = self.__extract_signal_args(args) 
-        # check if a project is loaded
-        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
-            self._viewer.mode = self._viewer.ACQUIRER
-                       
-            # change control widget in acquisition mode
-            self.__gui.control_widget.mode = GUI_CONST.ACQUISITION_ACTIVE
-
-        else :
-            _msg = \
-                _(' Can not start acquisition when no project are loaded.')
-            self.__gui.windows.error_message(_msg)
-
-
-    def on_start_mixer(self, *args) :
-        """ Request mixer start """
-        _args = self.__extract_signal_args(args) 
-         # check if a project is loaded
-        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
-            # switch to viewer with acqusisition and mixer
-            self._viewer.mode = self._viewer.ACQUIRER_WITH_MIXER
-            # change control widget in no acquisition mode
-            self.__gui.control_widget.mode = \
-                    GUI_CONST.ACQUISITION_ACTIVE_WITH_MIXER
-
-            # display message 
-            self.__gui.status_bar.display_message(_('Acquiring with mixer'))
-        else :
-            # robustness
-            _msg = \
-                _('No project are loaded.')
-            self.__gui.windows.error_message(_msg)
-
-
-
-    def on_stop_acquisition(self, *args) :
-        """ Request to stop acquistion  """
-        _args = self.__extract_signal_args(args) 
-        # check if a project is loaded
-        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
-            # switch to viewer default
-            self._viewer.mode = self._viewer.DEFAULT 
-            # change control widget in no acquisition mode
-            self.__gui.control_widget.mode = GUI_CONST.ACQUISTION_INACTIVE
-
-        else :
-            # robustness
-            _msg = \
-                _('No project are loaded.')
-            self.__gui.windows.error_message(_msg)
-
-    def on_stop_mixer(self, *args) :
-        """ Request mixer stop """
-        _args = self.__extract_signal_args(args) 
-         # check if a project is loaded
-        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
-            # switch to viewer with acqusisition and mixer
-            self._viewer.mode = self._viewer.ACQUIRER
-            # change control widget in no acquisition mode
-            self.__gui.control_widget.mode = \
-                    GUI_CONST.ACQUISITION_ACTIVE
-
-            # display message 
-            self.__gui.status_bar.display_message(_('Acquiring'))
-        else :
-            # robustness
-            _msg = \
-                _('No project are loaded.')
-            self.__gui.windows.error_message(_msg)
-
-    def on_stop_video(self, *args) :
-        """ Stop video request  """
-        _args = self.__extract_signal_args(args) 
-        try :
-            self._viewer.stop_video()
-        except  LEXCEP.LucioException, _err_msg :
-            raise LEXCEP.LucioException, _err_msg
-        else :
-            self._viewer.mode = self._viewer.DEFAULT
-
-
-    def on_take_snapshot(self, *args) :
-        """ take image snapshot request  """
-        _args = self.__extract_signal_args(args) 
-        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
-            self._viewer.take_snapshot()
-        else :
-            # robustness
-            _msg = \
-                _('No project are loaded.')
-            self.__gui.windows.error_message(_msg)
-
-            _msg = \
-                _('No project are loaded.')
-            self.__gui.windows.error_message(_msg)
-
-
-    def on_view_image(self, *args) :
-        """ 
-        request image view/display :
-        Mix image with stream if viewer mode is acquirer with mixer 
-        """
-        _args = self.__extract_signal_args(args) 
-        #if mode is player does not allow image view
-        if self._viewer.mode == self._viewer.PLAYER :
-            pass
-        
-        # if mode is acquirer with mixer and image is from capture treeview :
-        # mix image with acqusisition stream
-        elif self._viewer.mode == self._viewer.ACQUIRER_WITH_MIXER \
-        and _args['tv_type'] ==  LCONST.CAPTURE :
-            self._viewer.mix_image_in_stream(_args['image'])
-        
-        # on other cases view image
-        else :
-            self._viewer.mode = self._viewer.IMAGER
-            self._viewer.view_image(_args['image'])
-            
-            #change control widget in no acquisition mode
-            if self.__gui.control_widget.mode in \
-                    ( GUI_CONST.ACQUISITION_ACTIVE,
-                    GUI_CONST.ACQUISITION_ACTIVE_WITH_MIXER) :
-                self.__gui.control_widget.mode = GUI_CONST.ACQUISTION_INACTIVE
-
-
-    def run(self) :
-        """ main program ininite loop """
-        # TODO : 
-        GUI_CTRL.GuiController.threads_enter()
-        # before starting main loop check for 
-        # options given to application
-        
-        # load a project ? 
-        if self.__options.filename \
-        and os.path.exists(self.__options.filename):
-            # emit open project signal
-            self.__gui.emit(
-                        "open-project", self.__options.filename)
-
-        GUI_CTRL.GuiController.main_loop()
-        GUI_CTRL.GuiController.threads_leave()
-        self.logger.info("Leaving luciole")
-    #
-    #   Callbacks from controller
-    #
-    def on_done_rush(self, rusher) :
-        """ callback : when tush images are loaded """
-        if rusher != None \
-        and self._project.mode == CTRL_CONST.PROJECT_LOADED :
-            # load treeviews
-            # prepare data
-            _app_data = {}
-            _app_data['capture_images'] = self._project.data['capture_images']
-            _app_data['chrono_images'] = self._project.data['chrono_images']
-            _app_data['rush'] = rusher
-
-            self.__gui.load_treeviews(_app_data) 
-             
-            # init acquisition 
-            self._viewer.init_acquisition(self._project.data)                 
-            
-            
-            #  update fpi on gui and show it
-            self.__gui.update_framerate(int(self._project.data['fpi']))
-            
-            # show project  acquisition widgets
-            self.__gui.control_widget.mode = GUI_CONST.ACQUISTION_INACTIVE 
-
-            # update project name on Main bar
-            self.__gui.set_program_bar(self._project.data['project_name'],
-                                        self._project.data['is_modified'])
-            
-            # finish project load (project aspect)
-            self._project.finish_project_load()
-
-            # store rusher
-            self.__rusher = rusher
-   
- 
-
-    def on_done_snapshot(self) :
-        """
-        callback : image snapshot is done.
-        Now image can be processed into project
-        """
-        self._project.append_snapshot(self.__rusher, self._viewer.acquirer)
-        
-    def on_done_preferences(self , modified_options) :
-        """ callback : preferences modified fome diaog """
-        # update prefernces
-        (_capture_trash, _ask_restart) = \
-            self.__configurer.update_preferences(modified_options)
-        
-        # check if gui update is needed
-        if isinstance(_capture_trash, bool) :
-            self.__gui.capture_trash = _capture_trash
-
-        if isinstance(_ask_restart, bool) and _ask_restart == True :
-            _msg = \
-                _('Please restart Luciole to take into account the new theme ')
-            self.__gui.status_bar.display_message(_msg)
-
-    def on_change_project_properties(self, key, key_webcam= None, data =None) :
-        """ callback project change from properties window """
-        # webcam_data field of project dictionaty is a dictionaty
-        # Test if webcam data change key
-        if key == 'webcam_data':
-            # make a local copy of webcam_data
-            webcam_dict = self._project.data['webcam_data']
-            #test if webcam dict key exists
-            if webcam_dict.has_key(key_webcam) :
-                # update webcam key and call project change
-                webcam_dict[key_webcam] = data
-                self._project.change_project('webcam_data', webcam_dict)
-
-    def on_done_import(self, image_objs = [] ) :
-        """ callback : image import (rush generation) is done """
-        if image_objs != [] :
-            self._project.change_project(  'rush_images',
-                                            self.__rusher.dump_image_name())
-            # Not to be done in thread : interacts with gui
-            for _image_obj in image_objs :
-                self.__gui.append_capture(_image_obj)  
-   
-
-    
-    #
-    # Error calbacks 
-    #
-    def on_error(self, err_type, message) :
-        """ Main error callback  """
-        _msg = _("error type : %s.  %s" % (err_type, message))
-        # Display error on log window
-        self.logger.info(_msg)
-    #
-    # private methods
-    #
-    def __init_i18n(self) :
-        """ intialize locales """
-        _locale_path = LCONST.LOCALE_DIR
-
-        # Init the list of languages to support
-        _langs = []
-        #Check the default locale
-        _lc, _encoding = locale.getdefaultlocale()
-        if (_lc):
-            #If we have a default, it's the first in the list
-            _langs = [_lc]
-        # Now lets get all of the supported languages on the system
-        _language = os.environ.get('LANGUAGE', None)
-        _msg = "language : " , _language
-        self.logger.debug(_msg)
-        if (_language):
-            # langage comes back something like en_CA:en_US:en_GB:en
-            # on linuxy systems, on Win32 it's nothing, so we need to
-            # split it up into a list
-            _langs += _language.split(":")
-        # Now add on to the back of the list the translations that we
-        # know that we have, our defaults"""
-        _langs += ["en_US"]
-        
-        # Now langs is a list of all of the languages that we are going
-        # to try to use.  First we check the default, then what the system
-        # told us, and finally the 'known' list
-        _msg = "locale path", _locale_path
-        self.logger.debug(_msg)
-        
-        GUI_CTRL.GuiController.init_18n(_locale_path)
-        #import gtk.glade
-        #gtk.glade.bindtextdomain(LCONST.APP_NAME, _locale_path)
-        #gtk.glade.textdomain(LCONST.APP_NAME)
-
-        gettext.bindtextdomain(LCONST.APP_NAME, _locale_path)
-        gettext.textdomain(LCONST.APP_NAME)
-        
-        # Get the language to use
-        _lang = gettext.translation(LCONST.APP_NAME, _locale_path
-            , languages=_langs, fallback = True)
-        # Install the language, map _() (which we marked our
-        # strings to translate with) to self.lang.gettext() which will
-        # translate them."""
-        global _
-        _ = _lang.gettext
-
-
-
-    #
-    # static_method
-    #
-    @staticmethod
-    def __extract_signal_args(args) :
-        """ 
-        extract the signals arguments :
-        arfs is a tuple
-        The first argument is the emitter object ( gobject)
-        the second argument is a dict with all the parameter given 
-        to signal.
-        
-        The function returns the paramter dictionary
-        """
-        return args[1]
-            
-
-if __name__ == '__main__' :
-    X = LucioleController(sys.argv)
-    X.run() 
-    
+
+
+   
 
 

=== modified file 'luciole/ctrl/ctrl_project.py'
--- luciole/ctrl/ctrl_project.py	2011-02-28 18:27:56 +0000
+++ luciole/ctrl/ctrl_project.py	2011-03-05 15:01:33 +0000
@@ -202,7 +202,7 @@
             self.warning("impossible to switch to acquisition mode (%s)",
                     self._mode )
     
-    def timleline_mode(self) :
+    def timeline_mode(self) :
         """ activate timeline mode """
         if self._mode == 'ACQUISITION' :
             self.ctrl_acq.stop()
@@ -394,7 +394,11 @@
         """ import-image-done callback """
         self.debug("RX import-image-done : %s", images)
         if images != [] :
-            self.emit('import-image-done', images)
+            # when image is imported is equivalent to a
+            # snapshot tajed, so snapshot-taken signal can
+            # be emited for each image :
+            for image in images :
+                self.ctrl_acq.emit('snapshot-taken',image )
             
             # update project 
             # get image names
@@ -402,6 +406,8 @@
             self.project.props['rush_images'].extend(_names)
             self.project.props['capture_images'].extend(_names)
             self.is_modified = True
+            self.debug(' rush images : %s', self.project.props['rush_images'])
+
         else :
             self.warning('No image imported')
     
@@ -417,7 +423,7 @@
         self._old_mode = self._mode
         if self._mode == 'ACQUISITION' :
             # switch to TIMELINE to free the webcam
-            self.timleline_mode()
+            self.timeline_mode()
 
         
         _properties = ProjectProperties(self.gui.main_window, 
@@ -436,39 +442,18 @@
 
 
     def _start_project_load(self) :
-        
-        
         # start rusher controller
         _rush_ctrl = LRUSH.ControllerLoadRush(   self.project,
                                     self.gui.status_bar )
-        self._connect_to_rush(_rush_ctrl)
-        
-        # start acquirer controller
-        if self.project.props['hardtype'] in \
-            (LCONST.FAKE, LCONST.DVCAM, LCONST.WEBCAM ) :  
-            # start acquisition controller
-            #self.acq_ctrl = CTRL_ACQ.CtrlAcq(self)
-            self.debug('Acquirer Object loaded %s', self.ctrl_acq)
-        else :
-            # No acquisition (only import and timeline)
-            self._mode = "TIMELINE"
-
-        # start timeline controller
-        #self.ctrl_tmln = CTRL_TMLN.CtrlTimeline(self)
-
-
-    def _connect_to_rush(self, rush_ctrl) :
-        rush_ctrl.connect('rush-loaded', self._rush_load_finish_cb)
-
-    def _disconnect_from_rush(self, rush_ctrl) :
-        rush_ctrl.disconnect_by_function( self._rush_load_finish_cb)
+        _rush_ctrl.connect('rush-loaded', self._rush_load_finish_cb)        
+
 
     def _rush_load_finish_cb(self, rush_ctrl, rush_obj) :
         self.debug(" Rush Load Finish :%s ", rush_obj.dump_image_name() )
         if rush_obj != None : 
             self._terminate_project_load(rush_obj)
         # Load rush is done only one time at load so disconnect it
-        self._disconnect_from_rush(rush_ctrl)
+        rush_ctrl.disconnect_by_function( self._rush_load_finish_cb)
     
     def _terminate_project_load(self, rush_obj) :
         self.project.rush = rush_obj
@@ -506,11 +491,15 @@
 
     def _acquirer_ready_cb(self, ctrl_acq ) :
         self.debug('RX acquirer-ready signal')
-        # TODO : work around on mode
-        # FIXME : set to image to force transtion to acquisition mode
-        # default mode when project is started
-        self._mode = 'IMAGE_VIEW'
-        self.acquisition_mode()
+        if self.project.props['hardtype'] in \
+                (LCONST.FAKE, LCONST.DVCAM, LCONST.WEBCAM ) : 
+
+            
+            # TODO : work around on mode
+            # FIXME : set to image to force transtion to acquisition mode
+            # default mode when project is started
+            self._mode = 'IMAGE_VIEW'
+            self.acquisition_mode()
 
 
 
@@ -518,15 +507,20 @@
         self.error(msg)
     
     def _connect_to_timeline(self, ctrl_tmln) :
-        ctrl_tmln.connect('timeline-loaded', self._timeline_loaded_cb)
+        ctrl_tmln.connect('timeline-ready', self._timeline_ready_cb)
         
     def _disconnect_from_timeline(self, ctrl_tmln) :
         ctrl_tmln.disconnect_from_project(self)
         ctrl_tmln.disconnect_by_function(self._timeline_loaded_cb)
 
-    def _timeline_loaded_cb(self, ctrl_tmln): 
-        pass
-        #self.project.timeline = timeline
+    def _timeline_ready_cb(self, ctrl_tmln): 
+        if self.project.props['hardtype'] ==  LCONST.DIGICAM :
+            # TODO : work around on mode
+            # FIXME : set to image to force transtion to acquisition mode
+            # default mode when project is started
+            self._mode = 'IMAGE_VIEW'
+            self.timeline_mode()
+
     
     
     def _copy_to_image2mix(self, image_name) :

=== modified file 'luciole/ctrl/ctrl_timeline.py'
--- luciole/ctrl/ctrl_timeline.py	2011-02-28 12:58:02 +0000
+++ luciole/ctrl/ctrl_timeline.py	2011-03-05 15:01:33 +0000
@@ -430,7 +430,8 @@
 
 class ProjectModeTimeline(ProjectMode):
     __signals__ = {
-            'timeline-loaded' : ['timeline'] ,
+            'timeline-ready' : [], 
+            'timeline-error' : ['msg'] ,
             'sound-props-changed' : ['active', 'stop_with_video'],
             }
     
@@ -755,18 +756,24 @@
                 self.error(
                     'Sound track active but no sound file present (%s)' %
                      _sound_track)
-
-        # discover the factories
-        closure = {"rediscovered": 0}
-        discoverer = self.sources.discoverer
-        discoverer.connect("discovery-done", self._discovererDiscoveryDoneCb,
+        
+        if uris != [] :
+            # discover the factories
+            closure = {"rediscovered": 0}
+            discoverer = self.sources.discoverer
+            discoverer.connect("discovery-done", self._discovererDiscoveryDoneCb,
                 _project, _image_duration, uris, closure)
-        discoverer.connect("discovery-error", self._discovererDiscoveryErrorCb,
+            discoverer.connect("discovery-error", self._discovererDiscoveryErrorCb,
                 _project, _image_duration, uris, closure)
          
-        # start discoverer
+            # start discoverer
 
-        self.sources.addUris(uris)
+            self.sources.addUris(uris)
+        else :
+            # Nothing to load. emit timeline ready
+            self.debug('Nothing to load. Emit timeline-ready')
+            self.emit('timeline-ready')
+        # TODO : check why to be done here
         self.default_duration = _image_duration
 
     
@@ -805,8 +812,8 @@
                 stop_with_video =  project['sound']['stop_with_video'])
 
 
-        self.debug('Emit timeline-loaded')
-        self.emit('timeline-loaded')
+        self.debug('Emit timeline-ready')
+        self.emit('timeline-ready')
     
 
        

=== modified file 'luciole/gui/actions.py'
--- luciole/gui/actions.py	2011-02-28 12:58:02 +0000
+++ luciole/gui/actions.py	2011-03-05 15:01:33 +0000
@@ -212,11 +212,14 @@
         self._MODES_SIGNALS = {
             self._MODE_ACQ : 'acquisition-mode',
             self._MODE_TIMELINE : 'timeline-mode', }
+        (self._MODE_ACQ_VAL, self._MODE_TIMELINE_VAL) = range(2)
         self._MODES_RADIO_ACTION = [
             (self._MODE_ACQ, gtk.STOCK_MEDIA_RECORD,
-                '_Acqusition', '<Control>a', 'Acquisition Mode', 0),
+                '_Acqusition', '<Control>a', 'Acquisition Mode',
+                self._MODE_ACQ_VAL),
             (self._MODE_TIMELINE, gtk.STOCK_EXECUTE,
-                '_Timeline', '<Control>t', 'Timeline Mode', 1)
+                '_Timeline', '<Control>t', 'Timeline Mode', 
+                self._MODE_TIMELINE_VAL)
                     ]
                 
         # treeview actions
@@ -690,13 +693,18 @@
         #self._action_groups['TIMELINE'].set_sensitive(False)
 
     def _project_mode_changed_cb(self, ctrl, mode ):
+        self.debug('RX project-mode-changed')
+
         if mode == 'TIMELINE' :
             self._action_groups['TIMELINE'].set_sensitive(True)
             _list_actions = self._action_groups['TIMELINE'].list_actions()
-            
+            # TODO : code unusefull for toogleAction
+            # keeped as example
+
             self.debug('Actions in TIMELINE group : %s', _list_actions
                     )
             for _action in _list_actions :
+                # check if toggla actions are in this group
                 if isinstance(_action, gtk.ToggleAction) :
                     self.debug(' Action %s is sensitive :%s',
                                 _action.get_name(),
@@ -706,12 +714,24 @@
                         self.debug(' widget is sensitive :%s',
                                 _wdg.get_property('sensitive'))
 
-
+            
 
             self._action_groups['ACQUISITION'].set_sensitive(False)
+            # update mode action , if needed:
+            _action = self.get_action(self._MODE_TIMELINE)
+            _val = _action.get_current_value()
+            if _val != self._MODE_TIMELINE_VAL :
+                _action.set_active(True)
+
         elif mode == "ACQUISITION" :
             self._action_groups['TIMELINE'].set_sensitive(False)
             self._action_groups['ACQUISITION'].set_sensitive(True)
+            
+            # update mode action , if needed:
+            _action = self.get_action(self._MODE_ACQ)
+            _val = _action.get_current_value()
+            if _val != self._MODE_TIMELINE_VAL :
+                _action.set_active(True)