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

[NicoInattendu]

fix for bug #727165. ow on assistant and webcam properties window, the webcam playback is activated, in viewer window. It's allow a preview of webcam parameters

Bug correction.
Now on assistant and webcam properties window, the webcam plauback is activated, in viewer window. It's allow a preview of webcam parameters

=== modified file 'luciole/ctrl/ctrl_acq.py'
--- luciole/ctrl/ctrl_acq.py	2011-03-05 14:23:17 +0000
+++ luciole/ctrl/ctrl_acq.py	2011-03-09 11:46:59 +0000
@@ -33,7 +33,7 @@
 import gst
 from pitivi.signalgroup import SignalGroup
 from pitivi.action import ViewAction
-from pitivi.pipeline import Pipeline
+from pitivi.pipeline import Pipeline, PipelineError
 
 # local application/library specific imports
 from luciole.media.lgst.webcam_factory import WebcamSourceFactory
@@ -157,10 +157,14 @@
             else :
                 #self._source_factory.active_mixer(False)
                 self._mode = "ACQUISITION"
-                
-            self._pipeline.play()
-            self.debug('send acquisition-started - mode : %s', self._mode)
-            self.emit('acquisition-started', with_mixer)
+            try :     
+                self._pipeline.play()
+            except PipelineError :
+                self.warning('Fail to start pipeline')
+                self._mode = "NO_ACQUISITION"
+            else :
+                self.debug('send acquisition-started - mode : %s', self._mode)
+                self.emit('acquisition-started', with_mixer)
 
 
         else :

=== modified file 'luciole/ctrl/ctrl_project.py'
--- luciole/ctrl/ctrl_project.py	2011-03-05 13:59:13 +0000
+++ luciole/ctrl/ctrl_project.py	2011-03-09 11:46:59 +0000
@@ -39,15 +39,11 @@
 import luciole.base.exceptions as LEXCEP
 import luciole.base.tools as LT
 import luciole.constants as LCONST
-import luciole.ctrl.constants as CTRL_CONST
 import luciole.ctrl.ctrl_acq as CTRL_ACQ
-import luciole.ctrl.ctrl_base as CTRL_BASE
 import luciole.ctrl.ctrl_timeline as CTRL_TMLN
 import luciole.ctrl.ctrl_no_project as CTRL_NO_PROJECT
 import luciole.ctrl.ctrl_img_vw as CTRL_IMG_VW
 import luciole.ctrl.load_rush as LRUSH
-import luciole.gui.constants as GUI_CONST
-import luciole.media.image as LI
 import luciole.project.project_etree as LPF
 
 from luciole.gui.windows.assistant_new_project import AssistantNewProject
@@ -58,7 +54,7 @@
 _NULL_TUPLE = None, None
 
 class Project(object) :
-    
+    """ Type class for project data """    
     
     def __init__(self) :
         self.parser = LPF.ProjectToFile()
@@ -69,6 +65,7 @@
     
        
     def save(self, path) :
+        """ save to xml file """
         _project_path  = None 
         if path is not None :
             try :
@@ -83,6 +80,9 @@
         return _project_path
     
     def set_non_pjt_dpdt_props(self) :
+        """ set default valus for properties , 
+            who are not stored in xml file
+            """
         # init props not managed by porject in file
         self.props['is_modified'] = False 
         self.props['is-mixer-active'] = False
@@ -90,7 +90,8 @@
         self.props['alpha'] = LCONST.DEFAULT_ALPHA_IMAGE
 
 class CtrlProject(Signallable, Loggable) :
-    
+    """ High level class who manage a luciole project """
+
     # CONSTANTS
     MODES = ("NO_PROJECT", "ACQUISITION", "TIMELINE", "IMAGE_VIEW", "EXPORT")
     PROJECT_LOADED_MODES = ("ACQUISITION", "TIMELINE", "IMAGE_VIEW", "EXPORT")
@@ -141,6 +142,7 @@
         Loggable.__init__(self)
         
         self._mode = None
+        self._old_mode = None
         self.gui = None
         self.project = Project()
 
@@ -154,6 +156,7 @@
 
 
     def connect_to_gui(self, gui) :
+        """ connect project controller with gui """
         self.gui = gui
         
         self.ctrl_acq.set_viewer(gui.drawarea)
@@ -162,6 +165,7 @@
         self.ctrl_img_vw.set_viewer(gui.drawarea)
     
     def no_project_mode(self) :
+        """ activate NO_PROJECT mode """
         self.debug('No project mode')
         
         if self._mode == 'ACQUISITION' :
@@ -178,7 +182,7 @@
      
 
     def acquisition_mode(self, force = False) :
-        """ activate acquisition mode """
+        """ activate ACQUISITION mode """
         self.debug('Acquisition mode')
         if self._mode in self.PROJECT_LOADED_MODES \
             and self._mode != 'ACQUISITION'  :
@@ -195,30 +199,34 @@
 
             self.ctrl_acq.active_viewer()
             self.ctrl_acq.start()
-            self.debug('Emit project-mode-changed : %s'%self._mode)
-            self.emit('project-mode-changed',self._mode)
+            self.debug('Emit project-mode-changed : %s' % self._mode)
+            self.emit('project-mode-changed', self._mode)
 
         else :
             self.warning("impossible to switch to acquisition mode (%s)",
                     self._mode )
     
-    def timeline_mode(self) :
-        """ activate timeline mode """
+    def timeline_mode(self, force = False)  :
+        """ activate TIMELINE mode """
+        self.debug('setting timeline mode')
+        
         if self._mode == 'ACQUISITION' :
             self.ctrl_acq.stop()
         
-        if self._mode in self.PROJECT_LOADED_MODES \
-            and self._mode != 'TIMELINE'  :
+        if (self._mode in self.PROJECT_LOADED_MODES \
+            and self._mode != 'TIMELINE') \
+            or (force == True) :
 
             self._mode = 'TIMELINE'
             self.ctrl_tmln.active_viewer()
-            self.debug('Emit project-mode-changed : %s'%self._mode)
-            self.emit('project-mode-changed',self._mode)
+            self.debug('Emit project-mode-changed : %s' % self._mode)
+            self.emit('project-mode-changed', self._mode)
         else :
             self.warning("impossible to switch to timeline mode")
     
 
     def img_vw_mode(self, origin, image_name, position = 0) :
+        """ activate IMAGE_VIEW mode """
         if self._mode in self.PROJECT_LOADED_MODES : 
             if self._mode == 'ACQUISITION' :
                 self.ctrl_acq.stop()
@@ -274,7 +282,7 @@
             # close current project
             self.close()
             
-        _ass = AssistantNewProject(self._new_project_cb)
+        _ass = AssistantNewProject(self._new_project_cb, self.gui.drawarea)
         
 
         
@@ -315,13 +323,14 @@
             self.project = None
     
     def save(self, dir_path = None ) :
+        """ save project """
         if self._mode not in self.PROJECT_LOADED_MODES :
             self.error('invalid mode for save : %s'%self._mode)
             return
         if dir_path and not os.path.exists(dir_path) :
             self.error('Path %s exists. Impossible to save project', dir_path)
             return
-        self.debug("%s",dir_path)  
+        self.debug("%s", dir_path)  
         try :
             _project_path = self.project.save(dir_path)
         except LEXCEP.LucioException, _err_msg :
@@ -332,10 +341,11 @@
             if dir_path is not None and _project_path is not None  :
                 # reload project is corretcly saved
                 self.close()
-                self.debug('Opening project with path %s',_project_path)
+                self.debug('Opening project with path %s', _project_path)
                 self.open(_project_path)
     
     def set_framerate(self, fpi, force = False) :
+        """ set project framerate """
         if self._mode != "TIMELINE" and force == False :
             self.info('update of fpi only availabe in TIMELINE mode')
             return
@@ -347,18 +357,9 @@
         
 
 
-    def new(self, project_data = None) :
-        
-        # create new project
-
-        if  project_data :
-            # TODO case with assistant
-            pass
-
-
-
     def release(self) :
-
+        """ release project ctrl """
+        # TODO : this fucntion seems unuseful : Ton analyse
         # release signals between aquirer and project
         if self.project.props['hardtype'] in \
                 (LCONST.FAKE, LCONST.DVCAM, LCONST.WEBCAM ) : 
@@ -374,12 +375,13 @@
 
 
     def import_images(self, paths) :
+        """ import images """
         if self._mode not in self.PROJECT_LOADED_MODES :
             self.error('invalid mode for import: %s'%self._mode)
             return
 
         if paths != [] :
-            self.debug('Starting image importer for %s',paths)
+            self.debug('Starting image importer for %s', paths)
             importer =  ImportController(   paths,
                                         self.project.props,
                                         self.project.rush,
@@ -398,7 +400,7 @@
             # snapshot tajed, so snapshot-taken signal can
             # be emited for each image :
             for image in images :
-                self.ctrl_acq.emit('snapshot-taken',image )
+                self.ctrl_acq.emit('snapshot-taken', image )
             
             # update project 
             # get image names
@@ -419,7 +421,7 @@
         if self._mode not in self.PROJECT_LOADED_MODES :
             self.error('invalid mode for import: %s'%self._mode)
             return
-        self.debug('%s',self.project.props)
+        self.debug('%s', self.project.props)
         self._old_mode = self._mode
         if self._mode == 'ACQUISITION' :
             # switch to TIMELINE to free the webcam
@@ -427,21 +429,34 @@
 
         
         _properties = ProjectProperties(self.gui.main_window, 
-                self.project.props)
+                self.project.props, self.gui.drawarea)
         _properties.connect('project-changed', self._project_modified_cb)
+        _properties.connect('dialog-closed', self._dialog_pp_closed_cb)
         _properties.run()
 
     def  _project_modified_cb(self, dialog, project_data) :
         """ callback for modified data from project properties dialog """
         self.is_modified = True
+        
+    def  _dialog_pp_closed_cb(self, dialog) :
+        """ dialog project properties closed callback """
         if self._old_mode == 'ACQUISITION' :
             # go back to acqusition mode
             self.acquisition_mode(True)
             self._old_mode = None
+        if self._old_mode == 'TIMELINE' :
+            # go back to acqusition mode
+            # trick to force timeline mode reload
+            self.timeline_mode(True)
+            self._old_mode = None
+
 
 
 
     def _start_project_load(self) :
+        """ start project load. 
+            i.e. execute project controller """
+
         # start rusher controller
         _rush_ctrl = LRUSH.ControllerLoadRush(   self.project,
                                     self.gui.status_bar )
@@ -449,6 +464,7 @@
 
 
     def _rush_load_finish_cb(self, rush_ctrl, rush_obj) :
+        """ image rush load finish callback """ 
         self.debug(" Rush Load Finish :%s ", rush_obj.dump_image_name() )
         if rush_obj != None : 
             self._terminate_project_load(rush_obj)
@@ -456,13 +472,14 @@
         rush_ctrl.disconnect_by_function( self._rush_load_finish_cb)
     
     def _terminate_project_load(self, rush_obj) :
+        """ terminate load of a project """
         self.project.rush = rush_obj
         
         # set project as not modified as it is just loaded
         self.project.set_non_pjt_dpdt_props()
         
         # set path for image to mix
-        self.project.props['image2mix'] =\
+        self.project.props['image2mix'] = \
                 os.path.join(
                         self.project.props['project_dir'],
                         LCONST.IMAGE2MIX_NAME
@@ -481,15 +498,18 @@
         self.emit('project-loaded', self.project )
     
     def _connect_to_acq(self , ctrl_acq) :
+        """ connect to acqusision controller """
         ctrl_acq.connect('acquirer-ready', self._acquirer_ready_cb)
         ctrl_acq.connect('acquirer-error', self._acquirer_error_cb)
 
     def  _disconnect_from_acq(self , ctrl_acq) :
+        """ disconnect from acqusision controller """
         ctrl_acq.disconnect_by_function( self._acquirer_ready_cb)
         ctrl_acq.disconnect_by_function( self._acquirer_error_cb)
 
 
     def _acquirer_ready_cb(self, ctrl_acq ) :
+        """ acquirer ready callback """
         self.debug('RX acquirer-ready signal')
         if self.project.props['hardtype'] in \
                 (LCONST.FAKE, LCONST.DVCAM, LCONST.WEBCAM ) : 
@@ -504,27 +524,32 @@
 
 
     def _acquirer_error_cb(self, ctrl_acq, msg) :
+        """ acquirer error callback """
+        # TODO : implementation of acqusition errot
+        # not corectly managed
         self.error(msg)
     
     def _connect_to_timeline(self, ctrl_tmln) :
+        """ connect to timeline controller """
         ctrl_tmln.connect('timeline-ready', self._timeline_ready_cb)
         
     def _disconnect_from_timeline(self, ctrl_tmln) :
+        """ discconnect from timeline controller """
         ctrl_tmln.disconnect_from_project(self)
-        ctrl_tmln.disconnect_by_function(self._timeline_loaded_cb)
+        ctrl_tmln.disconnect_by_function(self._timeline_ready_cb)
 
     def _timeline_ready_cb(self, ctrl_tmln): 
+        """ timeline ready callback """
+        self.debug('RX timeline-ready signal')
         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()
+            # when digicam mode is set force timeline mode
+            self.timeline_mode(True)
 
     
     
     def _copy_to_image2mix(self, image_name) :
-        
+        """ on directory, copy an image to image the image 2 mix path
+        """
         _source = os.path.join(     self.project.props['project_dir'],
                                         self.project.props['rush_dir'],
                                         image_name)

=== modified file 'luciole/gui/windows/assistant_new_project.py'
--- luciole/gui/windows/assistant_new_project.py	2011-02-28 12:58:02 +0000
+++ luciole/gui/windows/assistant_new_project.py	2011-03-09 11:46:59 +0000
@@ -408,8 +408,8 @@
 class PageWebcam(LWDW.WebcamDetectionWidget) :
     """ Assistant page for webcam detection """
     
-    def __init__(self, assistant, project_data, *args ) :
-        LWDW.WebcamDetectionWidget.__init__(self, project_data, *args )
+    def __init__(self, assistant, project_data,  viewer_wdg, *args ) :
+        LWDW.WebcamDetectionWidget.__init__(self, project_data, viewer_wdg, *args )
         self.assistant = assistant
 
     def webcam_detection_prepare(self, page) :
@@ -517,8 +517,8 @@
         """ Call back for 'selection-changed' signal """
         _filename = widget.get_filename()
         if _filename :
-             self.project_data['sound']['active'] = 'yes'
-             self.project_data['sound']['input_path'] = _filename
+            self.project_data['sound']['active'] = 'yes'
+            self.project_data['sound']['input_path'] = _filename
 
 
 
@@ -650,9 +650,10 @@
     
     __LUCIOLE_LOGO = os.path.join(LCONST.IMAGE_DIR,'luciole_logo.png')
 
-    def __init__(self, apply_callback) :
+    def __init__(self, apply_callback, viewer_wdg) :
         """ Initialize assistant window """
         self.apply_callback = apply_callback 
+        self.viewer_wdg = viewer_wdg
         
         #
         # init project datas 
@@ -696,7 +697,7 @@
         #
         # configure page 3
         #
-        self._pg3 = PageWebcam( self.assistant, self.project_data) 
+        self._pg3 = PageWebcam( self.assistant, self.project_data, self.viewer_wdg) 
         self.assistant.append_page(self._pg3)
         self.assistant.set_page_title( self._pg3, _(' Webcam detection '))
         self.assistant.set_page_type( self._pg3, gtk.ASSISTANT_PAGE_CONTENT)

=== modified file 'luciole/gui/windows/dialog_project_properties.py'
--- luciole/gui/windows/dialog_project_properties.py	2011-02-27 18:32:53 +0000
+++ luciole/gui/windows/dialog_project_properties.py	2011-03-09 11:46:59 +0000
@@ -53,6 +53,7 @@
     """
     __signals__ = {
                     'project-changed' : ['project'],
+                    'dialog-closed' : [],
                     }
 
     # This tow 2 tables descibes how to display project info
@@ -130,7 +131,7 @@
 
     _title = _('Project properties')
     
-    def __init__(self, main_window,  project) :
+    def __init__(self, main_window,  project , viewer_wdg) :
         """ create a Dialog with project properties and display it"""
         Loggable.__init__(self)
         Signallable.__init__(self)
@@ -145,8 +146,8 @@
                 gtk.STOCK_APPLY, gtk.RESPONSE_APPLY
             )
         )
-        print self._dialog.vbox
         self._project = project
+        self._viewer_wdg = viewer_wdg
         # keep framerate list and framerate selected those value can change
         #self._framerate_selected = None
         #self._framerate_list = None
@@ -204,8 +205,9 @@
                         self._new_webcam_props != self._project['webcam_data'] :
                     self._project['webcam_data'].update(self._new_webcam_props)
                     self.emit('project-changed', self._project)
-
-
+        
+        self.debug('emit dialog-closed signal')
+        self.emit('dialog-closed')
 
     def _cb_on_exit(self, widget, event) :
         """ on exit callback """
@@ -530,7 +532,10 @@
             
     def on_button_webcam_clicked(self, widget) :
         """ Button webcam clicked """
-        self._widget_webcam = WebcamDetectionDlg(self._dialog, self._cb_webcam_updated)
+        self._widget_webcam = WebcamDetectionDlg(
+                self._dialog,
+                self._viewer_wdg,
+                self._cb_webcam_updated)
 
 
     def _cb_webcam_updated(self, webcam_props) :
@@ -667,7 +672,7 @@
 class WebcamDetectionDlg(gtk.MessageDialog, Loggable) :
     """ Opens Dialog for webcam Detection """
    
-    def __init__(self, parent, cb_ok = None ) :
+    def __init__(self, parent, viewer_wdg, cb_ok = None ) :
         """ create a Dialog with project properties and display it
             parent : The parent window
             cb_ok : The callback when on button is clicked 
@@ -685,7 +690,9 @@
         # detected data will be stored here 
         self.project_webcam = dict()
         
-        self.webcam_widget = LWDW.WebcamDetectionWidget(self.project_webcam) 
+        self.webcam_widget = \
+                LWDW.WebcamDetectionWidget(self.project_webcam,
+                                            viewer_wdg)
         self.webcam_widget.connect('webcam-caps-selected', 
                 self._webcam_caps_selected)
         self.webcam_widget.connect('webcam-caps-selected', 

=== modified file 'luciole/gui/windows/webcam_detection_widget.py'
--- luciole/gui/windows/webcam_detection_widget.py	2011-02-16 13:04:44 +0000
+++ luciole/gui/windows/webcam_detection_widget.py	2011-03-09 11:46:59 +0000
@@ -35,19 +35,13 @@
 import gobject
 
 
-import gst
-
-
 from pitivi.log.loggable import Loggable
 from pitivi.signalinterface import Signallable
 
 # for test
-from pitivi.encode import RenderSinkFactory, RenderFactory
-from pitivi.action import RenderAction
-from pitivi.factories.base import SinkFactory
 from pitivi.pipeline import Pipeline
-from pitivi.settings import StreamEncodeSettings, RenderSettings
 
+from pitivi.action import ViewAction
 # local application/library specific imports
 import luciole.media.webcam_detect.webcam_detection as WBCM_DTCT
 
@@ -55,6 +49,7 @@
 from luciole.media.lgst.webcam_factory import WebcamSourceFactory
 
 class WebcamField(Loggable, Signallable) :
+    """ Manage webcam properties/fields """
     __signals__ = {
                 'combo-changed' : ['field','value'],
         }
@@ -68,9 +63,10 @@
         self._combo_idx = []
         self._combo = None
         self._range = None
-        self.widget = self._createUi()
+        self.widget = self._create_ui()
 
-    def _createUi(self) : 
+    def _create_ui(self) :
+        """ Gui widgetc creation """
         _bbox =  gtk.HBox()
         _boxalign = gtk.Alignment(xalign=0.0, yalign=0.0)
         _boxalign.add(_bbox)
@@ -91,16 +87,18 @@
         return _boxalign
     
     def _create_combo(self, bbox) :
+        """ create GUI combo box """
         _combo = gtk.combo_box_new_text()
         self.debug('create combobox for field %s', self.field_name)
         for _idx, _value in enumerate(self.value) :
             _combo.append_text(str(_value))
             self._combo_idx.append(str(_value))
-        _combo.connect('changed', self.combobox_defintion_changed_cb)
+        _combo.connect('changed', self._combobox_defintion_changed_cb)
         bbox.pack_start(_combo, expand=False)
         return _combo
     
     def _create_range(self, bbox) :
+        """ create GUI range """
         
         _adj = gtk.Adjustment(
                 float(self.value[0]),
@@ -115,19 +113,21 @@
         _scale.set_value_pos(gtk.POS_RIGHT)
         _scale.set_draw_value(True)
         _scale.set_size_request(500, 500)
-        _scale.connect('value-changed', self.vscale_value_changed_cb)
+        _scale.connect('value-changed', self._vscale_value_changed_cb)
         bbox.pack_start(_scale, expand=True, fill = True )
         return _scale
 
-    def combobox_defintion_changed_cb(self, widget) :
-
+    def _combobox_defintion_changed_cb(self, widget) :
+        """ combobox change callback"""
         self.emit('combo-changed', self.field_name, widget.get_active_text() )
     
-    def vscale_value_changed_cb(self, widget) :
+    def _vscale_value_changed_cb(self, widget) :
+        """ scale value changed callback"""
         self.emit('combo-changed', self.field_name, widget.get_value() )
 
 
     def set_active(self, value) :
+        """ active values on combo """
         if self._combo is not None :
             try :
                 _idx = self._combo_idx.index(value)
@@ -138,7 +138,7 @@
 
 
 class WebcamPropsWdg(Loggable, Signallable) :
-    """ Webcam Properties """ 
+    """ Webcam Properties widget """ 
    
     __signals__ = {
         'prop-changed' : ['prop','value'],
@@ -158,46 +158,48 @@
 
         parent_wdg.add(self._main_window)
         
-        self.prepare_ui()
         
         # Show the window and all its children
         self._main_window.show_all()
 
-        
-
-    def prepare_ui(self) :
-        pass
            
   
     def set_definitions(self, definitions) :
+        """ set webcam definitions GUI prop"""
         self.set_prop('definition', definitions) 
     
     def set_active_defintion(self, definition) :
+        """ set webcam active definition GUI prop"""
         _wdg = self.prop_widgets['definition']
         _wdg.set_active(definition)
 
 
     def set_videotypes(self, videotypes) :
+        """ set webcam videotypes GUI prop"""
         self.set_prop('videotype', videotypes) 
 
     def set_active_videotype(self, value) :
+        """ set webcam active videotype GUI prop"""
         self.set_active_prop('videotype', value) 
     
     
     def set_prop(self, prop, prop_values, wdg_type='combo' ) :
+        """ set a webcam GUI prop. Generic method """
         _wdg = WebcamField(prop, prop_values, wdg_type )
         if isinstance(prop_values, list) :
-            _wdg.connect('combo-changed', self.combo_changed_cb)
+            _wdg.connect('combo-changed', self._combo_changed_cb)
             self.prop_widgets[prop] = _wdg
         self._main_window.pack_start(_wdg.widget) 
         _wdg.widget.show_all()
 
     
     def set_active_prop(self, prop, active_value):
+        """ set a webcam active GUI prop. Generic method """
         _wdg = self.prop_widgets[prop]
         _wdg.set_active(active_value)
     
     def remove_prop(self, prop) :
+        """ remove a webcam property """
         if prop in self.prop_widgets :
         
             self.debug('remove prop %s', prop)
@@ -207,20 +209,23 @@
             del self.prop_widgets[prop]
     
     def remove_all_props(self) :
+        """ remove all properties """
         _props =  self.prop_widgets.keys()
         for _prop in _props:
             _wdg = self.prop_widgets.pop(_prop)
             self._main_window.remove(_wdg.widget)
-            _wdg.disconnect_by_function(self.combo_changed_cb)
+            _wdg.disconnect_by_function(self._combo_changed_cb)
             self.debug("remove widget prop %s", _prop)
 
 
-    def combo_changed_cb(self, widget, prop, value) :
+    def _combo_changed_cb(self, widget, prop, value) :
+        """ combobox value changed callback """
         self.debug('emit prop-changed : %s=%s', prop, value)
         self.emit('prop-changed', prop, value)
     
 
     def display_webcams(self, _webcams) :
+        """ display detected webcams """
         _wdg = WebcamField('webcam-name', _webcams)
         if isinstance(_webcams, list) :
             _wdg.connect('combo-changed', self._webcam_changed_cb)
@@ -230,21 +235,15 @@
         _wdg.widget.show_all()
     
     def _webcam_changed_cb(self, widget, prop, value) :
+        """ webcam selection callback """
         self.debug('emit webcam-changed : %s=%s', prop, value)
         
         self.emit('webcam-changed', value)
 
 
-class FakeSinkFactory(SinkFactory):
-    def __init__(self, factoryname="fakesink", *args, **kwargs):
-        SinkFactory.__init__(self, *args, **kwargs)
-        self.__factoryname=factoryname
-
-    def _makeBin(self, output_stream=None):
-        return gst.element_factory_make(self.__factoryname)
-
 class  WebcamDetectionWidget(gtk.Frame, Loggable) :
     """ Assistant page for webcam detection """
+
     __gsignals__ = { 
            'webcams-detected' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
                                (gobject.TYPE_PYOBJECT,)),
@@ -260,12 +259,14 @@
 
 
         
-    def __init__(self, project_data, *args ) :
+    def __init__(self, project_data, viewer, *args ) :
         gtk.Frame.__init__(self, *args )
-        Signallable.__init__(self)
         Loggable.__init__(self)
         self.wcam_params = {}
-
+        self._viewer = viewer
+        self.factory = None
+        self.action = None
+        self.pipeline = None
         self.set_name('Page_webcam')
         self.project_data = project_data
         
@@ -306,57 +307,55 @@
             self.info('No webcam detected')
             self.emit('webcam-not-detetcted')
 
+    def prepare_viewer(self, wcam_params) :
+        """ prepare viewer and pipeline """
+        self.debug('prepare pipeline/viewer start')
 
-    def active_webcam(self, device) :
-        if self.pipeline is not None :
+        viewer = self._viewer
+        if viewer.pipeline is not None :
             try :
-                self.pipeline.pause()
-                self.render.deactivate()
+                viewer.pause()
             except :
-                pass
-
-        
+                self.warning('Impossible to pause viewer')
         self.factory = WebcamSourceFactory()
-        self.debug("%s", self.wcam_params)
-        self.factory.webcam_params =  self.wcam_params
+        self.factory.webcam_params =  wcam_params
+        self.factory.with_scale = False
+
         self.pipeline = Pipeline()
-        
-        vsettings = StreamEncodeSettings(encoder="theoraenc")
-        rsettings = RenderSettings(settings=[vsettings],
-                                   muxer="oggmux")
-        
-        self.fakesink = FakeSinkFactory()
-        rendersink = RenderSinkFactory(RenderFactory(settings=rsettings),
-                                       self.fakesink)
-        self.render = RenderAction()
-        #self.pipeline.connect("eos", self._renderEOSCb)
-        #self.pipeline.connect("error", self._renderErrorCb)
-        self.pipeline.addAction(self.render)
-        self.render.addConsumers(rendersink)
-        self.render.addProducers(self.factory)
-        self.render.activate() 
-        self.pipeline.play()
-        gobject.timeout_add(1000, self._deactive_pipeline)
-        return self.factory
-    
-    def _deactive_pipeline(self) :
-        self.debug('Deactive Pipeline')
-        if self.pipeline is not None :
+        self.action = ViewAction()
+        self.action.addProducers(self.factory)
+        viewer.setPipeline(None)
+        #viewer.showSlider()
+        
+        # FIXME: why do I have to call viewer.setAction ?
+        viewer.setAction(self.action)
+        viewer.setPipeline(self.pipeline)
+        viewer.play()
+        self.debug('viewer started')
+ 
+    def release_viewer(self) :
+        """ release pipeline for viewer"""
+        self.debug(' release pipe %s', self.pipeline)
+
+        viewer = self._viewer
+        if self.pipeline is None  :
+            self.debug('No pipeline to release')
+            return
+        if viewer.pipeline is not None :
             try :
-                print " release ."
-                self.pipeline.stop()
-                self.render.deactivate()
-                self.render.setPipeline(None)
-                self.pipeline.release()
-                self.pipeline = None
-                self.factory = None
-
+                viewer.stop()
             except :
-                pass
-        return False
+                self.warning('Impossible to stop pipeline')
+
+        viewer.setPipeline(None)
+        self.pipeline.release()
+        self.pipeline = None
+        self.factory = None
+        self.action = None
 
 
     def _webcam_changed_cb(self, wdg, webcam) :
+        """ webcam selection changed callback """
         self.debug('Rx webcam-changed : %s', webcam )
         self.webcam_props.clear_all()
         self.wcam_params = {}
@@ -379,8 +378,8 @@
                         'device':_selected_device['device-file'],
                         }
                     }
-            _factory = self.active_webcam(self.wcam_params)
-            self.webcam_props.prepare(_factory.webcam_caps)
+            self.prepare_viewer(self.wcam_params)
+            self.webcam_props.prepare(self.factory.webcam_caps)
 
 
         else :
@@ -388,94 +387,17 @@
     
 
     def _caps_selected_cb(self, webcam_props, caps) :
+        """ webcam caps(propeties) selected callback """
         self.project_data['webcam_data']['caps'] = caps
+        
+        self.wcam_params['wcam_filter'] = {
+                'media_type' : caps,
+                }
+        
+        self.prepare_viewer(self.wcam_params)
+
         self.debug('Rx caps-selected : %s', caps.to_string() )
         self.emit('webcam-caps-selected', caps)
-
-    
-
-
-    def _on_webcam_detect_complete(self, webcam_obj) :
-        """ callback , executed when webcam detection is complete 
-            Return the number of detected webcams"""
-        _status = 0
-
-        if webcam_obj != None and webcam_obj.webcam_devices != None:
-            _vbox = self._vbox
-            # firt clean childs on the vbox widget
-            for _child in _vbox.get_children() : 
-                _vbox.remove(_child)
-            # loop on detected webcams 
-            _rd_btn = None
-
-            for (_wbcm_idx, _webcam ) in \
-                    enumerate(webcam_obj.webcam_devices) :
-                _rd_btn = gtk.RadioButton(
-                        group =_rd_btn,
-                        label = _webcam["name"] )
-                _vbox.pack_start(_rd_btn)
-                _rd_btn.show()
-                
-                #connect event 
-                _rd_btn.connect(
-                        "clicked",
-                        self.on_webcam_radio_button_clicked,
-                        _wbcm_idx, 
-                        webcam_obj )
-                
-                # First set 
-                if _wbcm_idx == 0 :
-                    # select by default. 
-                    self.project_data['webcam_data'] = \
-                            webcam_obj.get_gst_best_input(_wbcm_idx) 
-            
-            self.label.set_text(_('Detected webcam(s)'))
-            _status = len(webcam_obj.webcam_devices)
-        else :
-            self.project_data['webcam_data'] = None
-            self.label.set_text(_('No webcam detected'))
-        self.label.show()
-        return _status
-    
-    def on_webcam_radio_button_clicked(self, widget, webcam_index, webcam_obj):
-        """ callback for webcam rasdio button.
-        Save info on selected webcam 
-        """
-        # when a webcam is selected select webcam data
-        self.project_data['webcam_data'] = \
-                webcam_obj.get_gst_best_input(webcam_index) 
-
         
-if __name__ == '__main__' :
-    import pygtk
-
-    def init_log() :
-        import os
-        from pitivi.log import log
-        enable_color = os.environ.get('PITIVI_DEBUG_NO_COLOR', '0') in ('', '0')
-        log.init('PITIVI_DEBUG', enable_color)
     
-    class Tester(Loggable) :
-
-        def __init__(self) :
-            Loggable.__init__(self)
-            window = gtk.Window()
-            window.connect('destroy', lambda w: gtk.main_quit())
-            self.debug(' starting App') 
-            _wdg = WebcamDetectionWidget(project_data = {})
-            _wdg.connect('webcams-detected',self._webcam_detected_cb) 
-            window.add(_wdg)
-            window.show_all()
-            
-            _wdg.prepare_webcam_detection()
-
-            return
-
-        def _webcam_detected_cb(self, widget, data = None):
-            self.debug('Rx webcam detected %s', data)
-
-    init_log()
-    Tester()
-    gtk.main()
-
 

=== modified file 'test/test_assistant_new_project.py'
--- test/test_assistant_new_project.py	2011-02-25 08:17:16 +0000
+++ test/test_assistant_new_project.py	2011-03-09 11:46:59 +0000
@@ -42,6 +42,7 @@
 # local application/library specific imports
 from common import init_log
 
+from pitivi.ui.viewer import PitiviViewer
 #tested module
 from luciole.gui.windows.assistant_new_project import AssistantNewProject
 
@@ -49,6 +50,7 @@
 PROJECT_PATH = '/home/nico/temp/testLuciole'
 
 class Tester(Loggable) :
+    """ Tester class """
 
     def __init__(self) :
         Loggable.__init__(self)
@@ -56,10 +58,13 @@
         gobject.threads_init() 
         window = gtk.Window()
         window.connect('destroy', lambda w: gtk.main_quit())
+        
+        self.ptv_viewer = PitiviViewer()
+        window.add(self.ptv_viewer)
         window.show_all()
         
         # start assistant
-        _ass =AssistantNewProject(self._apply_cb)
+        _ass =AssistantNewProject(self._apply_cb, self.ptv_viewer)
         self.prepare_assistant(_ass)
                
     def _apply_cb(self, project_data) :

=== modified file 'test/test_project_properties.py'
--- test/test_project_properties.py	2011-02-27 18:32:53 +0000
+++ test/test_project_properties.py	2011-03-09 11:46:59 +0000
@@ -22,12 +22,10 @@
 #
 #
 """
-test_assistant_new_project.py :    
-    GTK assistant for creation of new projects
+test_project_properties.py :    
+    Test project properties
 """
 # standard library imports
-import os.path
-import shutil
 
 # related third party imports
 import pygtk
@@ -41,11 +39,11 @@
 
 # local application/library specific imports
 from common import init_log
+from pitivi.ui.viewer import PitiviViewer
 
 #tested module
 from luciole.gui.windows.dialog_project_properties import ProjectProperties
 
-import gst
 
 CAPS_STR = ("video/x-raw-yuv, format=(fourcc)I420, width=(int)1280,"
             "height=(int)1024, interlaced=(boolean)false,"
@@ -63,7 +61,6 @@
         'v4ldriver': 'v4l2src', 
         'name': 'Built-in iSight'
             }, 
-    'project_name': 'test_luciole',
     'fpi': 5,
     'hardtype': 2,
     'resize' : 'no',
@@ -71,22 +68,36 @@
  }
 
 class Tester(Loggable) :
-
+    """ Tester class """
+    
     def __init__(self) :
         Loggable.__init__(self)
         self.debug('starting tester')
         gobject.threads_init() 
         window = gtk.Window()
         window.connect('destroy', lambda w: gtk.main_quit())
+        self.ptv_viewer = PitiviViewer()
+        window.add(self.ptv_viewer)
+        
         window.show_all()
         self.debug("project properties : %s", PROJECT_PROPS)
-        _properties = ProjectProperties(window, PROJECT_PROPS)
+        _properties = ProjectProperties(window, PROJECT_PROPS, self.ptv_viewer)
         _properties.connect('project-changed', self._project_modified_cb)
+        _properties.connect('dialog-closed', self._dialog_pp_closed_cb)
         _properties.run()
 
     def _project_modified_cb(self, gui, project_data) :
-        self.debug('received aplly cb -- project_data =%s ; %r %r', project_data, project_data, PROJECT_PROPS   )
-        
+        """ callback for modified data from project properties dialog """
+        self.debug( ("received aplly cb"
+                    "-- project_data =%s ; %r %r"),
+                    project_data, 
+                    project_data, 
+                    PROJECT_PROPS)
+    
+    def  _dialog_pp_closed_cb(self, dialog) :
+        """ dialog project properties closed callback """
+        self.debug('dialog closed')
+        gtk.main_quit()
 
 
 if __name__ == '__main__' :

=== added file 'test/test_webcam_detection_widget.py'
--- test/test_webcam_detection_widget.py	1970-01-01 00:00:00 +0000
+++ test/test_webcam_detection_widget.py	2011-03-09 11:46:59 +0000
@@ -0,0 +1,124 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -*- Mode: Python -*-
+# vim:si:ai:et:sw=4:sts=4:ts=4
+#
+# Copyright Nicolas Bertrand ([e-mail]), 2009-2010
+#
+# This file is part of Luciole.
+#
+#    Luciole is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Luciole is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Luciole.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+"""
+test_webcam_detection_widget.py :    
+    test webcam detection widget
+"""
+# standard library imports
+
+# related third party imports
+import pygtk
+pygtk.require('2.0')
+import gtk
+import gobject 
+import pygst
+pygst.require('0.10')
+
+from pitivi.log.loggable import Loggable
+from pitivi.action import ViewAction
+from pitivi.ui.viewer import PitiviViewer
+from pitivi.pipeline import Pipeline
+from pitivi.ui.viewer import PitiviViewer
+
+# local application/library specific imports
+from common import init_log
+
+#tested module
+from luciole.gui.windows.webcam_detection_widget import WebcamDetectionWidget
+from luciole.media.lgst.webcam_factory import WebcamSourceFactory
+
+class Tester(Loggable) :
+    """ Test class """
+
+    def __init__(self) :
+        Loggable.__init__(self)
+        self.debug('starting tester')
+        gobject.threads_init() 
+        self.wcam_params = {}
+        self.factory = None
+        
+        window = gtk.Window()
+        window.connect('destroy', lambda w: gtk.main_quit())
+        bbox = gtk.VBox()
+        boxalign = gtk.Alignment(xalign=0.5, yalign=0.5)
+        boxalign.add(bbox)
+
+        self.ptv_viewer = PitiviViewer()
+
+        # set webcam detection widget
+        self.project_data = {}
+        _wdg = WebcamDetectionWidget(self.project_data, self.ptv_viewer)
+        _wdg.connect('webcam-caps-selected', self._wcam_caps_selected)
+        _wdg.prepare_webcam_detection()
+        bbox.pack_start(_wdg)
+
+        bbox.pack_start(self.ptv_viewer, expand=False)
+
+        
+        window.add(boxalign)
+               
+        window.show_all()
+    
+    def _wcam_caps_selected(self, wdg ,caps) :
+        self.debug('received  webcam-caps-selected -- project_data =%s', 
+                caps )
+        
+        self.wcam_params['wcam_filter'] = {
+                'media_type' : caps,
+                }
+         
+        #self.prepare_viewer()
+
+    def prepare_viewer(self) :
+        viewer = self.ptv_viewer
+        if viewer.pipeline is not None :
+            try :
+                viewer.pause()
+            except :
+                pass
+        self.factory = WebcamSourceFactory()
+        self.factory.webcam_params =  self.wcam_params
+        self.factory.with_scale = False
+
+        pipeline = Pipeline()
+        action = ViewAction()
+        action.addProducers(self.factory)
+        viewer.setPipeline(None)
+        viewer.showSlider()
+        
+        # FIXME: why do I have to call viewer.setAction ?
+        viewer.setAction(action)
+        viewer.setPipeline(pipeline)
+        viewer.play()
+        
+        return False
+
+
+
+if __name__ == '__main__' :
+    init_log()
+    Tester()
+    gtk.main()
+
+