new ScribusUtils release, this script now handle call to ScribusUtils.py methods

git-svn-id: https://svn.erp5.org/repos/public/erp5/trunk@8346 20353a03-c40f-0410-a6d1-a30d3c3de9de

product/ERP5Form/Extensions/ERP5Site_createModuleScribus.py

-# This code is to be removed in near future, because we will migrate
-# to a Python Script. This is put temporarily for a demo.
-
 def ERP5Site_createModuleScribus(self, form_id=None, module_portal_type=None,
         portal_skins_folder=None, object_portal_type=None, object_title=None, module_id=None,
         module_title=None, selection_index=None, selection_name=None, import_scribus_file=None,
@@ -9,666 +6,335 @@ def ERP5Site_createModuleScribus(self, form_id=None, module_portal_type=None,
   """ Creates a module, portal_type and ERP5Form from a scribus and
       PDFForm file"""
   context = self
-  from Products.Formulator.Errors import ValidationError, FormValidationError
   
-  from Products.ERP5Form.ScribusUtils import ScribusParser
-  ScribusParser = ScribusParser()
   
+  # IMPORTING MODULES
+  from Products.Formulator.Errors import ValidationError, FormValidationError
+  from Products.ERP5Form.ScribusUtils import ScribusParser
+  from Products.ERP5Form.ScribusUtils import ManageModule
+  from Products.ERP5Form.ScribusUtils import ManageFiles
+  from Products.ERP5Form.ScribusUtils import ManageCSS
   from Products.ERP5Form.CreatePropertySheet import LocalGenerator
-  generator = LocalGenerator()
-
   # importing module to get an access to the 'searchFolder' method
   # needed to be able to list the objects in 'list_object_view' form
   from Products.ERP5.ERP5Site import ERP5Site
-  
   from zLOG import LOG
 
-  #import Products.ERP5Form.Folder
-  # TODO
-  #   - Allow in the module only the new document, we must activate the filter
-  #   - handle an optionnal "description" parameter
-  #   - set the form action to "Base_edit"
-  #   - print : pdf
-  #   - export : xml
-  #   - report : last modified
-  #   - security : 5A
+  # CREATING MODULES INSTANCES
+  ScribusParser = ScribusParser()
+  ManageModule = ManageModule()
+  ManageFiles = ManageFiles()
+  ManageCSS = ManageCSS()
+  generator = LocalGenerator()
+
+  import pdb
+  pdb.set_trace()
+
+  # DECLARING VARIABLES
+  def_lineNumberInList = 20
+  def_colorRequired = 'rgb(192,192,255)'
+  def_colorRequiredError = 'rgb(128,128,255)'
+  def_color = '#F6FFFF'
+  def_colorError = 'rgb(255,64,64)'
   
 
+
+  # recovering objects
   portal = context.getPortalObject()
   portal_types = portal.portal_types
   object_portal_type_id = object_portal_type
 
 
+  # DECLARING NAMES
+  # declaring names for ERP5 objects, such as Form, DTML Document, etc.
+  # these names are stored in a dict (object_names)
+  object_names = ManageModule.setObjectNames(object_portal_type_id,
+                                             object_title)
   
-  # Create a new portal_type for the module
-  #
-  portal_types.manage_addTypeInformation( 'ERP5 Type Information'
-                                        , typeinfo_name = 'ERP5Type: ERP5 Folder'
-                                        , id            = module_portal_type
-                                        )
-  module_portal_type_value = portal_types[module_portal_type]
-
-
-  # Set allowed content types
-  module_portal_type_value.allowed_content_types = (object_portal_type_id, )
-  module_portal_type_value.filter_content_types  = 1
-  # building a list of all the portal_type actions
-  action_list = module_portal_type_value.listActions()
-  # cleaning all portal_type informations
-  module_portal_type_value.deleteActions(selections=range(0, len(action_list)))
-  # declaring form names
-  form_view_pdf = object_portal_type_id.replace(' ','') + '_view' +\
-                  object_portal_type_id.replace(' ','') + 'AsPdf'
-  form_view_list = object_title.replace(' ','') + 'Module_view' +\
-                   object_portal_type_id.replace(' ','') + 'List'
-  # declaring css dtml name
-  form_css_id = object_portal_type_id.replace(' ','') + '.css'
-
- 
-  # Parameters to addAction : id, name, action, condition, permission,
-  # category, visible=1, REQUEST=None
-  module_portal_type_value.addAction( "view"
-                                    , "View"
-                                    , "string:${object_url}/%s"%form_view_list
-                                    , ""
-                                    , "View"
-                                    , "object_view"
-                                    )
   
-  # SKIN PROCESSING
-  # Create the skin directory if does not exist yet
-  portal_skins_folder_name = portal_skins_folder
-  portal_skins = portal.portal_skins
-  if not portal_skins_folder_name in portal.portal_skins.objectIds():
-    portal_skins.manage_addFolder(portal_skins_folder_name)
-  skin_folder = portal.portal_skins[portal_skins_folder_name]
-  # Add new folders into skin paths.
-  for skin_name, selection in portal_skins.getSkinPaths():
-    selection = selection.split(',')
-    if portal_skins_folder_name not in selection:
-      new_selection = [portal_skins_folder_name,]
-      new_selection.extend(selection)
-      portal_skins.manage_skinLayers( skinpath = tuple(new_selection)
-                                    , skinname = skin_name
-                                    , add_skin = 1
+  # CREATING NEW PORTAL TYPE FOR THE MODULE
+  # Manage the creation of a ne portal_type for the module
+  # (module is not saved for the moment, but properties can be
+  # updated)
+  ManageModule.setModulePortalType(portal_types,
+                                   object_portal_type_id,
+                                   module_portal_type,
+                                   object_names
                                   )
 
-  # ERP FORM PROCESSING
-  # Create the default ERP5 Form in order to view the objects
-  form_view_id = object_portal_type_id.replace(' ','') + '_view'
+  # PROCESSING SKIN FOLDER
+  # Process and create if necessary the skins_folder defined by the user.
+  # return the skin_folder object
+  skin_folder = ManageModule.setSkinFolder(portal,
+                                           portal_skins_folder)
+      
+      
+  # ERP FORM LIST PROCESSING
+  # Create ERP5 Form in order to view the module
+  # set up the factory based on skin_folder
   factory = skin_folder.manage_addProduct['ERP5Form']
-  factory.addERP5Form( form_view_id
-                     , title  = object_title
-                     )
-  form_view_id_object = skin_folder[form_view_id]
-  #if option_html != None :
-  #  form_view_id_object.rename_group('Default')
-  #form_view_id_object.rename_group('Default', 'left')
-  if option_html != 1:
-    # using default ERP5 positioning convention
-    # creating groups
-    form_view_id_object.rename_group('Default','left')
-    default_groups = ['right', 'center', 'bottom', 'hidden']
-    for group in default_groups:
-      form_view_id_object.add_group(group)
-  # page groups corresponding to graphic view are defined on the flyn
-  # when parsing pages to get fields.
-  # default field will be removed at the end
-  
-    
-    
-  # Define CSS file and object informations
-  # first CSS file name
-  form_css_id = object_portal_type_id.replace(' ','') + '_css.css'
-  # then CSS content object (string)
+  
+  # run the factory to create the new object (ERP5Form)
+  ManageFiles.setERP5Form(factory,
+                          str(object_names['view_list']),
+                          str(object_title + ' Module View'))
+  
+  # manage the module form and set up the list inside
+  # update form properties with generic module values
+  # and implement the objects' listing inside the form
+  ManageModule.setModuleForm(object_title,
+                             skin_folder,
+                             object_names['view_list'],
+                             module_title,
+                             module_id,
+                             def_lineNumberInList)
+                             
+
+  # INIT ATTRIBUTES DICT
+  # global_properties is a special dict destinated to
+  # keep all the field and page data safe during the
+  # parsing, allowing them to be updated when needed
+  # and used if necessary.
+  global_properties = ScribusParser.initFieldDict()
+
+  
+  # PARSER VARIABLES DECLARATION
+  # the following variable will recover the final CSS
+  # file's content object (string) before saving it
+  # onto the hard disk
   form_css_content = ""
-  #properties_css_dict is used to store class informations
+  # properties_css_dict is used to store class informations
   properties_css_dict = {}
+  # init page number
+  page_number_int = 0
 
-  # Create Module ERP5 Form in order to view the module
-  object_title_view = object_title + ' Module View'
-  factory = skin_folder.manage_addProduct['ERP5Form']
-  factory.addERP5Form( form_view_list
-                     , title  = object_title_view
-                     )   
-  form_view_list_object = skin_folder[form_view_list]
-
-  form_list_id = form_view_list_object.id
-  form_list = form_view_list_object.restrictedTraverse(form_list_id)
-  #defining groups for objects listing
-  form_view_list_object.rename_group('Default', 'left')
-  default_groups = ['right', 'center', 'bottom', 'hidden']
-  # adding groups
-  for group in default_groups:
-    form_view_list_object.add_group(group)
-
-  title_module = ''
-  for word in module_title.split():
-    title_module += str(word.capitalize() + ' ')
-    
-  # Add ListBox Field to list the created objects
-  id = 'listbox'
-  title = title_module
-  field_type = 'ListBox'
-  form_view_list_object.manage_addField(id, title, field_type)
-   
-  # manage ListBox settings
-  values_settings = {}
-  values_settings['pt'] = "form_list"
-  values_settings['action'] = "Base_doSelect"
-  
-  # set the form settings
-  for key, value in values_settings.items():
-    setattr(form_view_list_object, key, value)
-  
-  # manage edit property of ListBox
-  field_attributes = getattr(form_view_list_object, id)
-  field_attributes.values['lines'] = 20
-  # adding field columns
-  field_attributes.values['columns'] = [('id', 'ID'), ('title', 'Title'), ('description', 'Description')]
-  field_attributes.values['list_action'] = 'list'
-  field_attributes.values['search'] = 1
-  field_attributes.values['select'] = 1
-  field_attributes.values['selection_name'] = '%s_selection' % module_id
-  # adding 'list_method' to be able to list the objects of a folder
-  # WARNING : this field does not contains the name of the method (as
-  # a string instance) but the method itself (as method instance)
-  list_method = getattr(ERP5Site,'searchFolder')
-  # a stange BUG occurs when saving method in field_attributes
-  # method adress is well get and saved in the listField
-  # but crashing when registrering new portal type inside
-  # erp5... I do not know why !
-  #field_attributes.values['list_method'] = list_method
-  print "METHOD : name = %s" % list_method.__name__
-  print "METHOD : type = %s" % list_method.__class__
-  print "METHOD : doc  = %s" % list_method.__doc__
-  
-  form_id = form_view_id_object.id
-  form = form_view_id_object.restrictedTraverse(form_id)
-
-  # import and manage Scribus File
-  xml_string = ScribusParser.getContentFile(import_scribus_file)
 
-  page_number_int = 0
+  # import scribus file
+  # take the input ScribusFile and read the content
+  xml_string = ScribusParser.getContentFile(import_scribus_file)
   
   if xml_string == None:
     LOG("ScribusParser",1,"Scribus file is empty !")
     print "no field was defined in the Scribus file"
     pass
   else:
-    # get properties from Scribus File
+    
+    # GETTING FULL SCRIBUS DOCUMENT PROPERTIES
+    # get string from ScribusFile content
     output_string = str(xml_string)
     
-    #getting page objects with their attributes
-    #LOG("ScribusParser",0,"getXmlObjectProperties...")
-    print " createmodule > ScribusParser.getXmlObjectProperties"
-    text_field_list = ScribusParser.getXmlObjectsProperties(xml_string)
-    print " createmodule < ScribusParser.getXmlObjectProperties\n"
     
-    #splitting tooltip-text to recover usefull attributes
-    #LOG("ScribusParser",0,"getPropertiesConversion...")
-    print " createmodule > ScribusParser.getPropertiesConversion"
-    widget_properties = ScribusParser.getPropertiesConversion(text_field_list)
-    print " createmodule < ScribusParser.getPropertiesConversion\n"
+    print " createmodule > ScribusParser.getXmlObjectPropertiesDict"
+    # building a tree from the output string elaborated from the
+    # original Scribus file.
+    # create a list of pages containing a dict of all the page_objects
+    # elements with their attributes 'as they are' (so without any check
+    # for data integrity or unuseful values).
+    # This procedure already makes a selection of parameters and take all the
+    # unnecessary page_objects off.
+    #import pdb
+    #pdb.set_trace()
+    (text_field_list,keep_page,page_gap) = ScribusParser.getXmlObjectsPropertiesDict(xml_string)
+    print " createmodule < ScribusParser.getXmlObjectPropertiesDict\n"
+    
+    
+    print " createmodule > ScribusParser.getPropertiesConversionDict"
+    # parsing text_field_list created from the getXmlObjectsPropertiesDict
+    # to extract all the usefull properties and organize elements. Then check
+    # attributes to get properties values.
+    # This represents the main process of the script.
+    widget_properties = ScribusParser.getPropertiesConversionDict(text_field_list)
+    print " createmodule < ScribusParser.getPropertiesConversionDict\n"
+    
+
+    # testing if final rendering is PDF-like
+    if option_html ==1 :
+      print " createmodule > generating background"
+      ## BACKGROUND GENERATOR
+      # extract background pictures from the PDF document, convert them in the right
+      # format (JPG) and add them to the skin folder as Image objects.
+      # used only with option_html == 1
+      # recover image_size
+      image_size = ManageFiles.setBackgroundPictures(import_pdf_file,
+                                        object_names,
+                                        skin_folder)
+      page_height, page_width = image_size
+      print "   height = " + str(page_height)
+      print "   width = " + str(page_width)
+      print " createmodule < background generated\n"    
+      
       
     # add field from OrderedWidgetProperties in ERP5 Module created
-    radiofield_widget_properties = {}
+    # radiofield_widget_properties = {}
     position = {}
-    
-    # personal_properties is used to create PropertySheet
+    # personal_properties_list is used to create PropertySheet
     personal_properties_list = []
-    page_number_int = len(widget_properties)
-
-    # declaring dicts used to generate CSS file
-    # css_page is a class container. each class is composed in the css_page
-    # before being saved in a css_dict
-    properties_css_page = {}
-    # css_dict_head contains all the 'global' class, reffering to PAGE
-    properties_css_dict_head = {}
-    # css_dict_standard contains all the fields classes, when no error occurs
-    properties_css_dict_standard = {}
-    # css_dict_error contains the same thing, but in case error occurs.
-    # there background is different so that users can see where the problem
-    # is on the graphic view
-    properties_css_dict_error = {}
-    # css_dict_err_d contains coordinates and color to display text-error
-    properties_css_dict_err_d = {}
-
-    # declaring page size
-    # FIXME : this value has to be taken from the image size or the document size.
-    # to be dynamicly set
-    page_height = 850
-    page_width = 610
-
-    # DO NOT WORK !
-    # print "opening image"
-    # page_image = Image.open(import_image_1)
-    # print "getting properties"
-    # page_image_properties = page_image.size
-    # print page_image_properties
-    # print " getting width"
-    # page_width = int(page_image_properties[1])
-    # page_height = int(page_image_properties[0])
+    # recovering number of pages
+    global_properties['page'] = len(widget_properties)  
+    
+    
+    
+    # CSS FILE INIT
+    # init the CSS dict by creating sub-dicts to store various information
+    # i.e : 'head', 'standard' ,'error', etc.
+    # these sub-dicts are stored in the properties_css_dict
+    properties_css_dict = ManageCSS.setInit()
+
        
+    
+    # BEGINING DATA INTERPRETATION
     LOG("ScribusParser",0,"begining interpretation of data")
     print " createmodule > begining data interpretation"
     #iterating pages
-    for page_iterator in range(len(widget_properties)):
+    #print "   %s" % int(global_properties['page'])
+    for page_iterator in range(int(global_properties['page'])):
       page_number = str(page_iterator)
       page_content = widget_properties[page_number]
       page_id = "page_" + page_number
       
+      
+      
       if option_html == 1:
-        # Processing current page for CSS data
-        # getting properties
-        properties_css_page = {}
-        properties_css_page['position'] = 'relative'
-        if page_iterator == 0:
-          properties_css_page['margin-top'] = "0px"
-        else:
-          properties_css_page['margin-top']= "%spx" % (page_height + 20)
-        # adding properties dict to golbal dict
-        properties_css_dict_head[page_id] = properties_css_page
-
-        # creating image class for background
-        properties_css_background = {}
-        # making background id
-        properties_css_background_id =  page_id + '_background'
-        #getting properties
-        properties_css_background['position'] = 'absolute'
-        properties_css_dict_head[properties_css_background_id] = properties_css_background
-
-        #creating corresponding page group to form
-        if page_number == '0':
-          # if first page, renaming 'default' group into 0 group
-          form_view_id_object.rename_group('Default',page_id)
-          print "   > renamed 'default' group to %s" % page_id
-        else :
-          # adding bandt new group for page
-          form_view_id_object.add_group(page_id)
-          print "   > added new group %s " % page_id
-      
-      #iterating pageobjects in page
+        # CSS PAGE DEFINITION (PAGE AND BACKGROUND IMAGE)
+        # get CSS class properties relative to the actual page
+        # (background picture position, picture size, etc.)
+        # and add them to the css dict
+        properties_css_dict = ManageCSS.setPageProperties(
+                                   properties_css_dict,
+                                   page_iterator,
+                                   page_id,
+                                   page_height)
+        
+       
+      
+          
+          
+      # RESUME DATA INTERPRETATION
+      # iterating pageobjects in page
       for index in range(len(page_content)):
         (id, properties_field) = page_content[index]
-                        
+        # testing each page_content              
         if properties_field.has_key('type'):
-          field_type = str(properties_field['type'])
-          title = str(properties_field['title'])
-          form_view_id_object.manage_addField(id, title, field_type)
-  
-          context = skin_folder[form_view_id]
-          form_id = context.id
           
           if option_html ==1:
-            # Processing object for CSS data
-            #declaring dict containing all css data
-            # _stand for general display
-            properties_css_object_stand = {}
-            # _error when an error occurs
-            properties_css_object_error = {}
-            # _err_d to diplay the text error
-            properties_css_object_err_d = {}
-            #defining global properties
-            properties_css_object_stand['position'] = 'absolute'
-            properties_css_object_error['position'] = 'absolute'
-            properties_css_object_err_d['position'] = 'absolute'
-            properties_css_object_stand['padding'] = '0px'
-            properties_css_object_error['padding'] = '0px'
-            properties_css_object_err_d['padding'] = '0px'
-            #getting position and size
-            properties_css_object_stand['width'] = str(properties_field['size_x']) + 'px'
-            properties_css_object_error['width'] = str(properties_field['size_x']) + 'px'
-            properties_css_object_stand['height'] = str(properties_field['size_y']) + 'px'
-            properties_css_object_error['height'] = str(properties_field['size_y']) + 'px'
-            properties_css_object_stand['margin-left'] = str(properties_field['position_x']) + 'px'
-            properties_css_object_error['margin-left'] = str(properties_field['position_x']) + 'px'
-            properties_css_object_err_d['margin-left'] = str(page_width + 20 ) + 'px'
-            properties_css_object_stand['margin-top'] = str(properties_field['position_y']) + 'px'
-            properties_css_object_error['margin-top'] = str(properties_field['position_y']) + 'px'
-            properties_css_object_err_d['margin-top'] = str(properties_field['position_y']) + 'px'
-            # adding special text_color for text error
-            properties_css_object_err_d['color'] = 'rgb(255,0,0)'
-            # adding properties to relatives dicts
-            properties_css_dict_standard[id] = properties_css_object_stand
-            properties_css_dict_error[id] = properties_css_object_error
-            properties_css_dict_err_d[id] = properties_css_object_err_d
-            # then getting additional properties
-            if properties_field['required'] ==1:
-              # field is required: using special color
-              # color is specified as light-blue when standard
-              # color = 'green' when error
-              properties_css_dict_standard[id]['background'] = 'rgb(192,192,255)'
-              properties_css_dict_error[id]['background'] = 'rgb(128,128,255)'
-            else:
-              properties_css_dict_standard[id]['background'] = '#F6FFFF'
-              properties_css_dict_error[id]['background'] = 'rgb(255,64,64)'
-          
-            #adding field to the corresponding page group
-            position[id] = page_id
-            form_view_id_object.move_field_group(id,'page_0',position[id])
-            #print "    > added %s to %s (graphic mode) " % (id,position[id])
-            #print properties_css_dict_error[id]['background'] 
-            #print properties_css_dict_standard[id]['background']
-          else:
-            # no graphic view
-            # position is defined corresponding to ERP5 view
-            position[id] = properties_field['order']
-            form_view_id_object.move_field_group(id,'left',position[id])
-            #print "    > added %s to %s (ERP mode)" % (id,position[id])
-          
-          # modify value of property
-          form = context.restrictedTraverse(form_id)
-          field_attributes = getattr(form, id)
-          
-          type = 'string'
-  
-          if field_type == 'DateTimeField':
-            type = 'date'
-            field_attributes.values['input_order'] = properties_field['input_order']
-            field_attributes.values['date_only'] = properties_field['date_only']
-            field_attributes.values['required'] = properties_field['required']
-  
-          elif field_type == 'RelationStringField':
-            portal_type_item = properties_field['portal_type'].capitalize()
-            field_attributes.values['portal_type'] = [(portal_type_item, portal_type_item)]
-            field_attributes.values['base_category'] = properties_field['base_category']
-            field_attributes.values['catalog_index'] = properties_field['catalog_index']
-            field_attributes.values['default_module'] = properties_field['default_module']
-          
-          elif field_type == 'RadioField':
-            radiofield_widget_properties[id] = {'description' : ''}
-            items = []
-            for word_item in properties_field['items'].split('|'):
-              items.append((word_item, word_item.capitalize()))
-  
-            field_attributes.values['items'] = items
-
-          elif field_type in ['StringField','IntegerField','Floatfield']:
-            field_attributes.values['maximum_input'] = properties_field['maximum_input']
-            #print "   => saved 'maximum_input' value"
-          
-          # check that the property is local ...
-          if id.startswith('my') and not (
-              # ... and not in black list
-              # FIXME: this list must be configurable outside this script
-                    id.startswith('my_source') or 
-                    id.startswith('my_destination') or
-                    id in ('my_start_date', 'my_stop_date') ) :
-            personal_properties = { 'id' : id[3:],
-                                    'description' : '',
-                                    'type' : type,
-                                    'mode': 'w' }
-
-            personal_properties_list.append(personal_properties)
-
-    # adding 'page_end' class to add a div at the end of the last page
-    # in order to display the full last page under Konqueror
-    properties_css_page = {}
-    properties_css_page['position'] = 'relative'
-    properties_css_page['margin-top'] = "%spx" % str( page_height)
-    properties_css_dict_head['page_end'] = properties_css_page
-    print " createmodule < end of data interpretation"
-    print "\n"
-
-
-    # CSS CLASS
-    if option_html ==1:
-      print " createmodule > printing output from css_class_generator"
-      form_css_content =  "/*-- special css form generated through ScribusUtils module     --*/"
-      form_css_content += "/*-- to have a graphic rendering with 'form_html' page template --*/\n"
-      form_css_content += "/* head : classes declared for general purpose */\n"
-      # iterating classes in document's head
-      for class_name in properties_css_dict_head.keys():
-        # getting class properties_dict
-        class_properties = properties_css_dict_head[class_name]
-        # joining exerything
-        output_string = "." + str(class_name) + " {" \
-                        + "; ".join(["%s:%s" % (id, val) for id, val in class_properties.items()]) \
-                        + "}"
-        # adding current line to css_content_object
-        form_css_content += output_string + "\n"
-      form_css_content += "\n/* standard field classes */ \n"
-      # adding standard classes
-      for class_name in properties_css_dict_standard.keys():
-        class_properties = properties_css_dict_standard[class_name]
-        output_string = "." + str(class_name) + " {" \
-                        + "; ".join(["%s:%s" % (id,val) for id,val in class_properties.items()]) \
-                        + "}"
-        form_css_content += output_string + "\n"
-      form_css_content += "\n/* error field classes */\n"
-      #adding error classes
-      for class_name in properties_css_dict_error.keys():
-        class_properties = properties_css_dict_error[class_name]
-        output_string = "." + str(class_name) + "_error {" \
-                        + "; ".join(["%s:%s" % (id,val) for id, val in class_properties.items()]) \
-                        + "}"
-        form_css_content += output_string + "\n"
-      form_css_content += "\n/* text_error field classes */ \n"
-      # adding field error classes
-      for class_name in properties_css_dict_err_d.keys():
-        class_properties = properties_css_dict_err_d[class_name]
-        output_string = "." + str(class_name) + "_error_display {" \
-                        + "; ".join(["%s:%s" % (id,val) for id,val in class_properties.items()]) \
-                        + "}"
-        form_css_content += output_string + "\n"
-    
-      #print form_css_content
-      print " createmodule < end output \n"
-    
-      print " createmodule > creating output CSS file"
-      factory.addDTMLDocument(form_css_id,"css",form_css_content)
-      print " createmodule < CSS file creation\n"
-
-
-  print " createmodule > managing Form settings"
-  # manage global form settings
-  values = {}
-  values['title'] = str(object_portal_type)
-  values['row_length'] = 4
-  values['name'] = str(form_view_id)
-  # the 'pt' field has to be changed from 'form_view' to 'form_html'
-  # when generating graphic interface.
+            # CSS FIELD PROPERTIES
+            # get CSS class properties related to the actual page_object
+            # in the page (position, size, color, etc.) and add them to
+            # the css_dict
+            properties_css_dict = ManageCSS.setFieldProperties(
+                                           properties_css_dict,
+                                           page_content[index],
+                                           page_width,
+					   page_height,
+					   page_iterator,
+					   page_gap,
+					   keep_page)
+
+          # recover useful page_object attributes from scribus dict
+          # to be able to create and update correctly the fields
+          # composing the form
+          ScribusParser.getFieldAttributes(page_content[index],
+                                           option_html,
+                                           page_id,
+                                           global_properties)
+          
+    # CSS CLASS (generateOutputContent)
     if option_html ==1:
-    values['pt'] = "form_html"
-  else:
-    values['pt'] = "form_view"
-  values['action'] = "Base_edit"
-  values['update_action'] = ""
-  values['method'] = 'POST'
-  values['enctype'] = 'multipart/form-data'
-  values['encoding'] = "UTF-8"
-  values['stored_encoding'] = 'UTF-8'
-  values['unicode_mode'] = 0
-  # set the form settings
-  for key, value in values.items():
-    setattr(form, key, value)
-  print " createmodule < settings managed\n"
 
+      # add last properties to css dict, including implementation
+      # of a n+1 page to prevent bug when rendering under Konqueror
+      ManageCSS.setFinalProperties(properties_css_dict,page_height)
 
+      # generate output string from dict
+      form_css_content = ManageCSS.generateOutputContent(properties_css_dict)
 
-  print " createmodule > managing PDF settings"
-  # Import and manage PDF File before filling of default TALES expressions in cells
-  # first import the PDFForm in the skin folder
-  factory.addPDFForm(form_view_pdf, object_title, pdf_file = import_pdf_file)
-
-  
-  for c in skin_folder.objectValues():
-
-    if c.getId() == form_view_pdf :
-      print "    %s selected" % c.getId()
-      cell_name_list = c.getCellNames()
-      print "      %s" % cell_name_list
-      for cell_name in cell_name_list:
-        if cell_name[0:3] == 'my_':
-          cellName_list = []
-          for word in cell_name[3:].split('_'):
-            word = word.capitalize()
-            cellName_list.append(word)
-          if cellName_list[-1] == 'List' :
-            TALES = 'python: ", ".join(here.get' + "".join(cellName_list) + '())'
-          else :
-            TALES = 'python: here.get' + "".join(cellName_list) + '()'
-          print "      cell : %s => TALES expression : %s " % (cell_name,TALES)
-          c.setCellTALES(cell_name, TALES)
-  print " createmodule < PDF settings managed\n"
+      # save CSS string content into ERP5
+      ManageFiles.setCSSFile(factory,object_names['css'],form_css_content)
 
 
 
 
-  print " createmodule > importing background pictures"
-  # Import and register background images for HTML display
-  if option_html == 1:
+  # CREATING OBJECT FORM AND MANAGING GROUPS
+  print " createmodule > generate fields in ERP Form"
+  # CREATING ERP5 OBJECT FORM
+  # create ERP5 Form to handle object view
+  ManageFiles.setERP5Form(factory,
+                          object_names['view_id'],
+                          object_title)
+
+  # update Form groups to have right number of groups with
+  # corresponding names (depending on the kind of display)
+  default_groups = ManageModule.setObjectForm(skin_folder,
+                                              object_names,
+                                              option_html,
+                                              global_properties,
+                                              object_portal_type)
+
+  # create fields corresponding to the page_objects
+  # recovered from the scribus file
+  ManageModule.setFieldsInObjectForm(skin_folder,
+                                     object_names,
+                                     default_groups,
+                                     global_properties,
+                                     option_html
+                                     )
+  print " createmodue < fields created in ERP5 Form\n"
+
                                      
-    # saving pdf content to aspecific file on hard disk
-    temp_pdf = open('/tmp/ScribusUtilsTempPDF.tmp','w')
-    # moving cursor to begining of file
-    import_pdf_file.seek(0)
-    # reading content
-    temp_content = import_pdf_file.read()
-    print "    > inputfile read : %sb" % len(temp_content)
-    # writing content to outputfile
-    temp_pdf.write(temp_content)
-    print "    > inputfile written"
-    # closing outputfile
-    temp_pdf.close()
-
-    # running first conversion from PDF to PPM
-    import commands
-    result = commands.getstatusoutput('pdftoppm -r 72 /tmp/ScribusUtilsTempPDF.tmp /tmp/ScribusUtilsTempPPM')
-    print "    > pdftoppm result(%s) : %s" % (result[0],result[1])
-
-    # running second conversion from PPM to JPEG
-    result = commands.getstatusoutput('convert /tmp/ScribusUtilsTempPPM* jpg:/tmp/ScribusUtilsTempJPG')
-    print "    > convert result(%s) : %s" % (result[0],result[1])
-
-    # getting list of resulting pictures
-    result = commands.getstatusoutput('ls /tmp/ | grep ScribusUtilsTempJPG')
-    print "    > getting list of final pictures"
-
-    image_number = 0
-    for image in result[1].split('\n'):
-      # result[1] contains the output string
-      # splitting this output string in lines to get
-      # the string parameters
-      
-      # opening resulting pictures
-      temp_jpg = open('/tmp/%s' % image,'r')
-      print "    > open picture : len=%sb" % len(temp_jpg.read())
-
-      # saving content to zope folder
-      form_page_id = object_portal_type_id.replace(' ','')+ "_background_" + str(image_number)
-      add_image = skin_folder.manage_addProduct['OFSP'].manage_addImage
-      add_image(form_page_id,temp_jpg,"background image")
-
-      # incrementing image number before going to next one
-      image_number +=1
-
-    # deleting temporary files
-    result = commands.getstatusoutput('rm -f /tmp/ScribusUtilsTemp*')
-    print "    > remove temp files"
-    
-    #factory = skin_folder.manage_addProduct['Images']
-    """
-    if page_number_int > 0 :
-      # image specified for first page_element
-      form_page_id = object_portal_type_id.replace(' ','') + "_background_" + "0"
-      add_image = skin_folder.manage_addProduct['OFSP'].manage_addImage
-      add_image(form_page_id,import_image_1,"background image")
-    if page_number_int > 1 :
-      form_page_id = object_portal_type_id.replace(' ','') + "_background_" + "1"
-      add_image = skin_folder.manage_addProduct['OFSP'].manage_addImage
-      add_image(form_page_id,import_image_2,"background image 2")
-    if page_number_int > 2:
-      form_page_id = object_portal_type_id.replace(' ','') + "_background_" + "2"
-      add_image = skin_folder.manage_addProduct['OFSP'].manage_addImage
-      add_image(form_page_id,import_image_3,"background image 3")
-    """
-  print " createmodule < background pictures imported\n"
-
-  # get background picture size.
-  #skin_folder
-
-
-
-  # Create PropertySheet and Document
+                                     
+  # PDF IMPORTATION AND TALES GENERATION
+  print " createmodule > managing PDF settings"
+  # read all the content of the PDF document and save it in the skin_folder
+  # as a PDFForm. then iterate the fields to get the corresponding TALES
+  # expressions and save them in the PDFForm.
+  ManageFiles.setPDFForm(factory,
+                         skin_folder,
+                         object_names,
+                         object_title,
+                         pdf_file = import_pdf_file
+                         )
+  print " createmodule < PDF settings managed\n"
+  
+
+
+  # PROPERTYSHEET AND DOCUMENT CREATION
   print " createmodule > PropertySheet and Document creation"
-  name_file = ''
-  title_module = ''
-  for word in object_portal_type.split():
-    name_file += word.capitalize()
-    title_module += str(word.capitalize() + ' ')
-    
-  generator.generateLocalPropertySheet(name_file, personal_properties_list)
-  print "   PropertySheet : %s" % name_file
-  generator.generateLocalDocument(name_file, object_portal_type)
-  print "   Document : %s" % name_file
-  
-  # Reload register local property sheets
+  # recover personal properties and save them in a PropertySheet
+  # then create the Document related to the object
+  ManageFiles.setPropertySheetAndDocument(global_properties,
+                                          object_portal_type,
+                                          generator,
+                                          skin_folder,
+                                          object_names)
+  # as new document and PropertySheet are created, it is needed to reload the
+  # registry.
   from Products.ERP5Type.Utils import initializeLocalPropertySheetRegistry
   initializeLocalPropertySheetRegistry()
-
-  # Reload register local classes
   from Products.ERP5Type.Utils import initializeLocalDocumentRegistry
   initializeLocalDocumentRegistry()
-  print " createmodule < PropertyShett and Document imported\n"
-  
-
-
-  
-  # Then add the portal_type corresponding to the new object
-  typeinfo_name_ERP5Type = str('ERP5Type: ERP5 ' + object_portal_type)
-  #context.log("typeinfo_name_ERP5Type", typeinfo_name_ERP5Type)
-  #context.log("object_portal_type_id", object_portal_type_id)
-  portal_types.manage_addTypeInformation(
-                    'ERP5 Type Information'
-                  , typeinfo_name = typeinfo_name_ERP5Type
-                  , id            = object_portal_type_id)
-
-  object_portal_type_value = portal_types[object_portal_type_id]
-  # Set default actions
-  action_list = object_portal_type_value.listActions()
-  object_portal_type_value.deleteActions(
-                  selections=range(0, len(action_list)))
-  # parameters to addAction : id, name, action, condition, permission,
-  # category, visible=1, REQUEST=None
-  object_portal_type_value.addAction( "view"
-                                    , "View"
-                                    , "string:${object_url}/%s" % form_view_id
-                                    , ""
-                                    , "View"
-                                    , "object_view"
-                                    )
-  object_portal_type_value.addAction( "print"
-                                    , "Print"
-                                    , "string:${object_url}/%s" % form_view_pdf
-                                    , ""
-                                    , "View"
-                                    , "object_print"
-                                    )
-  object_portal_type_value.addAction( "metadata"
-                                    , "Metadata"
-                                    , "string:${object_url}/Base_viewMetadata"
-                                    , ""
-                                    , "Manage properties"
-                                    , "object_view"
-                                    )
+  print " createmodule < PropertySheet and Document imported\n"
+  
+  
+  
 
-  object_portal_type_value.addAction( "history"
-                                    , "History"
-                                    , "string:${object_url}/Base_viewHistory"
-                                    , ""
-                                    , "Manage properties"
-                                    , "object_view"
+  # OBJECT PORTAL TYPE
+  # create PortalType for the object
+  ManageModule.setObjectPortalType(portal_types,
+                                   object_portal_type_id,
+                                   object_portal_type,
+                                   object_names
                                    )
 
+                                   
+  
   # Finally add the module to the site
-  portal.newContent( id          = str(module_id)
-                   , portal_type = str(module_portal_type)
-                   , title       = title_module
-                   )
+  ManageModule.registerModule(portal,
+                              module_id,
+                              module_portal_type,
+                              object_portal_type)
 
 
+  # manage redirection URL
   if not selection_index:
     redirect_url = '%s/view?%s' % ( portal.absolute_url()
                                 , 'portal_status_message=Module+Created.'
@@ -681,5 +347,5 @@ def ERP5Site_createModuleScribus(self, form_id=None, module_portal_type=None,
                             , 'portal_status_message=Module+Created.'
                             )
 
-
+  # redirect
   portal.REQUEST.RESPONSE.redirect( redirect_url )