Added a new system for layouting production-ready forms without any HTML coding, many performance improvements and more independence towards Archetypes.

bin/job.py

@@ -1,17 +1,21 @@
 '''job.py must be executed by a "zopectl run" command and, as single arg,
    must get a string with the following format:
 
-    <ZopeAdmin><PloneInstancePath>:<ApplicationName>:<ToolMethodName>[:<args>].
+    <ZopeAdmin>:<PloneInstancePath>:<ApplicationName>:<ToolMethodName>[:<args>].
 
      <ZopeAdmin> is the userName of the Zope administrator for this instance.
      <PloneInstancePath> is the path, within Zope, to the Plone Site object (if
                          not at the root of the Zope hierarchy, use '/' as
                          folder separator);
 
-     <ApplicationName> is the name of the Appy application;
+     <ApplicationName> is the name of the Appy application. If it begins with
+                       "path=", it does not represent an Appy application, but
+                       the path, within <PloneInstancePath>, to any Zope object
+                       (use '/' as folder separator)
 
      <ToolMethodName> is the name of the method to call on the tool in this
-                      Appy application;
+                      Appy application, or the method to call on the arbitrary
+                      Zope object if previous param starts with "path=".
 
      <args> (optional) are the arguments to give to this method (only strings
             are supported). Several arguments must be separated by '*'.'''
@@ -43,18 +47,24 @@ else:
         from AccessControl.SecurityManagement import newSecurityManager
         user = app.acl_users.getUserById(zopeUser)
         if not hasattr(user, 'aq_base'):
-            user = user.__of__(uf)
+            user = user.__of__(app.acl_users)
         newSecurityManager(None, user)
-
         # Get the Plone site
         ploneSite = app # Initialised with the Zope root object.
         for elem in plonePath.split('/'):
             ploneSite = getattr(ploneSite, elem)
-        # Get the tool corresponding to the Appy application
-        toolName = 'portal_%s' % appName.lower()
-        tool = getattr(ploneSite, toolName).appy()
-        # Execute the method on the tool
+        # If we are in a Appy application, the object on which we will call the
+        # method is the tool within this application.
+        if not appName.startswith('path='):
+            objectName = 'portal_%s' % appName.lower()
+            targetObject = getattr(ploneSite, objectName).appy()
+        else:
+            # It can be any object within the Plone site.
+            targetObject = ploneSite
+            for elem in appName[5:].split('/'):
+                targetObject = getattr(targetObject, elem)
+        # Execute the method on the target object
         if args: args = args.split('*')
-        exec 'tool.%s(*args)' % toolMethod
+        exec 'targetObject.%s(*args)' % toolMethod
         transaction.commit()
 # ------------------------------------------------------------------------------

doc/version.txt

@@ -1 +1 @@
-0.5.5
+0.6.0

gen/descriptors.py

@@ -4,10 +4,13 @@ from appy.gen import State, Transition, Type
 # ------------------------------------------------------------------------------
 class Descriptor: # Abstract
     def __init__(self, klass, orderedAttributes, generator):
-        self.klass = klass # The corresponding Python class
-        self.orderedAttributes = orderedAttributes # Names of the static appy-
-        # compliant attributes declared in self.klass
-        self.generator = generator # A reference to the code generator.
+        # The corresponding Python class
+        self.klass = klass
+        # The names of the static appy-compliant attributes declared in
+        # self.klass
+        self.orderedAttributes = orderedAttributes
+        # A reference to the code generator.
+        self.generator = generator
 
     def __repr__(self): return '<Class %s>' % self.klass.__name__
 
@@ -19,14 +22,22 @@ class ClassDescriptor(Descriptor):
            the condition will be returned. p_condition must be a string
            containing an expression that will be evaluated with, in its context,
            "self" being this ClassDescriptor and "attrValue" being the current
-           Type instance.'''
-        res = []
+           Type instance.
+           
+           Order of returned attributes already takes into account type's
+           "move" attributes.'''
+        attrs = []
         # First, get the attributes for the current class
         for attrName in self.orderedAttributes:
-            attrValue = getattr(self.klass, attrName)
+            try:
+                attrValue = getattr(self.klass, attrName)
+                hookClass = self.klass
+            except AttributeError:
+                attrValue = getattr(self.modelClass, attrName)
+                hookClass = self.modelClass
             if isinstance(attrValue, Type):
                 if not condition or eval(condition):
-                    res.append( (attrName, attrValue) )
+                    attrs.append( (attrName, attrValue, hookClass) )
         # Then, add attributes from parent classes
         for baseClass in self.klass.__bases__:
             # Find the classDescr that corresponds to baseClass
@@ -36,7 +47,17 @@ class ClassDescriptor(Descriptor):
                     baseClassDescr = classDescr
                     break
             if baseClassDescr:
-                res = baseClassDescr.getOrderedAppyAttributes() + res
+                attrs = baseClassDescr.getOrderedAppyAttributes() + attrs
+        # Modify attributes order by using "move" attributes
+        res = []
+        for name, appyType, klass in attrs:
+            if appyType.move:
+                newPosition = len(res) - abs(appyType.move)
+                if newPosition <= 0:
+                    newPosition = 0
+                res.insert(newPosition, (name, appyType, klass))
+            else:
+                res.append((name, appyType, klass))
         return res
 
     def getChildren(self):
@@ -51,7 +72,7 @@ class ClassDescriptor(Descriptor):
     def getPhases(self):
         '''Gets the phases defined on fields of this class.'''
         res = []
-        for fieldName, appyType in self.getOrderedAppyAttributes():
+        for fieldName, appyType, klass in self.getOrderedAppyAttributes():
             if appyType.phase not in res:
                 res.append(appyType.phase)
         return res

gen/generator.py

@@ -131,14 +131,9 @@ class Generator:
         if not os.path.exists(self.templatesFolder):
             print WARN_NO_TEMPLATE % self.templatesFolder
         # Default descriptor classes
-        self.classDescriptor = ClassDescriptor
-        self.workflowDescriptor = WorkflowDescriptor
-        self.customToolClassDescriptor = ClassDescriptor
-        self.customFlavourClassDescriptor = ClassDescriptor
-        # Custom tool and flavour classes, if they are defined in the
-        # application
-        self.customToolDescr = None
-        self.customFlavourDescr = None
+        self.descriptorClasses = {
+            'class': ClassDescriptor, 'tool': ClassDescriptor,
+            'flavour': ClassDescriptor, 'workflow': WorkflowDescriptor}
         # The following dict contains a series of replacements that need to be
         # applied to file templates to generate files.
         self.repls = {'applicationName': self.applicationName,
@@ -146,6 +141,8 @@ class Generator:
                       'codeHeader': CODE_HEADER}
         # List of Appy classes and workflows found in the application
         self.classes = []
+        self.tool = None
+        self.flavour = None
         self.workflows = []
         self.initialize()
         self.config = Config.getDefault()
@@ -225,24 +222,30 @@ class Generator:
                     # of their definition).
                     attrs = astClasses[moduleElem.__name__].attributes
                     if appyType == 'class':
+                        # Determine the class type (standard, tool, flavour...)
                         if issubclass(moduleElem, Tool):
-                            descrClass = self.customToolClassDescriptor
-                            self.customToolDescr = descrClass(
-                                moduleElem, attrs, self)
+                            if not self.tool:
+                                klass = self.descriptorClasses['tool']
+                                self.tool = klass(moduleElem, attrs, self)
+                            else:
+                                self.tool.update(moduleElem, attrs)
                         elif issubclass(moduleElem, Flavour):
-                            descrClass = self.customFlavourClassDescriptor
-                            self.customFlavourDescr = descrClass(
-                                moduleElem, attrs, self)
+                            if not self.flavour:
+                                klass = self.descriptorClasses['flavour']
+                                self.flavour = klass(moduleElem, attrs, self)
+                            else:
+                                self.flavour.update(moduleElem, attrs)
                         else:
-                            descrClass = self.classDescriptor
-                            self.classes.append(
-                                descrClass(moduleElem, attrs, self))
+                            descriptorClass = self.descriptorClasses['class']
+                            descriptor = descriptorClass(moduleElem,attrs, self)
+                            self.classes.append(descriptor)
+                        # Manage classes containing tests
                         if self.containsTests(moduleElem):
                             self.modulesWithTests.add(moduleObj.__name__)
                     elif appyType == 'workflow':
-                        descrClass = self.workflowDescriptor
-                        self.workflows.append(
-                            descrClass(moduleElem, attrs, self))
+                        descriptorClass = self.descriptorClasses['workflow']
+                        descriptor = descriptorClass(moduleElem, attrs, self)
+                        self.workflows.append(descriptor)
                         if self.containsTests(moduleElem):
                             self.modulesWithTests.add(moduleObj.__name__)
             elif isinstance(moduleElem, Config):
@@ -331,8 +334,8 @@ class Generator:
 
     def run(self):
         self.walkApplication()
-        for classDescr in self.classes: self.generateClass(classDescr)
-        for wfDescr in self.workflows: self.generateWorkflow(wfDescr)
+        for descriptor in self.classes: self.generateClass(descriptor)
+        for descriptor in self.workflows: self.generateWorkflow(descriptor)
         self.finalize()
         msg = ''
         if self.totalNumberOfTests:

gen/layout.py

@@ -0,0 +1,188 @@
+'''This module contains classes used for layouting graphical elements
+   (fields, widgets, groups, ...).'''
+
+# A layout defines how a given field is rendered in a given context. Several
+# contexts exist:
+#  "view"   represents a given page for a given Appy class, in read-only mode.
+#  "edit"   represents a given page for a given Appy class, in edit mode.
+#  "cell"   represents a cell in a table, like when we need to render a field
+#           value in a query result or in a reference table.
+
+# Layout elements for a class or page ------------------------------------------
+#  s - The page summary, containing summarized information about the page or
+#      class, workflow information and object history.
+#  w - The widgets of the current page/class
+#  n - The navigation panel (inter-objects navigation)
+#  b - The range of buttons (intra-object navigation, save, edit, delete...)
+#  m - The global status message sometimes shown.
+
+# Layout elements for a field --------------------------------------------------
+#  l -  "label"        The field label
+#  d -  "description"  The field description (a description is always visible)
+#  h -  "help"         Help for the field (typically rendered as an icon,
+#                       clicking on it shows a popup with online help
+#  v -  "validation"   The icon that is shown when a validation error occurs
+#                       (typically only used on "edit" layouts)
+#  r -  "required"     The icon that specified that the field is required (if
+#                       relevant; typically only used on "edit" layouts)
+#  f -  "field"        The field value, or input for entering a value.
+
+# For every field of a Appy class, you can define, for every layout context,
+# what field-related information will appear, and how it will be rendered.
+# Variables defaultPageLayouts and defaultFieldLayouts defined below give the
+# default layouts for pages and fields respectively.
+# 
+# How to express a layout? You simply define a string that is made of the
+# letters corresponding to the field elements you want to render. The order of
+# elements correspond to the order into which they will be rendered.
+
+# ------------------------------------------------------------------------------
+rowDelimiters =  {'-':'middle', '=':'top', '_':'bottom'}
+cellDelimiters = {'|': 'center', ';': 'left', '!': 'right'}
+macroDict = {
+  # Page-related elements
+  's': ('page', 'header'), 'w': ('page', 'widgets'),
+  'n': ('navigate', 'objectNavigate'), 'b': ('page', 'buttons'),
+  'm': ('page', 'message'),
+  # Field-related elements
+  'l': ('show', 'label'), 'd': ('show', 'description'),
+  'h': ('show', 'help'),  'v': ('show', 'validation'),
+  'r': ('show', 'required')
+}
+
+# ------------------------------------------------------------------------------
+class LayoutElement:
+    '''Abstract base class for any layout element.'''
+    def get(self): return self.__dict__
+
+class Cell(LayoutElement):
+    '''Represents a cell in a row in a table.'''
+    def __init__(self, content, align, isHeader=False):
+        self.align = align
+        self.width = None
+        self.content = None
+        self.colspan = 1
+        if isHeader:
+            self.width = content
+        else:
+            self.content = [] # The list of widgets to render in the cell
+            self.decodeContent(content)
+
+    def decodeContent(self, content):
+        digits = '' # We collect the digits that will give the colspan
+        for char in content:
+            if char.isdigit():
+                digits += char
+            else:
+                # It is a letter corresponding to a macro
+                if char in macroDict:
+                    self.content.append(macroDict[char])
+                elif char == 'f':
+                    # The exact macro to call will be known at render-time
+                    self.content.append('?')
+        # Manage the colspan
+        if digits:
+            self.colspan = int(digits)
+
+# ------------------------------------------------------------------------------
+class Row(LayoutElement):
+    '''Represents a row in a table.'''
+    def __init__(self, content, valign, isHeader=False):
+        self.valign = valign
+        self.cells = []
+        self.decodeCells(content, isHeader)
+        # Compute the row length
+        length = 0
+        for cell in self.cells:
+            length += cell['colspan']
+        self.length = length
+
+    def decodeCells(self, content, isHeader):
+        '''Decodes the given chunk of layout string p_content containing
+           column-related information (if p_isHeader is True) or cell content
+           (if p_isHeader is False) and produces a list of Cell instances.'''
+        cellContent = ''
+        for char in content:
+            if char in cellDelimiters:
+                align = cellDelimiters[char]
+                self.cells.append(Cell(cellContent, align, isHeader).get())
+                cellContent = ''
+            else:
+                cellContent += char
+        # Manage the last cell if any
+        if cellContent:
+            self.cells.append(Cell(cellContent, 'left', isHeader).get())
+
+# ------------------------------------------------------------------------------
+class Table(LayoutElement):
+    '''Represents a table where to dispose graphical elements.'''
+    def __init__(self, layoutString, style=None, css_class='', cellpadding=0,
+                 cellspacing=0, width='100%', align='left'):
+        self.style = style
+        self.css_class = css_class
+        self.cellpadding = cellpadding
+        self.cellspacing = cellspacing
+        self.width = width
+        self.align = align
+        # The following attribute will store a special Row instance used for
+        # defining column properties.
+        self.headerRow = None
+        # The content rows are stored hereafter.
+        self.rows = []
+        self.layoutString = layoutString
+        self.decodeRows(layoutString)
+
+    def addCssClasses(self, css_class):
+        '''Adds a single or a group of p_css_class.'''
+        classes = self.css_class
+        if classes == None:
+            classes = ''
+        if not classes:
+            self.css_class = css_class
+        else:
+            self.css_class += ' ' + css_classes
+            # Ensures that every class appears once
+            self.css_class = ' '.join(set(self.css_class.split()))
+
+    def isHeaderRow(self, rowContent):
+        '''Determines if p_rowContent specified the table header row or a
+           content row.'''
+        # Find the first char that is a number or a letter
+        for char in rowContent:
+            if char not in cellDelimiters:
+                if char.isdigit(): return True
+                else:              return False
+        return True
+
+    def decodeRows(self, layoutString):
+        '''Decodes the given p_layoutString and produces a list of Row
+           instances.'''
+        # Split the p_layoutString with the row delimiters
+        rowContent = ''
+        for char in layoutString:
+            if char in rowDelimiters:
+                valign = rowDelimiters[char]
+                if self.isHeaderRow(rowContent):
+                    self.headerRow = Row(rowContent,valign,isHeader=True).get()
+                else:
+                    self.rows.append(Row(rowContent, valign).get())
+                rowContent = ''
+            else:
+                rowContent += char
+        # Manage the last row if any
+        if rowContent:
+            self.rows.append(Row(rowContent, 'middle').get())
+
+    def removeElement(self, elem):
+        '''Removes given p_elem from myself.'''
+        macroToRemove = macroDict[elem]
+        for row in self.rows:
+            for cell in row['cells']:
+                if macroToRemove in cell['content']:
+                    cell['content'].remove(macroToRemove)
+
+# ------------------------------------------------------------------------------
+defaultPageLayouts  = {
+    'view': Table('m;-s|-n!-w;-b|'), 'edit': Table('m;-s|-n!-w;-b|')}
+defaultFieldLayouts = {'view': 'l;f!', 'edit': 'lrv;f!'}
+# ------------------------------------------------------------------------------

gen/odt/generator.py

@@ -46,7 +46,7 @@ class Generator(AbstractGenerator):
            into the ODT file. This method returns the list of "dumpable"
            fields.'''
         res = []
-        for fieldName, field in classDescr.getOrderedAppyAttributes():
+        for fieldName, field, klass in classDescr.getOrderedAppyAttributes():
             if (field.type not in self.undumpable) and \
                (not self.fieldIsStaticallyInvisible(field)):
                 res.append((fieldName, field))

gen/plone25/descriptors.py

@@ -18,7 +18,7 @@ from appy.gen.utils import GroupDescr, PageDescr, produceNiceMessage, \
 TABS = 4 # Number of blanks in a Python indentation.
 
 # ------------------------------------------------------------------------------
-class ArchetypeFieldDescriptor:
+class FieldDescriptor:
     '''This class allows to gather information needed to generate an Archetypes
        definition (field + widget) from an Appy type. An Appy type is used for
        defining the type of attributes defined in the user application.'''
@@ -39,7 +39,6 @@ class ArchetypeFieldDescriptor:
         self.widgetParams = {}
         self.fieldType = None
         self.widgetType = None
-        self.walkAppyType()
 
     def __repr__(self):
         return '<Field %s, %s>' % (self.fieldName, self.classDescr)
@@ -59,8 +58,8 @@ class ArchetypeFieldDescriptor:
         return res
 
     def produceMessage(self, msgId, isLabel=True):
-        '''Gets the default label or description (if p_isLabel is False) for
-           i18n message p_msgId.'''
+        '''Gets the default label, description or help (depending on p_msgType)
+           for i18n message p_msgId.'''
         default = ' '
         produceNice = False
         if isLabel:
@@ -75,82 +74,22 @@ class ArchetypeFieldDescriptor:
             msg.produceNiceDefault()
         return msg
 
-    def walkBasicType(self):
-        '''How to dump a basic type?'''
-        self.fieldType = '%sField' % self.appyType.type
-        self.widgetType = "%sWidget" % self.appyType.type
-        if self.appyType.type == 'Date':
-            self.fieldType = 'DateTimeField'
-            self.widgetType = 'CalendarWidget'
-            if self.appyType.format == Date.WITHOUT_HOUR:
-                self.widgetParams['show_hm'] = False
-                self.widgetParams['starting_year'] = self.appyType.startYear
-                self.widgetParams['ending_year'] = self.appyType.endYear
-        elif self.appyType.type == 'Float':
-            self.widgetType = 'DecimalWidget'
-        elif self.appyType.type == 'File':
-            if self.appyType.isImage:
-                self.fieldType = 'ImageField'
-                self.widgetType = 'ImageWidget'
-            self.fieldParams['storage'] = 'python:AttributeStorage()'
-
     def walkString(self):
         '''How to generate an Appy String?'''
-        if self.appyType.format == String.LINE:
-            if self.appyType.isSelection():
-                if self.appyType.isMultiValued():
-                    self.fieldType = 'LinesField'
-                    self.widgetType = 'MultiSelectionWidget'
-                    self.fieldParams['multiValued'] = True
-                    if (type(self.appyType.validator) in sequenceTypes) and \
-                        len(self.appyType.validator) <= 5:
-                        self.widgetParams['format'] = 'checkbox'
-                else:
-                    self.fieldType = 'StringField'
-                    self.widgetType = 'SelectionWidget'
-                    self.widgetParams['format'] = 'select'
-                # Elements common to all selection fields
-                methodName = 'list_%s_values' % self.fieldName
-                self.fieldParams['vocabulary'] = methodName
-                self.classDescr.addSelectMethod(methodName, self)
-                self.fieldParams['enforceVocabulary'] = True
-            else:
-                self.fieldType = 'StringField'
-                self.widgetType = 'StringWidget'
-                self.widgetParams['size'] = 50
-                if self.appyType.width:
-                    self.widgetParams['size'] = self.appyType.width
-        elif self.appyType.format == String.TEXT:
-            self.fieldType = 'TextField'
-            self.widgetType = 'TextAreaWidget'
-            if self.appyType.height:
-                self.widgetParams['rows'] = self.appyType.height
-        elif self.appyType.format == String.XHTML:
-            self.fieldType = 'TextField'
-            self.widgetType = 'RichWidget'
-            self.fieldParams['allowable_content_types'] = ('text/html',)
-            self.fieldParams['default_output_type'] = "text/html"
-        elif self.appyType.format == String.PASSWORD:
-            self.fieldType = 'StringField'
-            self.widgetType = 'PasswordWidget'
-            if self.appyType.width:
-                self.widgetParams['size'] = self.appyType.width
-
-    def walkComputed(self):
-        '''How to generate a computed field? We generate an Archetypes String
-           field.'''
-        self.fieldType = 'StringField'
-        self.widgetType = 'StringWidget'
-        self.widgetParams['visible'] = False # Archetypes will believe the
-        # field is invisible; we will display it ourselves (like for Ref fields)
+        if self.appyType.isSelect and \
+           (type(self.appyType.validator) in (list, tuple)):
+            # Generate i18n messages for every possible value if the list
+            # of values is fixed.
+            for value in self.appyType.validator:
+                msgLabel = '%s_%s_list_%s' % (self.classDescr.name,
+                    self.fieldName, value)
+                poMsg = PoMessage(msgLabel, '', value)
+                poMsg.produceNiceDefault()
+                self.generator.labels.append(poMsg)
 
     def walkAction(self):
         '''How to generate an action field ? We generate an Archetypes String
            field.'''
-        self.fieldType = 'StringField'
-        self.widgetType = 'StringWidget'
-        self.widgetParams['visible'] = False # Archetypes will believe the
-        # field is invisible; we will display it ourselves (like for Ref fields)
         # Add action-specific i18n messages
         for suffix in ('ok', 'ko'):
             label = '%s_%s_action_%s' % (self.classDescr.name, self.fieldName,
@@ -168,36 +107,22 @@ class ArchetypeFieldDescriptor:
         self.fieldParams['relationship'] = relationship
         if self.appyType.isMultiValued():
             self.fieldParams['multiValued'] = True
-        self.widgetParams['visible'] = False
         # Update the list of referers
         self.generator.addReferer(self, relationship)
         # Add the widget label for the back reference
-        refClassName = ArchetypesClassDescriptor.getClassName(
-            self.appyType.klass)
+        refClassName = ClassDescriptor.getClassName(self.appyType.klass)
         if issubclass(self.appyType.klass, ModelClass):
             refClassName = self.applicationName + self.appyType.klass.__name__
         elif issubclass(self.appyType.klass, appy.gen.Tool):
             refClassName = '%sTool' % self.applicationName
         elif issubclass(self.appyType.klass, appy.gen.Flavour):
             refClassName = '%sFlavour' % self.applicationName
-        backLabel = "%s_%s_back" % (refClassName, self.appyType.back.attribute)
+        backLabel = "%s_%s" % (refClassName, self.appyType.back.attribute)
         poMsg = PoMessage(backLabel, '', self.appyType.back.attribute)
         poMsg.produceNiceDefault()
         self.generator.labels.append(poMsg)
 
-    def walkInfo(self):
-        '''How to generate an Info field? We generate an Archetypes String
-           field.'''
-        self.fieldType = 'StringField'
-        self.widgetType = 'StringWidget'
-        self.widgetParams['visible'] = False # Archetypes will believe the
-        # field is invisible; we will display it ourselves (like for Ref fields)
-
     def walkPod(self):
-        '''How to dump a Pod type?'''
-        self.fieldType = 'FileField'
-        self.widgetType = 'FileWidget'
-        self.fieldParams['storage'] = 'python:AttributeStorage()'
         # Add i18n-specific messages
         if self.appyType.askAction:
             label = '%s_%s_askaction' % (self.classDescr.name, self.fieldName)
@@ -207,47 +132,23 @@ class ArchetypeFieldDescriptor:
         # Add the POD-related fields on the Flavour
         Flavour._appy_addPodRelatedFields(self)
 
-    alwaysAValidatorFor = ('Ref', 'Integer', 'Float')
     notToValidateFields = ('Info', 'Computed', 'Action', 'Pod')
     def walkAppyType(self):
         '''Walks into the Appy type definition and gathers data about the
-           Archetype elements to generate.'''
+           i18n labels.'''
         # Manage things common to all Appy types
-        # - special accessor for fields "title" and "description"
-        if self.fieldName in self.specialParams:
-            self.fieldParams['accessor'] = self.fieldName.capitalize()
-        # - default value
-        if self.appyType.default != None:
-            self.fieldParams['default'] = self.appyType.default
-        # - required?
-        if self.appyType.multiplicity[0] >= 1:
-            if self.appyType.type != 'Ref': self.fieldParams['required'] = True
-            # Indeed, if it is a ref appy will manage itself field updates in
-            # onEdit, so Archetypes must not enforce required=True
         # - optional ?
         if self.appyType.optional:
             Flavour._appy_addOptionalField(self)
-            self.widgetParams['condition'] = ' python: ' \
-                'here.fieldIsUsed("%s")'% self.fieldName
         # - edit default value ?
         if self.appyType.editDefault:
             Flavour._appy_addDefaultField(self)
-            methodName = 'getDefaultValueFor%s' % self.fieldName
-            self.fieldParams['default_method'] = methodName
-            self.classDescr.addDefaultMethod(methodName, self)
         # - put an index on this field?
-        if self.appyType.indexed:
-            if (self.appyType.type == 'String') and (self.appyType.isSelect):
-                self.fieldParams['index'] = 'ZCTextIndex, lexicon_id=' \
-                    'plone_lexicon, index_type=Okapi BM25 Rank'
-            else:
-                self.fieldParams['index'] = 'FieldIndex'
-        # - searchable ?
-        if self.appyType.searchable: self.fieldParams['searchable'] = True
-        # - slaves ?
-        if self.appyType.slaves: self.widgetParams['visible'] = False
-        # Archetypes will believe the field is invisible; we will display it
-        # ourselves (like for Ref fields).
+        if self.appyType.indexed and \
+           (self.fieldName not in ('title', 'description')):
+            self.classDescr.addIndexMethod(self)
+        # - searchable ? TODO
+        #if self.appyType.searchable: self.fieldParams['searchable'] = True
         # - need to generate a field validator?
         # In all cases excepted for "immutable" fields, add an i18n message for
         # the validation error for this field.
@@ -255,43 +156,18 @@ class ArchetypeFieldDescriptor:
             label = '%s_%s_valid' % (self.classDescr.name, self.fieldName)
             poMsg = PoMessage(label, '', PoMessage.DEFAULT_VALID_ERROR)
             self.generator.labels.append(poMsg)
-        # Generate a validator for the field if needed.
-        if (type(self.appyType.validator) == types.FunctionType) or \
-           (type(self.appyType.validator) == type(String.EMAIL)) or \
-           (self.appyType.type in self.alwaysAValidatorFor):
-            # For references, we always add a validator because gen validates
-            # itself things like multiplicities;
-            # For integers and floats, we also need validators because, by
-            # default, Archetypes produces an exception if the field value does
-            # not have the correct type, for example.
-            methodName = 'validate_%s' % self.fieldName
-            # Add a validate method for this
-            specificType = None
-            if self.appyType.type in self.alwaysAValidatorFor:
-                specificType = self.appyType.type
-            self.classDescr.addValidateMethod(methodName, label, self,
-                specificType=specificType)
-        # Manage specific permissions
-        permFieldName = '%s %s' % (self.classDescr.name, self.fieldName)
-        if self.appyType.specificReadPermission:
-            self.fieldParams['read_permission'] = '%s: Read %s' % \
-                (self.generator.applicationName, permFieldName)
-        if self.appyType.specificWritePermission:
-            self.fieldParams['write_permission'] = '%s: Write %s' % \
-                (self.generator.applicationName, permFieldName)
         # i18n labels
         i18nPrefix = "%s_%s" % (self.classDescr.name, self.fieldName)
-        wp = self.widgetParams
-        wp['label'] = self.fieldName
-        wp['label_msgid'] = '%s' % i18nPrefix
-        wp['description'] = '%sDescr' % i18nPrefix
-        wp['description_msgid'] = '%s_descr' % i18nPrefix
-        wp['i18n_domain'] = self.applicationName
         # Create labels for generating them in i18n files.
         messages = self.generator.labels
-        messages.append(self.produceMessage(wp['label_msgid']))
-        messages.append(self.produceMessage(wp['description_msgid'],
-                        isLabel=False))
+        if self.appyType.hasLabel:
+            messages.append(self.produceMessage(i18nPrefix))
+        if self.appyType.hasDescr:
+            descrId = i18nPrefix + '_descr'
+            messages.append(self.produceMessage(descrId,isLabel=False))
+        if self.appyType.hasHelp:
+            helpId = i18nPrefix + '_help'
+            messages.append(self.produceMessage(helpId, isLabel=False))
         # Create i18n messages linked to pages and phases
         messages = self.generator.labels
         pageMsgId = '%s_page_%s' % (self.classDescr.name, self.appyType.page)
@@ -305,34 +181,22 @@ class ArchetypeFieldDescriptor:
                 messages.append(poMsg)
                 self.classDescr.labelsToPropagate.append(poMsg)
         # Create i18n messages linked to groups
-        if self.appyType.group:
-            groupName, cols = GroupDescr.getGroupInfo(self.appyType.group)
-            msgId = '%s_group_%s' % (self.classDescr.name, groupName)
-            poMsg = PoMessage(msgId, '', groupName)
-            poMsg.produceNiceDefault()
-            if poMsg not in messages:
-                messages.append(poMsg)
-                self.classDescr.labelsToPropagate.append(poMsg)
-        # Manage schemata
-        if self.appyType.page != 'main':
-            self.fieldParams['schemata'] = self.appyType.page
-        # Manage things which are specific to basic types
-        if self.appyType.type in self.singleValuedTypes: self.walkBasicType()
+        group = self.appyType.group
+        if group:
+            group.generateLabels(messages, self.classDescr, set())
         # Manage things which are specific to String types
-        elif self.appyType.type == 'String': self.walkString()
-        # Manage things which are specific to Computed types
-        elif self.appyType.type == 'Computed': self.walkComputed()
+        if self.appyType.type == 'String': self.walkString()
         # Manage things which are specific to Actions
         elif self.appyType.type == 'Action': self.walkAction()
         # Manage things which are specific to Ref types
         elif self.appyType.type == 'Ref': self.walkRef()
-        # Manage things which are specific to Info types
-        elif self.appyType.type == 'Info': self.walkInfo()
         # Manage things which are specific to Pod types
         elif self.appyType.type == 'Pod': self.walkPod()
 
     def generate(self):
-        '''Produces the Archetypes field definition as a string.'''
+        '''Generates the i18n labels for this type.'''
+        self.walkAppyType()
+        if self.appyType.type != 'Ref': return
         res = ''
         s = stringify
         spaces = TABS
@@ -376,89 +240,41 @@ class ClassDescriptor(appy.gen.descriptors.ClassDescriptor):
         # for child classes of this class as well, but at this time we don't
         # know yet every sub-class. So we store field definitions here; the
         # Generator will propagate them later.
+        self.name = self.getClassName(klass)
+        self.predefined = False
+        self.customized = False
 
-    def generateSchema(self):
-        '''Generates the corresponding Archetypes schema in self.schema.'''
+    def getParents(self, allClasses):
+        parentWrapper = 'AbstractWrapper'
+        parentClass = '%s.%s' % (self.klass.__module__, self.klass.__name__)
+        if self.klass.__bases__:
+            baseClassName = self.klass.__bases__[0].__name__
+            for k in allClasses:
+                if self.klass.__name__ == baseClassName:
+                    parentWrapper = '%s_Wrapper' % k.name
+        return (parentWrapper, parentClass)
+
+    def generateSchema(self, configClass=False):
+        '''Generates the corresponding Archetypes schema in self.schema. If we
+           are generating a schema for a class that is in the configuration
+           (tool, flavour, etc) we must avoid having attributes that rely on
+           the configuration (ie attributes that are optional, with
+           editDefault=True, etc).'''
         for attrName in self.orderedAttributes:
-            attrValue = getattr(self.klass, attrName)
+            try:
+                attrValue = getattr(self.klass, attrName)
+            except AttributeError:
+                attrValue = getattr(self.modelClass, attrName)
             if isinstance(attrValue, Type):
-                field = ArchetypeFieldDescriptor(attrName, attrValue, self)
-                self.schema += '\n' + field.generate()
-
-    def addSelectMethod(self, methodName, fieldDescr):
-        '''For the selection field p_fieldDescr I need to generate a method
-           named p_methodName that will generate the vocabulary for
-           p_fieldDescr.'''
-        # Generate the method signature
-        m = self.methods
-        s = stringify
-        spaces = TABS
-        m += '\n' + ' '*spaces + 'def %s(self):\n' % methodName
-        spaces += TABS
-        appyType = fieldDescr.appyType
-        if type(appyType.validator) in (list, tuple):
-            # Generate i18n messages for every possible value
-            f = fieldDescr
-            labels = []
-            for value in appyType.validator:
-                msgLabel = '%s_%s_list_%s' % (f.classDescr.name, f.fieldName,
-                                              value)
-                labels.append(msgLabel) # I will need it later
-                poMsg = PoMessage(msgLabel, '', value)
-                poMsg.produceNiceDefault()
-                self.generator.labels.append(poMsg)
-            # Generate a method that returns a DisplayList
-            appName = self.generator.applicationName
-            allValues = appyType.validator
-            if not appyType.isMultiValued():
-                allValues = [''] + appyType.validator
-                labels.insert(0, 'choose_a_value')
-            m += ' '*spaces + 'return self._appy_getDisplayList' \
-                 '(%s, %s, %s)\n' % (s(allValues), s(labels), s(appName))
-        elif isinstance(appyType.validator, Selection):
-            # Call the custom method that will produce dynamically the list of
-            # values.
-            m += ' '*spaces + 'return self._appy_getDynamicDisplayList' \
-                 '(%s)\n' % s(appyType.validator.methodName)
-        self.methods = m
-
-    def addValidateMethod(self, methodName, label, fieldDescr,
-                          specificType=None):
-        '''For the field p_fieldDescr I need to generate a validation method.
-           If p_specificType is not None, it corresponds to the name of a type
-           like Ref, Integer or Float, for which specific validation is needed,
-           beyond the potential custom validation specified by a user-defined
-           validator method.'''
-        # Generate the method signature
-        m = self.methods
-        s = stringify
-        spaces = TABS
-        m += '\n' + ' '*spaces + 'def %s(self, value):\n' % methodName
-        spaces += TABS
-        m += ' '*spaces + 'return self._appy_validateField(%s, value, %s, ' \
-             '%s)\n' %  (s(fieldDescr.fieldName), s(label), s(specificType))
-        self.methods = m
-
-    def addDefaultMethod(self, methodName, fieldDescr):
-        '''When the default value of a field may be edited, we must add a method
-           that will gather the default value from the flavour.'''
-        m = self.methods
-        spaces = TABS
-        m += '\n' + ' '*spaces + 'def %s(self):\n' % methodName
-        spaces += TABS
-        m += ' '*spaces + 'return self.getDefaultValueFor("%s")\n' % \
-             fieldDescr.fieldName
-        self.methods = m
-
-class ArchetypesClassDescriptor(ClassDescriptor):
-    '''Represents an Archetypes-compliant class that corresponds to an
-       application class.'''
-    predefined = False
-    def __init__(self, klass, orderedAttributes, generator):
-        ClassDescriptor.__init__(self, klass, orderedAttributes, generator)
-        if not hasattr(self, 'name'):
-            self.name = self.getClassName(klass)
-        self.generateSchema()
+                if configClass:
+                    attrValue = copy.copy(attrValue)
+                    attrValue.optional = False
+                    attrValue.editDefault = False
+                field = FieldDescriptor(attrName, attrValue, self)
+                fieldDef = field.generate()
+                if fieldDef:
+                    # Currently, we generate Archetypes fields for Refs only.
+                    self.schema += '\n' + fieldDef
 
     @staticmethod
     def getClassName(klass):
@@ -502,6 +318,13 @@ class ArchetypesClassDescriptor(ClassDescriptor):
                 res = self.isFolder(theClass.__bases__[0])
         return res
 
+    def getCreators(self):
+        '''Gets the specific creators defined for this class.'''
+        res = []
+        if self.klass.__dict__.has_key('creators') and self.klass.creators:
+            res += list(self.klass.creators)
+        return res
+
     def getCreateMean(self, type='Import'):
         '''Returns the mean for this class that corresponds to p_type, or
            None if the class does not support this create mean.'''
@@ -534,75 +357,87 @@ class ArchetypesClassDescriptor(ClassDescriptor):
     @staticmethod
     def getSearch(klass, searchName):
         '''Gets the search named p_searchName.'''
-        for search in ArchetypesClassDescriptor.getSearches(klass):
+        for search in ClassDescriptor.getSearches(klass):
             if search.name == searchName:
                 return search
         return None
 
-class ToolClassDescriptor(ClassDescriptor):
-    '''Represents the POD-specific fields that must be added to the tool.'''
-    predefined = True
-    def __init__(self, klass, generator):
-        ClassDescriptor.__init__(self, klass, klass._appy_attributes, generator)
-        self.name = '%sTool' % generator.applicationName
-    def isFolder(self, klass=None): return True
-    def isRoot(self): return False
-    def addUnoValidator(self):
+    def addIndexMethod(self, field):
+        '''For indexed p_field, this method generates a method that allows to
+           get the value of the field as must be copied into the corresponding
+           index.'''
         m = self.methods
         spaces = TABS
-        m += '\n' + ' '*spaces + 'def validate_unoEnabledPython(self, value):\n'
+        n = field.fieldName
+        m += '\n' + ' '*spaces + 'def get%s%s(self):\n' % (n[0].upper(), n[1:])
         spaces += TABS
-        m += ' '*spaces + 'return self._appy_validateUnoEnabledPython(value)\n'
+        m += ' '*spaces + "'''Gets indexable value of field \"%s\".'''\n" % n
+        m += ' '*spaces + 'return self.getAppyType("%s").getValue(self)\n' % n
         self.methods = m
+
+class ToolClassDescriptor(ClassDescriptor):
+    '''Represents the POD-specific fields that must be added to the tool.'''
+    def __init__(self, klass, generator):
+        ClassDescriptor.__init__(self,klass,klass._appy_attributes[:],generator)
+        self.name = '%sTool' % generator.applicationName
+        self.modelClass = self.klass
+        self.predefined = True
+        self.customized = False
+    def getParents(self, allClasses=()):
+        res = ['Tool']
+        if self.customized:
+            res.append('%s.%s' % (self.klass.__module__, self.klass.__name__))
+        return res
+    def update(self, klass, attributes):
+        '''This method is called by the generator when he finds a custom tool
+           definition. We must then add the custom tool elements in this default
+           Tool descriptor.'''
+        self.orderedAttributes += attributes
+        self.klass = klass
+        self.customized = True
+    def isFolder(self, klass=None): return True
+    def isRoot(self): return False
     def generateSchema(self):
-        ClassDescriptor.generateSchema(self)
-        self.addUnoValidator()
+        ClassDescriptor.generateSchema(self, configClass=True)
 
 class FlavourClassDescriptor(ClassDescriptor):
     '''Represents an Archetypes-compliant class that corresponds to the Flavour
        for the generated application.'''
-    predefined = True
     def __init__(self, klass, generator):
-        ClassDescriptor.__init__(self, klass, klass._appy_attributes, generator)
+        ClassDescriptor.__init__(self,klass,klass._appy_attributes[:],generator)
         self.name = '%sFlavour' % generator.applicationName
         self.attributesByClass = klass._appy_classes
-        # We don't generate the schema automatically here because we need to
-        # add more fields.
+        self.modelClass = self.klass
+        self.predefined = True
+        self.customized = False
+    def getParents(self, allClasses=()):
+        res = ['Flavour']
+        if self.customized:
+            res.append('%s.%s' % (self.klass.__module__, self.klass.__name__))
+        return res
+    def update(self, klass, attributes):
+        '''This method is called by the generator when he finds a custom flavour
+           definition. We must then add the custom flavour elements in this
+           default Flavour descriptor.'''
+        self.orderedAttributes += attributes
+        self.klass = klass
+        self.customized = True
     def isFolder(self, klass=None): return True
     def isRoot(self): return False
+    def generateSchema(self):
+        ClassDescriptor.generateSchema(self, configClass=True)
 
 class PodTemplateClassDescriptor(ClassDescriptor):
     '''Represents a POD template.'''
-    predefined = True
     def __init__(self, klass, generator):
-        ClassDescriptor.__init__(self, klass, klass._appy_attributes, generator)
+        ClassDescriptor.__init__(self,klass,klass._appy_attributes[:],generator)
         self.name = '%sPodTemplate' % generator.applicationName
+        self.modelClass = self.klass
+        self.predefined = True
+        self.customized = False
+    def getParents(self, allClasses=()): return ['PodTemplate']
     def isRoot(self): return False
 
-class CustomToolClassDescriptor(ArchetypesClassDescriptor):
-    '''If the user defines a class that inherits from Tool, we will add those
-       fields to the tool.'''
-    predefined = False
-    def __init__(self, *args):
-        self.name = '%sTool' % args[2].applicationName
-        ArchetypesClassDescriptor.__init__(self, *args)
-    def generateSchema(self):
-        '''Custom tool fields may not use the variability mechanisms, ie
-           'optional' or 'editDefault' attributes.'''
-        for attrName in self.orderedAttributes:
-            attrValue = getattr(self.klass, attrName)
-            if isinstance(attrValue, Type):
-                attrValue = copy.copy(attrValue)
-                attrValue.optional = False
-                attrValue.editDefault = False
-                field = ArchetypeFieldDescriptor(attrName, attrValue, self)
-                self.schema += '\n' + field.generate()
-
-class CustomFlavourClassDescriptor(CustomToolClassDescriptor):
-    def __init__(self, *args):
-        self.name = '%sFlavour' % args[2].applicationName
-        ArchetypesClassDescriptor.__init__(self, *args)
-
 class WorkflowDescriptor(appy.gen.descriptors.WorkflowDescriptor):
     '''Represents a workflow.'''
     # How to map Appy permissions to Plone permissions ?

gen/plone25/generator.py

@@ -8,10 +8,9 @@ from appy.gen import *
 from appy.gen.po import PoMessage, PoFile, PoParser
 from appy.gen.generator import Generator as AbstractGenerator
 from model import ModelClass, PodTemplate, Flavour, Tool
-from descriptors import ArchetypeFieldDescriptor, ArchetypesClassDescriptor, \
+from descriptors import FieldDescriptor, ClassDescriptor, \
                         WorkflowDescriptor, ToolClassDescriptor, \
-                        FlavourClassDescriptor, PodTemplateClassDescriptor, \
-                        CustomToolClassDescriptor, CustomFlavourClassDescriptor
+                        FlavourClassDescriptor, PodTemplateClassDescriptor
 
 # Common methods that need to be defined on every Archetype class --------------
 COMMON_METHODS = '''
@@ -30,6 +29,13 @@ class Generator(AbstractGenerator):
     def __init__(self, *args, **kwargs):
         Flavour._appy_clean()
         AbstractGenerator.__init__(self, *args, **kwargs)
+        # Set our own Descriptor classes
+        self.descriptorClasses['class'] = ClassDescriptor
+        self.descriptorClasses['workflow']  = WorkflowDescriptor
+        # Create our own Tool, Flavour and PodTemplate instances
+        self.tool = ToolClassDescriptor(Tool, self)
+        self.flavour = FlavourClassDescriptor(Flavour, self)
+        self.podTemplate = PodTemplateClassDescriptor(PodTemplate, self)
         # i18n labels to generate
         self.labels = [] # i18n labels
         self.toolName = '%sTool' % self.applicationName
@@ -50,19 +56,10 @@ class Generator(AbstractGenerator):
              'toolInstanceName': self.toolInstanceName,
              'podTemplateName': self.podTemplateName,
              'commonMethods': commonMethods})
-        # Predefined class descriptors
-        self.toolDescr = ToolClassDescriptor(Tool, self)
-        self.flavourDescr = FlavourClassDescriptor(Flavour, self)
-        self.podTemplateDescr = PodTemplateClassDescriptor(PodTemplate,self)
         self.referers = {}
 
     versionRex = re.compile('(.*?\s+build)\s+(\d+)')
     def initialize(self):
-        # Use customized class descriptors
-        self.classDescriptor = ArchetypesClassDescriptor
-        self.workflowDescriptor = WorkflowDescriptor
-        self.customToolClassDescriptor = CustomToolClassDescriptor
-        self.customFlavourClassDescriptor = CustomFlavourClassDescriptor
         # Determine version number of the Plone product
         self.version = '0.1 build 1'
         versionTxt = os.path.join(self.outputFolder, 'version.txt')
@@ -91,6 +88,7 @@ class Generator(AbstractGenerator):
         poMsg = msg(app, '', app); poMsg.produceNiceDefault()
         self.labels += [poMsg,
             msg('workflow_state',       '', msg.WORKFLOW_STATE),
+            msg('appy_title',           '', msg.APPY_TITLE),
             msg('data_change',          '', msg.DATA_CHANGE),
             msg('modified_field',       '', msg.MODIFIED_FIELD),
             msg('previous_value',       '', msg.PREVIOUS_VALUE),
@@ -127,11 +125,12 @@ class Generator(AbstractGenerator):
             msg('search_or',            '', msg.SEARCH_OR),
             msg('search_and',           '', msg.SEARCH_AND),
             msg('ref_invalid_index',    '', msg.REF_INVALID_INDEX),
-            msg('bad_int',              '', msg.BAD_INT),
+            msg('bad_long',             '', msg.BAD_LONG),
             msg('bad_float',            '', msg.BAD_FLOAT),
             msg('bad_email',            '', msg.BAD_EMAIL),
             msg('bad_url',              '', msg.BAD_URL),
             msg('bad_alphanumeric',     '', msg.BAD_ALPHANUMERIC),
+            msg('bad_select_value',     '', msg.BAD_SELECT_VALUE),
             msg('select_delesect',      '', msg.SELECT_DESELECT),
             msg('no_elem_selected',     '', msg.NO_SELECTION),
             msg('delete_confirm',       '', msg.DELETE_CONFIRM),
@@ -145,6 +144,9 @@ class Generator(AbstractGenerator):
             msg('confirm',              '', msg.CONFIRM),
             msg('yes',                  '', msg.YES),
             msg('no',                   '', msg.NO),
+            msg('field_required',       '', msg.FIELD_REQUIRED),
+            msg('file_required',        '', msg.FILE_REQUIRED),
+            msg('image_required',       '', msg.IMAGE_REQUIRED),
         ]
         # Create basic files (config.py, Install.py, etc)
         self.generateTool()
@@ -229,10 +231,10 @@ class Generator(AbstractGenerator):
 
     ploneRoles = ('Manager', 'Member', 'Owner', 'Reviewer')
     def getAllUsedRoles(self, appOnly=False):
-        '''Produces a list of all the roles used within all workflows defined
-           in this application. If p_appOnly is True, it returns only roles
-           which are specific to this application (ie it removes predefined
-           Plone roles like Member, Manager, etc.'''
+        '''Produces a list of all the roles used within all workflows and
+           classes defined in this application. If p_appOnly is True, it
+           returns only roles which are specific to this application (ie it
+           removes predefined Plone roles like Member, Manager, etc.'''
         res = []
         for wfDescr in self.workflows:
             # Browse states and transitions
@@ -241,6 +243,8 @@ class Generator(AbstractGenerator):
                 if isinstance(attrValue, State) or \
                    isinstance(attrValue, Transition):
                     res += attrValue.getUsedRoles()
+        for cDescr in self.getClasses(include='all'):
+            res += cDescr.getCreators()
         res = list(set(res))
         if appOnly:
             for ploneRole in self.ploneRoles:
@@ -259,28 +263,22 @@ class Generator(AbstractGenerator):
         elif issubclass(k, appy.gen.Flavour):
             refClassName = '%sFlavour' % self.applicationName
         else:
-            refClassName = ArchetypesClassDescriptor.getClassName(k)
+            refClassName = ClassDescriptor.getClassName(k)
         if not self.referers.has_key(refClassName):
             self.referers[refClassName] = []
         self.referers[refClassName].append( (fieldDescr, relationship))
 
+    def getAppyTypePath(self, name, appyType, klass, isBack=False):
+        '''Gets the path to the p_appyType when a direct reference to an
+           appyType must be generated in a Python file.'''
+        if issubclass(klass, ModelClass):
+            res = 'wraps.%s.%s' % (klass.__name__, name)
+        else:
+            res = '%s.%s.%s' % (klass.__module__, klass.__name__, name)
+        if isBack: res += '.back'
+        return res
+
     def generateConfig(self):
-        # Compute referers
-        referers = ''
-        for className, refInfo in self.referers.iteritems():
-            referers += '"%s":[' % className
-            for fieldDescr, relationship in refInfo:
-                refClass = fieldDescr.classDescr.klass
-                if issubclass(refClass, ModelClass):
-                    refClassName = 'Extensions.appyWrappers.%s' % \
-                                   refClass.__name__
-                else:
-                    refClassName = '%s.%s' % (refClass.__module__,
-                                              refClass.__name__)
-                referers += '(%s.%s' % (refClassName, fieldDescr.fieldName)
-                referers += ',"%s"' % relationship
-                referers += '),'
-            referers += '],\n'
         # Compute workflow instances initialisation
         wfInit = ''
         for workflowDescr in self.workflows:
@@ -301,21 +299,11 @@ class Generator(AbstractGenerator):
             wfInit += 'workflowInstances[%s] = wf\n' % className
         # Compute imports
         imports = ['import %s' % self.applicationName]
-        classDescrs = self.classes[:]
-        if self.customToolDescr:
-            classDescrs.append(self.customToolDescr)
-        if self.customFlavourDescr:
-            classDescrs.append(self.customFlavourDescr)
+        classDescrs = self.getClasses(include='custom')
         for classDescr in (classDescrs + self.workflows):
             theImport = 'import %s' % classDescr.klass.__module__
             if theImport not in imports:
                 imports.append(theImport)
-        # Compute ordered lists of attributes for every Appy class.
-        attributes = []
-        for classDescr in classDescrs:
-            classAttrs = [a[0] for a in classDescr.getOrderedAppyAttributes()]
-            attrs = ','.join([('"%s"' % a) for a in classAttrs])
-            attributes.append('"%s":[%s]' % (classDescr.name, attrs))
         # Compute root classes
         rootClasses = ''
         for classDescr in self.classes:
@@ -327,14 +315,49 @@ class Generator(AbstractGenerator):
             addPermissions += '    "%s":"%s: Add %s",\n' % (classDescr.name,
                 self.applicationName, classDescr.name)
         repls = self.repls.copy()
+        # Compute the list of ordered attributes (foward and backward, inherited
+        # included) for every Appy class.
+        attributes = []
+        attributesDict = []
+        for classDescr in self.getClasses(include='all'):
+            titleFound = False
+            attrs = []
+            attrNames = []
+            for name, appyType, klass in classDescr.getOrderedAppyAttributes():
+                attrs.append(self.getAppyTypePath(name, appyType, klass))
+                attrNames.append(name)
+                if name == 'title': titleFound = True
+            # Add the "title" mandatory field if not found
+            if not titleFound:
+                attrs.insert(0, 'copy.deepcopy(appy.gen.title)')
+                attrNames.insert(0, 'title')
+            # Any backward attributes to append?
+            if classDescr.name in self.referers:
+                for field, rel in self.referers[classDescr.name]:
+                    try:
+                        getattr(field.classDescr.klass, field.fieldName)
+                        klass = field.classDescr.klass
+                    except AttributeError:
+                        klass = field.classDescr.modelClass
+                    attrs.append(self.getAppyTypePath(field.fieldName,
+                        field.appyType, klass, isBack=True))
+                    attrNames.append(field.appyType.back.attribute)
+            attributes.append('"%s":[%s]' % (classDescr.name,','.join(attrs)))
+            aDict = ''
+            i = -1
+            for attr in attrs:
+                i += 1
+                aDict += '"%s":attributes["%s"][%d],' % \
+                         (attrNames[i], classDescr.name, i)
+            attributesDict.append('"%s":{%s}' % (classDescr.name, aDict))
         # Compute list of used roles for registering them if needed
         repls['roles'] = ','.join(['"%s"' % r for r in \
                                   self.getAllUsedRoles(appOnly=True)])
         repls['rootClasses'] = rootClasses
-        repls['referers'] = referers
         repls['workflowInstancesInit'] = wfInit
         repls['imports'] = '\n'.join(imports)
         repls['attributes'] = ',\n    '.join(attributes)
+        repls['attributesDict'] = ',\n    '.join(attributesDict)
         repls['defaultAddRoles'] = ','.join(
             ['"%s"' % r for r in self.config.defaultCreators])
         repls['addPermissions'] = addPermissions
@@ -342,15 +365,16 @@ class Generator(AbstractGenerator):
 
     def generateInit(self):
         # Compute imports
-        imports = ['    import %s' % self.toolName,
-                   '    import %s' % self.flavourName,
-                   '    import %s' % self.podTemplateName]
-        for c in self.classes:
+        imports = []
+        classNames = []
+        for c in self.getClasses(include='all'):
             importDef = '    import %s' % c.name
             if importDef not in imports:
                 imports.append(importDef)
+                classNames.append("%s.%s" % (c.name, c.name))
         repls = self.repls.copy()
         repls['imports'] = '\n'.join(imports)
+        repls['classes'] = ','.join(classNames)
         repls['totalNumberOfTests'] = self.totalNumberOfTests
         self.copyFile('__init__.py', repls)
 
@@ -380,12 +404,7 @@ class Generator(AbstractGenerator):
                           "['portal_catalog']\n" % blackClass
         # Compute workflows
         workflows = ''
-        allClasses = self.classes[:]
-        if self.customToolDescr:
-            allClasses.append(self.customToolDescr)
-        if self.customFlavourDescr:
-            allClasses.append(self.customFlavourDescr)
-        for classDescr in allClasses:
+        for classDescr in self.getClasses(include='all'):
             if hasattr(classDescr.klass, 'workflow'):
                 wfName = WorkflowDescriptor.getWorkflowName(
                     classDescr.klass.workflow)
@@ -437,41 +456,31 @@ class Generator(AbstractGenerator):
         repls['workflows'] = workflows
         self.copyFile('workflows.py', repls, destFolder='Extensions')
 
-    def generateWrapperProperty(self, attrName, appyType):
-        '''Generates the getter for attribute p_attrName having type
-           p_appyType.'''
-        res = '    def get_%s(self):\n' % attrName
-        blanks = ' '*8
-        getterName = 'get%s%s' % (attrName[0].upper(), attrName[1:])
-        if isinstance(appyType, Ref):
-            res += blanks + 'return self.o._appy_getRefs("%s", ' \
-                   'noListIfSingleObj=True).objects\n' % attrName
-        elif isinstance(appyType, Computed):
-            res += blanks + 'appyType = getattr(self.klass, "%s")\n' % attrName
-            res += blanks + 'return self.o.getComputedValue(' \
-                            'appyType.__dict__)\n'
-        elif isinstance(appyType, File):
-            res += blanks + 'v = self.o.%s()\n' % getterName
-            res += blanks + 'if not v: return None\n'
-            res += blanks + 'else: return FileWrapper(v)\n'
-        elif isinstance(appyType, String) and appyType.isMultiValued():
-            res += blanks + 'return list(self.o.%s())\n' % getterName
+    def generateWrapperProperty(self, name):
+        '''Generates the getter for attribute p_name.'''
+        res = '    def get_%s(self):\n        ' % name
+        if name == 'title':
+            res += 'return self.o.Title()\n'
         else:
-            if attrName in ArchetypeFieldDescriptor.specialParams:
-                getterName = attrName.capitalize()
-            res += blanks + 'return self.o.%s()\n' % getterName
-        res += '    %s = property(get_%s)\n\n' % (attrName, attrName)
+            res += 'return self.o.getAppyType("%s").getValue(self.o)\n' % name
+        res += '    %s = property(get_%s)\n\n' % (name, name)
         return res
 
-    def generateWrapperPropertyBack(self, attrName, rel):
-        '''Generates a wrapper property for accessing the back reference named
-           p_attrName through Archetypes relationship p_rel.'''
-        res = '    def get_%s(self):\n' % attrName
-        blanks = ' '*8
-        res += blanks + 'return self.o._appy_getRefsBack("%s", "%s", ' \
-                   'noListIfSingleObj=True)\n' % (attrName, rel)
-        res += '    %s = property(get_%s)\n\n' % (attrName, attrName)
-        return res
+    def getClasses(self, include=None):
+        '''Returns the descriptors for all the classes in the generated
+           gen-application. If p_include is "all", it includes the descriptors
+           for the config-related classes (tool, flavour, etc); if
+           p_include is "custom", it includes descriptors for the
+           config-related classes for which the user has created a sub-class.'''
+        if not include: return self.classes
+        else:
+            res = self.classes[:]
+            configClasses = [self.tool, self.flavour, self.podTemplate]
+            if include == 'all':
+                res += configClasses
+            elif include == 'custom':
+                res += [c for c in configClasses if c.customized]
+            return res
 
     def getClassesInOrder(self, allClasses):
         '''When generating wrappers, classes mut be dumped in order (else, it
@@ -506,60 +515,48 @@ class Generator(AbstractGenerator):
         # We must generate imports and wrapper definitions
         imports = []
         wrappers = []
-        allClasses = self.classes[:]
-        # Add predefined classes (Tool, Flavour, PodTemplate)
-        allClasses += [self.toolDescr, self.flavourDescr, self.podTemplateDescr]
-        if self.customToolDescr:
-            allClasses.append(self.customToolDescr)
-        if self.customFlavourDescr:
-            allClasses.append(self.customFlavourDescr)
+        allClasses = self.getClasses(include='all')
         for c in self.getClassesInOrder(allClasses):
-            if not c.predefined:
+            if not c.predefined or c.customized:
                 moduleImport = 'import %s' % c.klass.__module__
                 if moduleImport not in imports:
                     imports.append(moduleImport)
             # Determine parent wrapper and class
-            parentWrapper = 'AbstractWrapper'
-            parentClass = '%s.%s' % (c.klass.__module__, c.klass.__name__)
-            if c.predefined:
-                parentClass = c.klass.__name__
-            if c.klass.__bases__:
-                baseClassName = c.klass.__bases__[0].__name__
-                for k in allClasses:
-                    if k.klass.__name__ == baseClassName:
-                        parentWrapper = '%s_Wrapper' % k.name
-            wrapperDef = 'class %s_Wrapper(%s, %s):\n' % \
-                         (c.name, parentWrapper, parentClass)
+            parentClasses = c.getParents(allClasses)
+            wrapperDef = 'class %s_Wrapper(%s):\n' % \
+                         (c.name, ','.join(parentClasses))
             wrapperDef += '    security = ClassSecurityInfo()\n'
             titleFound = False
             for attrName in c.orderedAttributes:
                 if attrName == 'title':
                     titleFound = True
-                attrValue = getattr(c.klass, attrName)
+                try:
+                    attrValue = getattr(c.klass, attrName)
+                except AttributeError:
+                    attrValue = getattr(c.modelClass, attrName)
                 if isinstance(attrValue, Type):
-                    wrapperDef += self.generateWrapperProperty(attrName,
-                                                               attrValue)
+                    wrapperDef += self.generateWrapperProperty(attrName)
             # Generate properties for back references
             if self.referers.has_key(c.name):
                 for refDescr, rel in self.referers[c.name]:
                     attrName = refDescr.appyType.back.attribute
-                    wrapperDef += self.generateWrapperPropertyBack(attrName,rel)
+                    wrapperDef += self.generateWrapperProperty(attrName)
             if not titleFound:
                 # Implicitly, the title will be added by Archetypes. So I need
                 # to define a property for it.
-                wrapperDef += self.generateWrapperProperty('title', String())
-            if isinstance(c, CustomToolClassDescriptor) or \
-               isinstance(c, CustomFlavourClassDescriptor):
+                wrapperDef += self.generateWrapperProperty('title')
+            if c.customized:
                 # For custom tool and flavour, add a call to a method that
                 # allows to customize elements from the base class.
                 wrapperDef += "    if hasattr(%s, 'update'):\n        " \
-                    "%s.update(%s.__bases__[1])\n" % (
-                    parentClass, parentClass, parentWrapper)
+                    "%s.update(%s)\n" % (parentClasses[1], parentClasses[1],
+                                         parentClasses[0])
                 # For custom tool and flavour, add security declaration that
                 # will allow to call their methods from ZPTs.
-                wrapperDef += "    for elem in dir(%s):\n        " \
-                    "if not elem.startswith('_'): security.declarePublic" \
-                    "(elem)\n" % (parentClass)
+                for parentClass in parentClasses:
+                    wrapperDef += "    for elem in dir(%s):\n        " \
+                        "if not elem.startswith('_'): security.declarePublic" \
+                        "(elem)\n" % (parentClass)
             # Register the class in Zope.
             wrapperDef += 'InitializeClass(%s_Wrapper)\n' % c.name
             wrappers.append(wrapperDef)
@@ -587,20 +584,12 @@ class Generator(AbstractGenerator):
         repls = self.repls.copy()
         # Manage predefined fields
         Tool.flavours.klass = Flavour
-        if self.customFlavourDescr:
-            Tool.flavours.klass = self.customFlavourDescr.klass
-        self.toolDescr.generateSchema()
-        repls['predefinedFields'] = self.toolDescr.schema
-        repls['predefinedMethods'] = self.toolDescr.methods
-        # Manage custom fields
-        repls['fields'] = ''
-        repls['methods'] = ''
-        repls['wrapperClass'] = '%s_Wrapper' % self.toolDescr.name
-        if self.customToolDescr:
-            repls['fields'] = self.customToolDescr.schema
-            repls['methods'] = self.customToolDescr.methods
-            wrapperClass = '%s_Wrapper' % self.customToolDescr.name
-            repls['wrapperClass'] = wrapperClass
+        if self.flavour.customized:
+            Tool.flavours.klass = self.flavour.klass
+        self.tool.generateSchema()
+        repls['fields'] = self.tool.schema
+        repls['methods'] = self.tool.methods
+        repls['wrapperClass'] = '%s_Wrapper' % self.tool.name
         self.copyFile('ToolTemplate.py', repls, destName='%s.py'% self.toolName)
         repls = self.repls.copy()
         # Create i18n-related messages
@@ -623,35 +612,32 @@ class Generator(AbstractGenerator):
                 importMean = classDescr.getCreateMean('Import')
                 if importMean:
                     Flavour._appy_addImportRelatedFields(classDescr)
-        Flavour._appy_addWorkflowFields(self.flavourDescr)
-        Flavour._appy_addWorkflowFields(self.podTemplateDescr)
+        Flavour._appy_addWorkflowFields(self.flavour)
+        Flavour._appy_addWorkflowFields(self.podTemplate)
+        # Complete self.flavour.orderedAttributes from the attributes that we
+        # just added to the Flavour model class.
+        for fieldName in Flavour._appy_attributes:
+            if fieldName not in self.flavour.orderedAttributes:
+                self.flavour.orderedAttributes.append(fieldName)
         # Generate the flavour class and related i18n messages
-        self.flavourDescr.generateSchema()
+        self.flavour.generateSchema()
         self.labels += [ Msg(self.flavourName, '', Msg.FLAVOUR),
                          Msg('%s_edit_descr' % self.flavourName, '', ' ')]
         repls = self.repls.copy()
-        repls['predefinedFields'] = self.flavourDescr.schema
-        repls['predefinedMethods'] = self.flavourDescr.methods
-        # Manage custom fields
-        repls['fields'] = ''
-        repls['methods'] = ''
-        repls['wrapperClass'] = '%s_Wrapper' % self.flavourDescr.name
-        if self.customFlavourDescr:
-            repls['fields'] = self.customFlavourDescr.schema
-            repls['methods'] = self.customFlavourDescr.methods
-            wrapperClass = '%s_Wrapper' % self.customFlavourDescr.name
-            repls['wrapperClass'] = wrapperClass
+        repls['fields'] = self.flavour.schema
+        repls['methods'] = self.flavour.methods
+        repls['wrapperClass'] = '%s_Wrapper' % self.flavour.name
         repls['metaTypes'] = [c.name for c in self.classes]
         self.copyFile('FlavourTemplate.py', repls,
                       destName='%s.py'% self.flavourName)
         # Generate the PodTemplate class
-        self.podTemplateDescr.generateSchema()
+        self.podTemplate.generateSchema()
         self.labels += [ Msg(self.podTemplateName, '', Msg.POD_TEMPLATE),
                          Msg('%s_edit_descr' % self.podTemplateName, '', ' ')]
         repls = self.repls.copy()
-        repls['fields'] = self.podTemplateDescr.schema
-        repls['methods'] = self.podTemplateDescr.methods
-        repls['wrapperClass'] = '%s_Wrapper' % self.podTemplateDescr.name
+        repls['fields'] = self.podTemplate.schema
+        repls['methods'] = self.podTemplate.methods
+        repls['wrapperClass'] = '%s_Wrapper' % self.podTemplate.name
         self.copyFile('PodTemplate.py', repls,
                         destName='%s.py' % self.podTemplateName)
 
@@ -676,7 +662,7 @@ class Generator(AbstractGenerator):
         implements = [baseClass]
         for baseClass in classDescr.klass.__bases__:
             if self.determineAppyType(baseClass) == 'class':
-                bcName = ArchetypesClassDescriptor.getClassName(baseClass)
+                bcName = ClassDescriptor.getClassName(baseClass)
                 parents.remove('ClassMixin')
                 parents.append(bcName)
                 implements.append(bcName)
@@ -695,6 +681,7 @@ class Generator(AbstractGenerator):
         if classDescr.isAbstract():
             register = ''
         repls = self.repls.copy()
+        classDescr.generateSchema()
         repls.update({
           'imports': '\n'.join(imports), 'parents': parents,
           'className': classDescr.klass.__name__,

gen/plone25/installer.py

@@ -6,9 +6,15 @@ import os, os.path, time
 from StringIO import StringIO
 from sets import Set
 import appy
+from appy.gen import Type, Ref
 from appy.gen.utils import produceNiceMessage
 from appy.gen.plone25.utils import updateRolesForPermission
 
+class ZCTextIndexInfo:
+    '''Silly class used for storing information about a ZCTextIndex.'''
+    lexicon_id = "plone_lexicon"
+    index_type = 'Okapi BM25 Rank'
+
 class PloneInstaller:
     '''This Plone installer runs every time the generated Plone product is
        installed or uninstalled (in the Plone configuration interface).'''
@@ -45,6 +51,28 @@ class PloneInstaller:
         self.toolName = '%sTool' % self.productName
         self.toolInstanceName = 'portal_%s' % self.productName.lower()
 
+    @staticmethod
+    def updateIndexes(ploneSite, indexInfo, logger):
+        '''This method creates or updates, in a p_ploneSite, definitions of
+           indexes in its portal_catalog, based on index-related information
+           given in p_indexInfo. p_indexInfo is a dictionary of the form
+           {s_indexName:s_indexType}. Here are some examples of index types:
+           "FieldIndex", "ZCTextIndex", "DateIndex".'''
+        catalog = ploneSite.portal_catalog
+        indexNames = catalog.indexes()
+        for indexName, indexType in indexInfo.iteritems():
+            if indexName not in indexNames:
+                # We need to create this index
+                if indexType != 'ZCTextIndex':
+                    catalog.addIndex(indexName, indexType)
+                else:
+                    catalog.addIndex(indexName,indexType,extra=ZCTextIndexInfo)
+                # Indexing database content based on this index.
+                catalog.reindexIndex(indexName, ploneSite.REQUEST)
+                logger.info('Created index "%s" of type "%s"...' % \
+                            (indexName, indexType))
+        # TODO: if the index already exists but has not the same type, we
+        # re-create it with the same type and we reindex it.
 
     actionsToHide = {
         'portal_actions': ('sitemap', 'accessibility', 'change_state','sendto'),
@@ -235,18 +263,17 @@ class PloneInstaller:
                                     title=produceNiceMessage(templateName))
                                 f.close()
         # Creates the new-way templates for Pod fields if they do not exist.
-        for contentType, attrNames in self.attributes.iteritems():
+        for contentType, appyTypes in self.attributes.iteritems():
             appyClass = self.tool.getAppyClass(contentType)
             if not appyClass: continue # May be an abstract class
-            for attrName in attrNames:
-                appyType = getattr(appyClass, attrName)
+            for appyType in appyTypes:
                 if appyType.type == 'Pod':
                     # For every flavour, find the attribute that stores the
                     # template, and store on it the default one specified in
                     # the appyType if no template is stored yet.
                     for flavour in self.appyTool.flavours:
                         attrName = flavour.getAttributeName(
-                            'podTemplate', appyClass, attrName)
+                            'podTemplate', appyClass, appyType.name)
                         fileObject = getattr(flavour, attrName)
                         if not fileObject or (fileObject.size == 0):
                             # There is no file. Put the one specified in the
@@ -298,9 +325,9 @@ class PloneInstaller:
         self.tool = getattr(self.ploneSite, self.toolInstanceName)
         self.appyTool = self.tool.appy()
         if self.reinstall:
-            self.tool.createOrUpdate(False)
+            self.tool.createOrUpdate(False, None)
         else:
-            self.tool.createOrUpdate(True)
+            self.tool.createOrUpdate(True, None)
 
         if not self.appyTool.flavours:
             # Create the default flavour
@@ -324,9 +351,9 @@ class PloneInstaller:
             self.productName, None)
 
     def installRolesAndGroups(self):
-        '''Registers roles used by workflows defined in this application if
-           they are not registered yet. Creates the corresponding groups if
-           needed.'''
+        '''Registers roles used by workflows and classes defined in this
+           application if they are not registered yet. Creates the corresponding
+           groups if needed.'''
         site = self.ploneSite
         data = list(site.__ac_roles__)
         for role in self.applicationRoles:
@@ -412,6 +439,22 @@ class PloneInstaller:
         if self.minimalistPlone:
             site.manage_changeProperties(right_slots=())
 
+    def manageIndexes(self):
+        '''For every indexed field, this method installs and updates the
+           corresponding index if it does not exist yet.'''
+        indexInfo = {}
+        for className, appyTypes in self.attributes.iteritems():
+            for appyType in appyTypes:
+                if appyType.indexed:
+                    n = appyType.name
+                    indexName = 'get%s%s' % (n[0].upper(), n[1:])
+                    indexType = 'FieldIndex'
+                    if (appyType.type == 'String') and appyType.isSelect:
+                        indexType = 'ZCTextIndex'
+                    indexInfo[indexName] = indexType
+        if indexInfo:
+            PloneInstaller.updateIndexes(self.ploneSite, indexInfo, self)
+
     def finalizeInstallation(self):
         '''Performs some final installation steps.'''
         site = self.ploneSite
@@ -435,7 +478,8 @@ class PloneInstaller:
             frontPageName = self.productName + 'FrontPage'
             site.manage_changeProperties(default_page=frontPageName)
 
-    def log(self, msg): print >> self.toLog, msg
+    def log(self, msg): print msg
+    def info(self, msg): return self.log(msg)
 
     def install(self):
         self.log("Installation of %s:" % self.productName)
@@ -447,9 +491,9 @@ class PloneInstaller:
         self.installWorkflows()
         self.installStyleSheet()
         self.managePortlets()
+        self.manageIndexes()
         self.finalizeInstallation()
         self.log("Installation of %s done." % self.productName)
-        return self.toLog.getvalue()
 
     def uninstallTool(self):
         site = self.ploneSite
@@ -502,7 +546,7 @@ class ZopeInstaller:
        generated Zope product.'''
     def __init__(self, zopeContext, productName, toolClass,
                  defaultAddContentPermission, addContentPermissions,
-                 logger, ploneStuff):
+                 logger, ploneStuff, classes):
         self.zopeContext = zopeContext
         self.productName = productName
         self.toolClass = toolClass
@@ -510,6 +554,22 @@ class ZopeInstaller:
         self.addContentPermissions = addContentPermissions
         self.logger = logger
         self.ploneStuff = ploneStuff # A dict of some Plone functions or vars
+        self.classes = classes
+
+    def completeAppyTypes(self):
+        '''We complete here the initialisation process of every Appy type of
+           every gen-class of the application.'''
+        for klass in self.classes:
+            for baseClass in klass.wrapperClass.__bases__:
+                for name, appyType in baseClass.__dict__.iteritems():
+                    if isinstance(appyType, Type):
+                        appyType.init(name, baseClass, self.productName)
+                    # Do not forget back references
+                    if isinstance(appyType, Ref):
+                        bAppyType = appyType.back
+                        bAppyType.init(bAppyType.attribute, appyType.klass,
+                                       self.productName)
+                        bAppyType.klass = baseClass
 
     def installApplication(self):
         '''Performs some application-wide installation steps.'''
@@ -562,6 +622,7 @@ class ZopeInstaller:
 
     def install(self):
         self.logger.info('is being installed...')
+        self.completeAppyTypes()
         self.installApplication()
         self.installTool()
         self.installTypes()

gen/plone25/mixins/ClassMixin.py

@@ -3,40 +3,5 @@ from appy.gen.plone25.mixins import AbstractMixin
 
 # ------------------------------------------------------------------------------
 class ClassMixin(AbstractMixin):
-    _appy_meta_type = 'class'
-    def _appy_fieldIsUsed(self, portalTypeName, fieldName):
-        tool = self.getTool()
-        flavour = tool.getFlavour(portalTypeName)
-        optionalFieldsAccessor = 'getOptionalFieldsFor%s' % self.meta_type
-        exec 'usedFields = flavour.%s()' % optionalFieldsAccessor
-        res = False
-        if fieldName in usedFields:
-            res = True
-        return res
-
-    def _appy_getDefaultValueFor(self, portalTypeName, fieldName):
-        tool = self.getTool()
-        flavour = tool.getFlavour(portalTypeName)
-        fieldFound = False
-        klass = self.__class__
-        while not fieldFound:
-            metaType = klass.meta_type
-            defValueAccessor = 'getDefaultValueFor%s_%s' % (metaType, fieldName)
-            if not hasattr(flavour, defValueAccessor):
-                # The field belongs to a super-class.
-                klass = klass.__bases__[-1]
-            else:
-                fieldFound = True
-        exec 'res = flavour.%s()' % defValueAccessor
-        return res
-
-    def fieldIsUsed(self, fieldName):
-        '''Checks in the corresponding flavour if p_fieldName is used.'''
-        portalTypeName = self._appy_getPortalType(self.REQUEST)
-        return self._appy_fieldIsUsed(portalTypeName, fieldName)
-
-    def getDefaultValueFor(self, fieldName):
-        '''Gets in the flavour the default value for p_fieldName.'''
-        portalTypeName = self._appy_getPortalType(self.REQUEST)
-        return self._appy_getDefaultValueFor(portalTypeName,fieldName)
+    _appy_meta_type = 'Class'
 # ------------------------------------------------------------------------------

gen/plone25/mixins/FlavourMixin.py

@@ -8,7 +8,7 @@ from appy.pod.renderer import Renderer
 import appy.gen
 from appy.gen import Type
 from appy.gen.plone25.mixins import AbstractMixin
-from appy.gen.plone25.descriptors import ArchetypesClassDescriptor
+from appy.gen.plone25.descriptors import ClassDescriptor
 
 # Errors -----------------------------------------------------------------------
 DELETE_TEMP_DOC_ERROR = 'A temporary document could not be removed. %s.'
@@ -17,7 +17,7 @@ POD_ERROR = 'An error occurred while generating the document. Please ' \
 
 # ------------------------------------------------------------------------------
 class FlavourMixin(AbstractMixin):
-    _appy_meta_type = 'flavour'
+    _appy_meta_type = 'Flavour'
     def getPortalType(self, metaTypeOrAppyType):
         '''Returns the name of the portal_type that is based on
            p_metaTypeOrAppyType in this flavour.'''
@@ -26,7 +26,7 @@ class FlavourMixin(AbstractMixin):
         isAppy = False
         appName = self.getProductConfig().PROJECTNAME
         if not isinstance(res, basestring):
-            res = ArchetypesClassDescriptor.getClassName(res)
+            res = ClassDescriptor.getClassName(res)
             isAppy = True
         if res.find('Extensions_appyWrappers') != -1:
             isPredefined = True
@@ -41,8 +41,9 @@ class FlavourMixin(AbstractMixin):
             isPredefined = True
             res = '%sFlavour' % appName
         if not isPredefined:
-            if self.getNumber() != 1:
-                res = '%s_%d' % (res, self.number)
+            number = self.appy().number
+            if number != 1:
+                res = '%s_%d' % (res, number)
         return res
 
     def registerPortalTypes(self):
@@ -129,9 +130,9 @@ class FlavourMixin(AbstractMixin):
         n = appyFlavour.getAttributeName('podTemplate', appyClass, fieldName)
         res['template'] = getattr(appyFlavour, n)
         appyType = ploneObj.getAppyType(fieldName)
-        res['title'] = self.translate(appyType['label'])
-        res['context'] = appyType['context']
-        res['action'] = appyType['action']
+        res['title'] = self.translate(appyType.labelId)
+        res['context'] = appyType.context
+        res['action'] = appyType.action
         return res
 
     def generateDocument(self):
@@ -225,18 +226,18 @@ class FlavourMixin(AbstractMixin):
             appyTool.log(DELETE_TEMP_DOC_ERROR % str(ie), type='warning')
         return res
 
-    def getAttr(self, attrName):
+    def getAttr(self, name):
         '''Gets on this flavour attribute named p_attrName. Useful because we
            can't use getattr directly in Zope Page Templates.'''
-        return getattr(self, attrName, None)
+        return getattr(self.appy(), name, None)
 
     def _appy_getAllFields(self, contentType):
         '''Returns the (translated) names of fields of p_contentType.'''
         res = []
-        for attrName in self.getProductConfig().attributes[contentType]:
-            if attrName != 'title': # Will be included by default.
-                label = '%s_%s' % (contentType, attrName)
-                res.append((attrName, self.translate(label)))
+        for appyType in self.getProductConfig().attributes[contentType]:
+            if appyType.name != 'title': # Will be included by default.
+                label = '%s_%s' % (contentType, appyType.name)
+                res.append((appyType.name, self.translate(label)))
         # Add object state
         res.append(('workflowState', self.translate('workflow_state')))
         return res
@@ -244,15 +245,10 @@ class FlavourMixin(AbstractMixin):
     def _appy_getSearchableFields(self, contentType):
         '''Returns the (translated) names of fields that may be searched on
            objects of type p_contentType (=indexed fields).'''
-        tool = self.getParentNode()
-        appyClass = tool.getAppyClass(contentType)
-        attrNames = self.getProductConfig().attributes[contentType]
         res = []
-        for attrName in attrNames:
-            attr = getattr(appyClass, attrName)
-            if isinstance(attr, Type) and attr.indexed:
-                label = '%s_%s' % (contentType, attrName)
-                res.append((attrName, self.translate(label)))
+        for appyType in self.getProductConfig().attributes[contentType]:
+            if appyType.indexed:
+                res.append((appyType.name, self.translate(appyType.labelId)))
         return res
 
     def getSearchableFields(self, contentType):
@@ -260,11 +256,10 @@ class FlavourMixin(AbstractMixin):
            the list of fields that the user has configured in the flavour as
            being effectively used in the search screen.'''
         res = []
-        appyClass = self.getAppyClass(contentType)
-        for attrName in getattr(self, 'searchFieldsFor%s' % contentType, ()):
-            attr = getattr(appyClass, attrName)
-            dAttr = self._appy_getTypeAsDict(attrName, attr, appyClass)
-            res.append((attrName, dAttr))
+        fieldNames = getattr(self.appy(), 'searchFieldsFor%s' % contentType, ())
+        for name in fieldNames:
+            appyType = self.getAppyType(name, asDict=True,className=contentType)
+            res.append(appyType)
         return res
 
     def getImportElements(self, contentType):

gen/plone25/mixins/PodTemplateMixin.py

@@ -3,5 +3,5 @@ from appy.gen.plone25.mixins import AbstractMixin
 
 # ------------------------------------------------------------------------------
 class PodTemplateMixin(AbstractMixin):
-    _appy_meta_type = 'podtemplate'
+    _appy_meta_type = 'PodTemplate'
 # ------------------------------------------------------------------------------

gen/plone25/mixins/ToolMixin.py

@@ -1,40 +1,18 @@
 # ------------------------------------------------------------------------------
 import re, os, os.path, Cookie
+from appy.shared.utils import getOsTempFolder
 from appy.gen import Type, Search, Selection
-from appy.gen.utils import FieldDescr, SomeObjects, sequenceTypes
+from appy.gen.utils import SomeObjects, sequenceTypes
 from appy.gen.plone25.mixins import AbstractMixin
 from appy.gen.plone25.mixins.FlavourMixin import FlavourMixin
 from appy.gen.plone25.wrappers import AbstractWrapper
-from appy.gen.plone25.descriptors import ArchetypesClassDescriptor
+from appy.gen.plone25.descriptors import ClassDescriptor
 
-_PY = 'Please specify a file corresponding to a Python interpreter ' \
-      '(ie "/usr/bin/python").'
-FILE_NOT_FOUND = 'Path "%s" was not found.'
-VALUE_NOT_FILE = 'Path "%s" is not a file. ' + _PY
-NO_PYTHON = "Name '%s' does not starts with 'python'. " + _PY
-NOT_UNO_ENABLED_PYTHON = '"%s" is not a UNO-enabled Python interpreter. ' \
-                         'To check if a Python interpreter is UNO-enabled, ' \
-                         'launch it and type "import uno". If you have no ' \
-                         'ImportError exception it is ok.'
 jsMessages = ('no_elem_selected', 'delete_confirm')
 
 # ------------------------------------------------------------------------------
 class ToolMixin(AbstractMixin):
-    _appy_meta_type = 'tool'
-    def _appy_validateUnoEnabledPython(self, value):
-        '''This method represents the validator for field unoEnabledPython.
-           This field is present on the Tool only if POD is needed.'''
-        if value:
-            if not os.path.exists(value):
-                return FILE_NOT_FOUND % value
-            if not os.path.isfile(value):
-                return VALUE_NOT_FILE % value
-            if not os.path.basename(value).startswith('python'):
-                return NO_PYTHON % value
-            if os.system('%s -c "import uno"' % value):
-                return NOT_UNO_ENABLED_PYTHON % value
-        return None
-
+    _appy_meta_type = 'Tool'
     def getFlavour(self, contextObjOrPortalType, appy=False):
         '''Gets the flavour that corresponds to p_contextObjOrPortalType.'''
         if isinstance(contextObjOrPortalType, basestring):
@@ -102,8 +80,11 @@ class ToolMixin(AbstractMixin):
     def getObject(self, uid, appy=False):
         '''Allows to retrieve an object from its p_uid.'''
         res = self.uid_catalog(UID=uid)
-        if res: return res[0].getObject()
-        return None
+        if res:
+            res = res[0].getObject()
+            if appy:
+                res = res.appy()
+        return res
 
     def executeQuery(self, contentType, flavourNumber=1, searchName=None,
                      startNumber=0, search=None, remember=False,
@@ -133,7 +114,7 @@ class ToolMixin(AbstractMixin):
            useful for some usages like knowing the number of objects without
            needing to get information about them). If no p_maxResults is
            specified, the method returns maximum
-           self.getNumberOfResultsPerPage(). The method returns all objects if
+           self.numberOfResultsPerPage. The method returns all objects if
            p_maxResults equals string "NO_LIMIT".
 
            If p_noSecurity is True, it gets all the objects, even those that the
@@ -163,7 +144,7 @@ class ToolMixin(AbstractMixin):
             # In this case, contentType must contain a single content type.
             appyClass = self.getAppyClass(contentType)
             if searchName != '_advanced':
-                search = ArchetypesClassDescriptor.getSearch(
+                search = ClassDescriptor.getSearch(
                     appyClass, searchName)
             else:
                 fields = self.REQUEST.SESSION['searchCriteria']
@@ -201,7 +182,7 @@ class ToolMixin(AbstractMixin):
             # Return brains only.
             if not maxResults: return brains
             else: return brains[:maxResults]
-        if not maxResults: maxResults = self.getNumberOfResultsPerPage()
+        if not maxResults: maxResults = self.appy().numberOfResultsPerPage
         elif maxResults == 'NO_LIMIT': maxResults = None
         res = SomeObjects(brains, maxResults, startNumber,noSecurity=noSecurity)
         res.brainsToObjects()
@@ -249,26 +230,31 @@ class ToolMixin(AbstractMixin):
     def getResultColumns(self, anObject, contentType):
         '''What columns must I show when displaying a list of root class
            instances? Result is a list of tuples containing the name of the
-           column (=name of the field) and a FieldDescr instance.'''
+           column (=name of the field) and the corresponding appyType (dict
+           version).'''
         res = []
         for fieldName in self.getResultColumnsNames(contentType):
             if fieldName == 'workflowState':
-                # We do not return a FieldDescr instance if the attributes is
-                # not a *real* attribute but the workfow state.
+                # We do not return a appyType if the attribute is not a *real*
+                # attribute, but the workfow state.
                 res.append(fieldName)
             else:
-                # Create a FieldDescr instance
-                appyType = anObject.getAppyType(fieldName)
+                appyType = anObject.getAppyType(fieldName, asDict=True)
                 if not appyType:
-                    res.append({'atField': None, 'name': fieldName})
+                    res.append({'name': fieldName, '_wrong': True})
                     # The field name is wrong.
                     # We return it so we can show it in an error message.
                 else:
-                    atField = anObject.schema.get(fieldName)
-                    fieldDescr = FieldDescr(atField, appyType, None)
-                    res.append(fieldDescr.get())
+                    res.append(appyType)
         return res
 
+    def truncateValue(self, value, appyType):
+        '''Truncates the p_value according to p_appyType width.'''
+        maxWidth = appyType['width']
+        if len(value) > maxWidth:
+            return value[:maxWidth] + '...'
+        return value
+
     xhtmlToText = re.compile('<.*?>', re.S)
     def getReferenceLabel(self, brain, appyType):
         '''p_appyType is a Ref with link=True. I need to display, on an edit
@@ -288,8 +274,8 @@ class ToolMixin(AbstractMixin):
             elif isinstance(value, basestring):
                 value = value.decode('utf-8')
                 refAppyType = appyObj.o.getAppyType(fieldName)
-                if refAppyType and (refAppyType['type'] == 'String') and \
-                   (refAppyType['format'] == 2):
+                if refAppyType and (refAppyType.type == 'String') and \
+                   (refAppyType.format == 2):
                     value = self.xhtmlToText.sub(' ', value)
             else:
                 value = str(value)
@@ -312,13 +298,21 @@ class ToolMixin(AbstractMixin):
         appName = self.getProductConfig().PROJECTNAME
         return self.utranslate(label, self.translationMapping, domain=appName)
 
-    def getPublishedObject(self):
-        '''Gets the currently published object.'''
+    def getPublishedObject(self, rootClasses):
+        '''Gets the currently published object, if its meta_class is among
+           p_rootClasses or if it is the corresponding tool or flavour.'''
         rq = self.REQUEST
         obj = rq['PUBLISHED']
         parent = obj.getParentNode()
-        if parent.id == 'skyn': return parent.getParentNode()
-        return rq['PUBLISHED']
+        if parent.id == 'skyn':
+            obj = parent.getParentNode()
+        if obj.meta_type in rootClasses:
+            return obj
+        else:
+            appName = self.getAppName()
+            if obj.meta_type in ('%sTool' % appName, '%sFlavour' % appName):
+                return obj
+        return None
 
     def getAppyClass(self, contentType):
         '''Gets the Appy Python class that is related to p_contentType.'''
@@ -359,6 +353,17 @@ class ToolMixin(AbstractMixin):
                     res[means.id] = means.__dict__
         return res
 
+    def userMayAdd(self, rootClass):
+        '''For deciding if a user may add a new instance of a class, beyond the
+           permission-based check, we can have a custom method that proposes an
+           additional condition. This method checks if there is such a custom
+           method (must be named "mayCreate") define on p_rootClass, and calls
+           it if yes. If no, it returns True.'''
+        pythonClass = self.getAppyClass(rootClass)
+        if 'mayCreate' in pythonClass.__dict__:
+            return pythonClass.mayCreate(self.appy())
+        return True
+
     def onImportObjects(self):
         '''This method is called when the user wants to create objects from
            external data.'''
@@ -503,7 +508,7 @@ class ToolMixin(AbstractMixin):
         appyClass = self.getAppyClass(contentType)
         res = []
         visitedGroups = {} # Names of already visited search groups
-        for search in ArchetypesClassDescriptor.getSearches(appyClass):
+        for search in ClassDescriptor.getSearches(appyClass):
             # Determine first group label, we will need it.
             groupLabel = ''
             if search.group:
@@ -610,7 +615,7 @@ class ToolMixin(AbstractMixin):
         if t == 'ref': # Manage navigation from a reference
             fieldName = d2
             masterObj = self.getObject(d1)
-            batchSize = masterObj.getAppyType(fieldName)['maxPerPage']
+            batchSize = masterObj.getAppyType(fieldName).maxPerPage
             uids = getattr(masterObj, '_appy_%s' % fieldName)
             # In the case of a reference, we retrieve ALL surrounding objects.
             
@@ -679,21 +684,18 @@ class ToolMixin(AbstractMixin):
            into a list of lists, where every sub-list has length p_numberOfRows.
            This method is typically used for rendering elements in a table of
            p_numberOfRows rows.'''
-        if numberOfRows > 1:
-            res = []
-            row = []
-            for elem in data:
-                row.append(elem)
-                if len(row) == numberOfRows:
-                    res.append(row)
-                    row = []
-            # Complete the last unfinished line if required.
-            if row:
-                while len(row) < numberOfRows: row.append(None)
+        res = []
+        row = []
+        for elem in data:
+            row.append(elem)
+            if len(row) == numberOfRows:
                 res.append(row)
-            return res
-        else:
-            return data
+                row = []
+        # Complete the last unfinished line if required.
+        if row:
+            while len(row) < numberOfRows: row.append(None)
+            res.append(row)
+        return res
 
     def truncate(self, value, numberOfChars):
         '''Truncates string p_value to p_numberOfChars.'''
@@ -708,22 +710,6 @@ class ToolMixin(AbstractMixin):
         '''Gets the translated month name of month numbered p_monthNumber.'''
         return self.translate(self.monthsIds[int(monthNumber)], domain='plone')
 
-    def getSelectValues(self, appyType):
-        '''Return the possible values (with their translation) of String type
-           p_appyType (dict version) which is a string whose validator limits
-           the possible values, either statically (validator is simply a list
-           of values) or dynamically (validator is a Selection instance).'''
-        validator = appyType['validator']
-        if isinstance(validator, Selection):
-            vocab = self._appy_getDynamicDisplayList(validator.methodName)
-            return vocab.items()
-        else:
-            res = []
-            for v in validator:
-                text = self.translate('%s_list_%s' % (appyType['label'], v))
-                res.append((v, self.truncate(text, 30)))
-        return res
-
     def logout(self):
         '''Logs out the current user when he clicks on "disconnect".'''
         rq = self.REQUEST
@@ -748,4 +734,20 @@ class ToolMixin(AbstractMixin):
         from appy.gen.plone25.installer import loggedUsers
         if loggedUsers.has_key(userId): del loggedUsers[userId]
         return self.goto(self.getParentNode().absolute_url())
+
+    def tempFile(self):
+        '''A temp file has been created in a temp folder. This method returns
+           this file to the browser.'''
+        rq = self.REQUEST
+        baseFolder = os.path.join(getOsTempFolder(), self.getAppName())
+        baseFolder = os.path.join(baseFolder, rq.SESSION.id)
+        fileName   = os.path.join(baseFolder, rq.get('name', ''))
+        if os.path.exists(fileName):
+            f = file(fileName)
+            content = f.read()
+            f.close()
+            # Remove the temp file
+            os.remove(fileName)
+            return content
+        return 'File does not exist'
 # ------------------------------------------------------------------------------

gen/plone25/model.py

@@ -7,7 +7,7 @@
 
 # ------------------------------------------------------------------------------
 import copy, types
-from appy.gen import Type, Integer, String, File, Ref, Boolean, Selection
+from appy.gen import Type, Integer, String, File, Ref, Boolean, Selection, Group
 
 # ------------------------------------------------------------------------------
 class ModelClass:
@@ -17,10 +17,12 @@ class ModelClass:
        prefixed with _appy_ in order to avoid name conflicts with user-defined
        parts of the application model.'''
     _appy_attributes = [] # We need to keep track of attributes order.
-    _appy_notinit = ('id', 'type', 'pythonType', 'slaves', 'selfClass',
-                     'phase', 'pageShow', 'isSelect') # When creating a new
-                     # instance of a ModelClass, those attributes must not be
-                     # given in the constructor.
+    # When creating a new instance of a ModelClass, the following attributes
+    # must not be given in the constructor (they are computed attributes).
+    _appy_notinit = ('id', 'type', 'pythonType', 'slaves', 'phase', 'pageShow',
+                     'isSelect', 'hasLabel', 'hasDescr', 'hasHelp',
+                     'master_css', 'layouts', 'required', 'filterable',
+                     'validable', 'backd', 'isBack')
 
     @classmethod
     def _appy_addField(klass, fieldName, fieldType, classDescr):
@@ -38,8 +40,11 @@ class ModelClass:
                 continue
             if isinstance(attrValue, basestring):
                 attrValue = '"%s"' % attrValue
-            elif isinstance(attrValue, Type):
-                attrValue = klass._appy_getTypeBody(attrValue)
+            elif isinstance(attrValue, Ref):
+                if attrValue.isBack:
+                    attrValue = klass._appy_getTypeBody(attrValue)
+                else:
+                    continue
             elif type(attrValue) == type(ModelClass):
                 moduleName = attrValue.__module__
                 if moduleName.startswith('appy.gen'):
@@ -48,6 +53,10 @@ class ModelClass:
                     attrValue = '%s.%s' % (moduleName, attrValue.__name__)
             elif isinstance(attrValue, Selection):
                 attrValue = 'Selection("%s")' % attrValue.methodName
+            elif isinstance(attrValue, Group):
+                attrValue = 'Group("%s")' % attrValue.name
+            elif type(attrValue) == types.FunctionType:
+                attrValue = '%sWrapper.%s'% (klass.__name__, attrValue.__name__)
             typeArgs += '%s=%s,' % (attrName, attrValue)
         return '%s(%s)' % (appyType.__class__.__name__, typeArgs)
 
@@ -106,10 +115,15 @@ class Flavour(ModelClass):
         '''From a given p_appyType, produce a type definition suitable for
            storing the default value for this field.'''
         res = copy.copy(appyType)
+        # A fiekd in the flavour can't have parameters that would lead to the
+        # creation of new fields in the flavour.
         res.editDefault = False
         res.optional = False
         res.show = True
+        res.group = copy.copy(appyType.group)
         res.phase = 'main'
+        # Set default layouts for all Flavour fields
+        res.layouts = None
         res.specificReadPermission = False
         res.specificWritePermission = False
         res.multiplicity = (0, appyType.multiplicity[1])
@@ -136,7 +150,7 @@ class Flavour(ModelClass):
             klass._appy_addField(fieldName, fieldType, fieldDescr.classDescr)
         fieldType.validator.append(fieldDescr.fieldName)
         fieldType.page = 'data'
-        fieldType.group = fieldDescr.classDescr.klass.__name__
+        fieldType.group = Group(fieldDescr.classDescr.klass.__name__)
 
     @classmethod
     def _appy_addDefaultField(klass, fieldDescr):
@@ -145,7 +159,7 @@ class Flavour(ModelClass):
         fieldType = klass._appy_copyField(fieldDescr.appyType)
         klass._appy_addField(fieldName, fieldType, fieldDescr.classDescr)
         fieldType.page = 'data'
-        fieldType.group = fieldDescr.classDescr.klass.__name__
+        fieldType.group = Group(fieldDescr.classDescr.klass.__name__)
 
     @classmethod
     def _appy_addPodRelatedFields(klass, fieldDescr):
@@ -276,7 +290,9 @@ class Tool(ModelClass):
                    # First arg is None because we don't know yet if it will link
                    # to the predefined Flavour class or a custom class defined
                    # in the application.
-    unoEnabledPython = String(group="connectionToOpenOffice")
+    def validPythonWithUno(self, value): pass
+    unoEnabledPython = String(group="connectionToOpenOffice",
+                              validator=validPythonWithUno)
     openOfficePort = Integer(default=2002, group="connectionToOpenOffice")
     numberOfResultsPerPage = Integer(default=30)
     listBoxesMaximumWidth = Integer(default=100)

gen/plone25/skin/ajax.pt

@@ -4,22 +4,23 @@
   It can also have a parameter "action", that refers to a method that will be triggered on
   contextObj before returning the result of the macro to the browser.
 </tal:comment>
-<tal:ajax define="page request/page;
-                  macro request/macro;
+<tal:ajax define="page       request/page;
+                  macro      request/macro;
                   contextObj context/getParentNode;
-                  action request/action|nothing;
-                  response request/RESPONSE;
-                  member context/portal_membership/getAuthenticatedMember;
-                  portal context/portal_url/getPortalObject;
+                  action     request/action|nothing;
+                  response   request/RESPONSE;
+                  member     context/portal_membership/getAuthenticatedMember;
+                  portal     context/portal_url/getPortalObject;
                   portal_url context/portal_url/getPortalPath;
-                  dummy python:response.setHeader('Content-Type','text/html;;charset=utf-8');
-                  dummy2 python:response.setHeader('Expires', 'Mon, 11 Dec 1975 12:05:05 GMT');
-                  dummy3 python:response.setHeader('CacheControl', 'no-cache')">
+                  template   python: contextObj.getPageTemplate(portal.skyn, page);
+                  dummy      python: response.setHeader('Content-Type','text/html;;charset=utf-8');
+                  dummy2     python: response.setHeader('Expires', 'Mon, 11 Dec 1975 12:05:05 GMT');
+                  dummy3     python: response.setHeader('CacheControl', 'no-cache')">
   <tal:comment replace="nothing">Keys "Expires" and "CacheControl" are used for preventing IE to cache
     this page. Indeed, this page is retrieved through an asynchronous XMLHttpRequest by the browser, and
     IE caches this by default.</tal:comment>
   <tal:executeAction condition="action">
-    <tal:do define="dummy python: contextObj.getAppyValue('on'+action)()" omit-tag=""/>
+    <tal:do define="dummy python: contextObj.getMethod('on'+action)()" omit-tag=""/>
   </tal:executeAction>
-  <metal:callMacro use-macro="python: portal.skyn.get(page).macros.get(macro)"/>
+  <metal:callMacro use-macro="python: template.macros.get(macro)"/>
 </tal:ajax>

gen/plone25/skin/do.py

@@ -12,4 +12,4 @@ else:
         from Products.CMFCore.utils import getToolByName
         portal = getToolByName(obj, 'portal_url').getPortalObject()
         obj = portal.get('portal_%s' % obj.id.lower()) # The tool
-return obj.getAppyValue('on'+action)()
+return obj.getMethod('on'+action)()

gen/plone25/skin/edit.pt

@@ -1,24 +1,18 @@
-<tal:block metal:define-macro="master"
-           define="contextObj python:context.getParentNode();
-                   errors request/errors | python:{};
-                   schematas contextObj/Schemata;
-                   fieldsets python:[key for key in schematas.keys() if (key != 'metadata') and (schematas[key].editableFields(contextObj, visible_only=True))];
-                   default_fieldset python:(not schematas or schematas.has_key('default')) and 'default' or fieldsets[0];
-                   fieldset request/fieldset|options/fieldset|default_fieldset;
-                   fields python:schematas[fieldset].editableFields(contextObj);
-                   lockable python:hasattr(contextObj, 'wl_isLocked');
-                   isLocked python:lockable and contextObj.wl_isLocked();
-                   isEdit python:True;
-                   tool contextObj/getTool;
-                   flavour python: tool.getFlavour(contextObj);
-                   appFolder tool/getAppFolder;
-                   appName appFolder/id;
-                   css python:contextObj.getUniqueWidgetAttr(fields, 'helper_css');
-                   js python:contextObj.getUniqueWidgetAttr(fields, 'helper_js');
-                   phaseInfo python: contextObj.getAppyPhases(fieldset=fieldset, forPlone=True);
-                   phase request/phase|phaseInfo/name;
-                   appyPages python: contextObj.getAppyPages(phase);
-                   pageName python: contextObj.getAppyPage(isEdit, phaseInfo, appyPages);">
+<tal:edit metal:define-macro="master"
+          define="contextObj  python:context.getParentNode();
+                  errors      request/errors | python:{};
+                  layoutType  python:'edit';
+                  layout      python: contextObj.getPageLayout(layoutType);
+                  tool        contextObj/getTool;
+                  flavour     python: tool.getFlavour(contextObj);
+                  appFolder   tool/getAppFolder;
+                  appName     appFolder/getId;
+                  page        request/page|python:'main';
+                  cssAndJs    python: contextObj.getCssAndJs(layoutType, page);
+                  css         python: cssAndJs[0];
+                  js          python: cssAndJs[1];
+                  phaseInfo   python: contextObj.getAppyPhases(page=page);
+                  phase       phaseInfo/name">
 
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"
       xmlns:tal="http://xml.zope.org/namespaces/tal"
@@ -32,80 +26,38 @@
     <div tal:define="dummy python:request.set('disable_border', 1)" />
   </div>
 
-  <tal:comment replace="nothing">Archetypes stuff for managing Javascript and CSS.
-    If I remove this stuff, Javascript popup for dates does not work anyore.</tal:comment>
-  <metal:javascript_head fill-slot="javascript_head_slot">
-    <tal:block define="macro here/archetypes_custom_js/macros/javascript_head | nothing"
-               condition="macro">
-      <metal:block use-macro="macro" />
-    </tal:block>
-    <tal:js condition="js" repeat="item js">
+  <tal:comment replace="nothing">Include type-specific CSS and JS.</tal:comment>
+  <metal:js fill-slot="javascript_head_slot">
+    <tal:js condition="js" repeat="jsFile js">
       <script type="text/javascript" charset="iso-8859-1"
-              tal:condition="python:exists('portal/%s' % item)"
-              tal:attributes="src string:$portal_url/$item">
+              tal:condition="python:exists('portal/%s' % jsFile)"
+              tal:attributes="src string:$portal_url/$jsFile">
       </script>
     </tal:js>
-    <tal:block define="macro edit_macros/javascript_head | nothing" condition="macro">
-      <metal:block use-macro="macro" />
-    </tal:block>
-  </metal:javascript_head>
-
+  </metal:js>
   <metal:css fill-slot="css_slot">
-    <tal:css condition="css" repeat="item css">
+    <tal:css condition="css" repeat="cssFile css">
       <style type="text/css" media="all"
-             tal:condition="python:exists('portal/%s' % item)"
-             tal:content="structure string:<!-- @import url($portal_url/$item); -->">
+             tal:condition="python:exists('portal/%s' % cssFile)"
+             tal:content="structure string:<!-- @import url($portal_url/$cssFile); -->">
       </style>
     </tal:css>
-    <tal:block define="macro edit_macros/css | nothing" condition="macro">
-      <metal:block use-macro="macro" />
-    </tal:block>
   </metal:css>
 
   <body>
     <metal:fill fill-slot="main">
-      <div metal:use-macro="here/skyn/macros/macros/pagePrologue"/>
-      <div metal:use-macro="here/skyn/macros/macros/showPageHeader"/>
-
+      <metal:prologue use-macro="here/skyn/page/macros/prologue"/>
       <form name="edit_form" method="post" enctype="multipart/form-data"
             class="enableUnloadProtection atBaseEditForm"
             tal:attributes="action python: contextObj.absolute_url()+'/skyn/do'">
-        <div metal:use-macro="here/skyn/macros/macros/listFields" /><br/>
         <input type="hidden" name="action" value="Update"/>
-        <input type="hidden" name="fieldset" tal:attributes="value fieldset"/>
-        <input type="hidden" name="pageName" tal:attributes="value pageName"/>
-        <input type="hidden" name="phase" tal:attributes="value phase"/>
+        <input type="hidden" name="page" tal:attributes="value page"/>
         <input type="hidden" name="nav" tal:attributes="value python:request.get('nav', '')"/>
-        <input type="hidden" name="is_new"
-               tal:attributes="value python: '/portal_factory/' in contextObj.absolute_url()"/>
-
-        <tal:comment replace="nothing">Buttons (Previous, Next, Save, etc)</tal:comment>
-        <metal:block define-slot="buttons"
-                     tal:define="pages phaseInfo/pages;
-                                 pageIndex python:pages.index(fieldset);
-                                 numberOfPages python:len(pages)">
-
-          <tal:previousButton condition="python: pageIndex &gt; 0">
-            <input class="context" type="submit" name="buttonPrevious"
-                   i18n:attributes="value label_previous;" i18n:domain="plone"
-                   tal:attributes="disabled python:test(isLocked, 'disabled', None);"/>
-            <input type="hidden" name="previousPage" tal:attributes="value python: pages[pageIndex-1]"/>
-          </tal:previousButton>
-          <tal:nextButton condition="python: pageIndex &lt; numberOfPages - 1">
-            <input class="context" type="submit" name="buttonNext" value="Next"
-                   i18n:attributes="value label_next;" i18n:domain="plone"
-                   tal:attributes="disabled python:test(isLocked, 'disabled', None);"/>
-            <input type="hidden" name="nextPage" tal:attributes="value python: pages[pageIndex+1]"/>
-          </tal:nextButton>
-          <input class="context" type="submit" name="buttonOk"
-                 i18n:attributes="value label_save;" i18n:domain="plone"
-                 tal:attributes="disabled python:test(isLocked, 'disabled', None);"/>
-          <input class="standalone" type="submit" name="buttonCancel"
-                 i18n:attributes="value label_cancel;" i18n:domain="plone"/>
-        </metal:block>
+        <input type="hidden" name="is_new" tal:attributes="value contextObj/checkCreationFlag"/>
+        <metal:show use-macro="here/skyn/page/macros/show"/>
       </form>
-      <div metal:use-macro="here/skyn/macros/macros/showPageFooter"/>
+      <metal:footer use-macro="here/skyn/page/macros/footer"/>
     </metal:fill>
   </body>
 </html>
-</tal:block>
+</tal:edit>

gen/plone25/skin/import.pt

@@ -20,7 +20,7 @@
                    importElems python: flavour.getImportElements(contentType);
                    global allAreImported python:True">
 
-  <div metal:use-macro="here/skyn/macros/macros/pagePrologue"/>
+  <div metal:use-macro="here/skyn/page/macros/prologue"/>
   <script language="javascript">
   <!--
   var importedElemsShown = false;

gen/plone25/skin/macros.pt

@@ -1,814 +1,3 @@
-<div metal:define-macro="listPodTemplates" class="appyPod" tal:condition="podTemplates"
-     tal:define="podTemplates python: flavour.getAvailablePodTemplates(contextObj, phase);">
-  <tal:podTemplates define="maxShownTemplates python: flavour.getMaxShownTemplates(contextObj)">
-    <tal:comment replace="nothing">Display templates as links if a few number of templates must be shown</tal:comment>
-    <span class="discreet" tal:condition="python: len(podTemplates)&lt;=maxShownTemplates"
-          tal:repeat="podTemplate podTemplates">
-      <a style="cursor: pointer"
-         tal:define="podFormat podTemplate/getPodFormat"
-         tal:attributes="onclick python: 'javascript:generatePodDocument(\'%s\',\'%s\', \'\', \'\')' % (contextObj.UID(), podTemplate.UID())" >
-        <img tal:attributes="src string: $portal_url/skyn/$podFormat.png"/>
-        <span tal:replace="podTemplate/Title"/>
-      </a>
-  &nbsp;</span>
-  <tal:comment replace="nothing">Display templates as a list if a lot of templates must be shown</tal:comment>
-  <select tal:condition="python: len(podTemplates)&gt;maxShownTemplates">
-    <option value="" tal:content="python: tool.translate('choose_a_doc')"></option>
-    <option tal:repeat="podTemplate podTemplates" tal:content="podTemplate/Title"
-            tal:attributes="onclick python: 'javascript:generatePodDocument(\'%s\',\'%s\', \'\', \'\')' % (contextObj.UID(), podTemplate.UID())" />
-  </select>
-  </tal:podTemplates>
-</div>
-
-<metal:editString define-macro="editString" tal:define="vocab python:field.Vocabulary(contextObj)">
-  <label tal:attributes="for fieldName" tal:condition="showLabel" tal:content="label"/>&nbsp;
-  <span class="fieldRequired" tal:condition="python: appyType['multiplicity'][0] &gt; 0"></span>
-  <div class="discreet" tal:content="structure description"/>
-  <select tal:attributes="name fieldName;
-                          id fieldName;
-                          tabindex tabindex/next;
-                          multiple isMultiple;
-                          onchange python: 'javascript:updateSlaves(getMasterValue(this), \'%s\')' % appyType['id'];
-                          class python: contextObj.getCssClasses(appyType, asSlave=False)">
-      <option tal:repeat="item vocab" i18n:translate=""
-              tal:attributes="value item;
-                              selected python:contextObj.fieldValueSelected(fieldName, value, item)"
-              tal:content="python:here.translate(vocab.getMsgId(item), default=vocab.getValue(item))"/>
-  </select>
-</metal:editString>
-
-<metal:editBoolean define-macro="editBoolean">
-  <input type="checkbox"
-         tal:attributes="tabindex tabindex/next;
-                         name python: fieldName + '_visible';
-                         id fieldName;
-                         checked python:contextObj.checkboxChecked(fieldName, value);
-                         onClick python:'toggleCheckbox(\'%s\', \'%s_hidden\');;updateSlaves(getMasterValue(this), \'%s\')' % (fieldName, fieldName, appyType['id']);
-                         class python: 'noborder ' + contextObj.getCssClasses(appyType, asSlave=False)"/>
-  <input tal:attributes="name fieldName;
-                         id string:${fieldName}_hidden;
-                         value python: test(contextObj.checkboxChecked(fieldName, value), 'True', 'False')"
-         type="hidden" />
-  <span class="fieldRequired" tal:condition="python: appyType['multiplicity'][0] &gt; 0"></span>
-  <label tal:attributes="for fieldName" tal:condition="showLabel" tal:content="label"/>
-  <div class="discreet" tal:content="structure description"/>
-</metal:editBoolean>
-
-<div metal:define-macro="editField"
-     tal:define="fieldName field/getName;
-                 isMultiple python:test(appyType['multiplicity'][1]!=1, 'multiple', '');
-                 inError python:test(errors.has_key(fieldName), True, False);
-                 value python:field.getAccessor(contextObj)();
-                 defaultValue python: contextObj.getDefault(fieldName)"
-     tal:attributes="class python:'field ' + test(inError, ' error', '')">
-  <div tal:condition="inError" tal:content="python: errors[fieldName]"></div>
-  <tal:stringField condition="python: appyType['type'] == 'String'">
-    <metal:edit use-macro="here/skyn/macros/macros/editString"/>
-  </tal:stringField>
-  <tal:booleanField condition="python: appyType['type'] == 'Boolean'">
-    <metal:edit use-macro="here/skyn/macros/macros/editBoolean"/>
-  </tal:booleanField>
-</div>
-
-<div metal:define-macro="showComputedField">
-  <span class="appyLabel" tal:condition="showLabel" tal:content="label"></span>
-  <span class="formHelp" tal:content="structure description"></span>
-  <tal:showValue define="theValue python: contextObj.getComputedValue(appyType)">
-    <span tal:condition="appyType/plainText" tal:replace="theValue"/>
-    <span tal:condition="not: appyType/plainText" tal:replace="structure theValue"/>
-  </tal:showValue>
-</div>
-
-<div metal:define-macro="showInfoField">
-  <span class="appyLabel" tal:content="structure label"></span>
-  <span class="formHelp" tal:content="structure description"></span>
-</div>
-
-<div metal:define-macro="showActionField">
-  <form name="executeAppyAction"
-        tal:define="formId python: '%s_%s' % (contextObj.UID(), field.getName())"
-        tal:attributes="id formId; action python: contextObj.absolute_url()+'/skyn/do'">
-    <input type="hidden" name="action" value="ExecuteAppyAction"/>
-    <input type="hidden" name="objectUid" tal:attributes="value contextObj/UID"/>
-    <input type="hidden" name="fieldName" tal:attributes="value field/getName"/>
-    <input type="button" tal:condition="appyType/confirm"
-           tal:attributes="value label; onClick python: 'javascript:askConfirm(\'%s\')' % formId"/>
-    <input type="submit" name="do" tal:condition="not: appyType/confirm"
-           tal:attributes="value label" onClick="javascript:;"/>
-    <tal:comment replace="nothing">The previous onClick is simply used to prevent Plone
-      from adding a CSS class that displays a popup when the user triggers the form multiple
-      times.</tal:comment>
-  </form>
-</div>
-
-<metal:showDate define-macro="showDateField"
-                tal:define="v python: contextObj.getAppyValue(field.getName(), appyType)">
-  <span tal:condition="showLabel" tal:content="label" class="appyLabel"></span>
-  <span tal:replace="v"></span>
-</metal:showDate>
-
-<metal:showFloat define-macro="showFloatField"
-                 tal:define="v python: contextObj.getAppyValue(field.getName(), appyType)">
-  <span tal:condition="showLabel" tal:content="label"
-        tal:attributes="class python: 'appyLabel ' + contextObj.getCssClasses(appyType, asSlave=False);
-                        id python: v"></span>
-  <span tal:replace="v"></span>
-</metal:showFloat>
-
-<metal:showString define-macro="showStringField"
-                  tal:define="v python: contextObj.getAppyValue(field.getName(), appyType);
-                              fmt python: appyType['format'];
-                              maxMult python: appyType['multiplicity'][1];
-                              severalValues python: (maxMult == None) or (maxMult &gt; 1)">
-  <tal:simpleString condition="python: fmt in (0, 3)">
-    <span tal:condition="showLabel" tal:content="label" class="appyLabel"
-          tal:attributes="class python: 'appyLabel ' + contextObj.getCssClasses(appyType, asSlave=False);
-                          id python: contextObj.getAppyValue(field.getName(), appyType, forMasterId=True)"></span>
-    <ul class="appyList" tal:condition="python: v and severalValues">
-      <li class="appyBullet" tal:repeat="sv v"><i tal:content="structure sv"></i></li>
-    </ul>
-    <tal:singleValue condition="python: v and not severalValues">
-      <span tal:condition="python: fmt != 3" tal:replace="structure v"/>
-      <span tal:condition="python: fmt == 3">********</span>
-    </tal:singleValue>
-  </tal:simpleString>
-  <tal:formattedString condition="python: fmt not in (0, 3)">
-    <fieldset>
-      <legend tal:condition="showLabel" tal:content="label"></legend>
-      <span tal:condition="python: v and (appyType['format'] == 1)"
-            tal:replace="structure python: v.replace('\n', '&lt;br&gt;')"/>
-      <span tal:condition="python: v and (appyType['format'] == 2)" tal:replace="structure v"/>
-    </fieldset>
-  </tal:formattedString>
-</metal:showString>
-
-<metal:showPod define-macro="showPodField"
-               tal:define="fieldName field/getName">
-  <tal:askAction condition="appyType/askAction"
-                 define="doLabel python:'%s_askaction' % appyType['label'];
-                         chekboxId python: '%s_%s' % (contextObj.UID(), fieldName)">
-    <input type="checkbox" tal:attributes="name doLabel; id chekboxId"/>
-    <label tal:attributes="for chekboxId" class="discreet"
-           tal:content="python: tool.translate(doLabel)"></label>
-  </tal:askAction>
-  <img tal:repeat="podFormat python:flavour.getPodInfo(contextObj, fieldName)['formats']"
-       tal:attributes="src string: $portal_url/skyn/${podFormat}.png;
-                       title label;
-                       onClick python: 'javascript:generatePodDocument(\'%s\',\'\',\'%s\',\'%s\')' % (contextObj.UID(), fieldName, podFormat)"
-       style="cursor:pointer"/>
-</metal:showPod>
-
-<div metal:define-macro="showArchetypesField"
-     tal:define="field fieldDescr/atField|widgetDescr/atField;
-                 appyType fieldDescr/appyType|widgetDescr/appyType;
-                 showLabel showLabel|python:True;
-                 labelId field/widget/label_msgid;
-                 label python: tool.translate(labelId);
-                 descrId field/widget/description_msgid|python:'';
-                 description python: tool.translate(descrId)"
-     tal:attributes="class python: contextObj.getCssClasses(appyType, asSlave=True)">
-
-  <tal:comment replace="nothing">For some fields we simply use the standard Archetypes
-      macro for showing it. Special Appy field types like Ref and Computed have their
-      corresponding Archetypes fields set as invisible, so they won't be shown by the following
-      tal:showField.</tal:comment>
-
-  <tal:showField define="mode python:test(isEdit, 'edit', 'view');"
-                 tal:condition="python: test(isEdit, member.has_permission(field.write_permission, contextObj), member.has_permission(field.read_permission, contextObj))">
-    <tal:editField condition="isEdit">
-      <metal:editMacro use-macro="python:contextObj.widget(field.getName(), mode='edit', use_label=showLabel)" />
-    </tal:editField>
-    <tal:viewField tal:condition="not: isEdit">
-      <tal:fileField condition="python: (appyType['type'] == 'File')">
-        <span tal:condition="showLabel" tal:content="label" class="appyLabel"></span>
-        <metal:viewField use-macro="python: contextObj.widget(field.getName(), 'view', use_label=0)"/>
-      </tal:fileField>
-      <tal:date condition="python: appyType['type'] == 'Date'">
-        <metal:showDate use-macro="here/skyn/macros/macros/showDateField"/>
-      </tal:date>
-      <tal:string condition="python: appyType['type'] == 'String'">
-        <metal:showString use-macro="here/skyn/macros/macros/showStringField"/>
-      </tal:string>
-      <tal:float condition="python: appyType['type'] == 'Float'">
-        <metal:showFloat use-macro="here/skyn/macros/macros/showFloatField"/>
-      </tal:float>
-      <tal:simpleField condition="python: (appyType['type'] in ('Integer', 'Boolean'))">
-        <span tal:condition="showLabel" tal:content="label"
-              tal:attributes="class python: 'appyLabel ' + contextObj.getCssClasses(appyType, asSlave=False);
-                              id python: field.getAccessor(contextObj)()"></span>
-        <metal:viewField use-macro="python: contextObj.widget(field.getName(), 'view', use_label=0)"/>
-      </tal:simpleField>
-    </tal:viewField>
-  </tal:showField>
-
-  <tal:comment replace="nothing">For other fields like Refs we use specific view/edit macros.</tal:comment>
-  <tal:viewRef condition="python: (not isEdit) and (appyType['type'] == 'Ref')">
-    <tal:ref define="isBack python:False;
-                     fieldName field/getName;
-                     innerRef innerRef|python:False">
-      <metal:viewRef use-macro="here/skyn/ref/macros/showReference" />
-    </tal:ref>
-  </tal:viewRef>
-  <tal:editRef condition="python: isEdit and (appyType['type'] == 'Ref')">
-    <tal:ref define="appyType fieldDescr/appyType|widgetDescr/appyType"
-             condition="python: appyType['link']==True">
-      <metal:editRef use-macro="here/skyn/ref/macros/editReference" />
-    </tal:ref>
-  </tal:editRef>
-  <tal:computedField condition="python: appyType['type'] == 'Computed'">
-    <metal:cf use-macro="here/skyn/macros/macros/showComputedField" />
-  </tal:computedField>
-  <tal:actionField condition="python: appyType['type'] == 'Action'">
-    <metal:af use-macro="here/skyn/macros/macros/showActionField" />
-  </tal:actionField>
-  <tal:masterString condition="python: isEdit and (appyType['type'] in ('String', 'Boolean')) and (appyType['slaves'])">
-    <metal:mf use-macro="here/skyn/macros/macros/editField" />
-  </tal:masterString>
-  <tal:infoField condition="python: appyType['type'] == 'Info'">
-    <metal:af use-macro="here/skyn/macros/macros/showInfoField" />
-  </tal:infoField>
-  <tal:podField condition="python: (not isEdit) and (appyType['type'] == 'Pod')">
-    <metal:af use-macro="here/skyn/macros/macros/showPodField" />
-  </tal:podField>
-</div>
-
-<div metal:define-macro="showBackwardField"
-     tal:define="isBack python:True;
-                 appyType widgetDescr/appyType;
-                 fieldName widgetDescr/fieldRel;
-                 labelId python: '%s_%s_back' % (contextObj.meta_type, appyType['backd']['attribute']);
-                 descrId python: '';
-                 innerRef innerRef|python:False">
-  <div metal:use-macro="here/skyn/ref/macros/showReference" />
-</div>
-
-<metal:group define-macro="showGroup">
-  <fieldset class="appyGroup">
-    <legend><i tal:define="groupDescription python:contextObj.translate('%s_group_%s' % (contextObj.meta_type, widgetDescr['name']))"
-               tal:content="structure groupDescription"></i></legend>
-    <table tal:define="global fieldNb python:-1" width="100%">
-      <tr valign="top" tal:repeat="rowNb python:range(widgetDescr['rows'])">
-        <td tal:repeat="colNb python:range(widgetDescr['cols'])"
-            tal:attributes="width python: str(100.0/widgetDescr['cols']) + '%'">
-          <tal:showField define="global fieldNb python:fieldNb+1;
-                                 hasFieldDescr python: test(fieldNb < len(widgetDescr['fields']), True, False);"
-                         tal:condition="hasFieldDescr">
-            <tal:field define="fieldDescr python:widgetDescr['fields'][fieldNb]">
-              <tal:archetypesField condition="python: fieldDescr['widgetType'] == 'field'">
-                <metal:atField use-macro="here/skyn/macros/macros/showArchetypesField"/>
-              </tal:archetypesField>
-              <tal:backwardRef tal:condition="python: (not isEdit) and (fieldDescr['widgetType'] == 'backField')">
-                <metal:backRef use-macro="here/skyn/macros/macros/showBackwardField" />
-              </tal:backwardRef>
-            </tal:field>
-          </tal:showField>
-        </td>
-      </tr>
-    </table>
-  </fieldset>
-  <br/>
-</metal:group>
-
-<metal:fields define-macro="listFields"
-     tal:repeat="widgetDescr python: contextObj.getAppyFields(isEdit, pageName)">
-    <tal:displayArchetypesField condition="python: widgetDescr['widgetType'] == 'field'">
-      <tal:atField condition="python: widgetDescr['page'] == pageName">
-        <metal:field use-macro="here/skyn/macros/macros/showArchetypesField" />
-      </tal:atField>
-    </tal:displayArchetypesField>
-    <tal:displayBackwardRef condition="python: (not isEdit) and (widgetDescr['widgetType'] == 'backField')">
-      <tal:backRef condition="python: widgetDescr['appyType']['backd']['page'] == pageName">
-        <metal:field metal:use-macro="here/skyn/macros/macros/showBackwardField" />
-      </tal:backRef>
-    </tal:displayBackwardRef>
-    <tal:displayGroup condition="python: widgetDescr['widgetType'] == 'group'">
-      <tal:displayG condition="python: widgetDescr['page'] == pageName">
-        <metal:group metal:use-macro="here/skyn/macros/macros/showGroup" />
-      </tal:displayG>
-    </tal:displayGroup>
-</metal:fields>
-
-<metal:history define-macro="history"
-      tal:define="startNumber request/startNumber|python:0;
-                  startNumber python: int(startNumber);
-                  historyInfo python: contextObj.getHistory(startNumber);
-                  objs        historyInfo/events;
-                  batchSize   historyInfo/batchSize;
-                  totalNumber historyInfo/totalNumber;
-                  ajaxHookId  python:'appyHistory';
-                  navBaseCall python: 'askObjectHistory(\'%s\',\'%s\',**v**)' % (ajaxHookId, contextObj.absolute_url());
-                  tool        contextObj/getTool">
-
-  <tal:comment replace="nothing">Table containing the history</tal:comment>
-  <tal:history condition="objs">
-  <metal:nav use-macro="here/skyn/navigate/macros/appyNavigate"/>
-  <table width="100%" class="listing nosort">
-    <tr i18n:domain="plone">
-      <th i18n:translate="listingheader_action"/>
-      <th i18n:translate="listingheader_performed_by"/>
-      <th i18n:translate="listingheader_date_and_time"/>
-      <th i18n:translate="listingheader_comment"/>
-    </tr>
-    <tal:event repeat="event objs">
-    <tr tal:define="odd repeat/event/odd;
-                    rhComments event/comments|nothing;
-                    state event/review_state|nothing;
-                    isDataChange python: event['action'] == '_datachange_'"
-        tal:attributes="class python:test(odd, 'even', 'odd')" valign="top">
-      <td tal:condition="isDataChange" tal:content="python: tool.translate('data_change')"></td>
-      <td tal:condition="not: isDataChange"
-          tal:content="python: tool.translate(contextObj.getWorkflowLabel(event['action']))"
-          tal:attributes="class string:state-${state}"/>
-      <td tal:define="actorid python:event.get('actor');
-                      actor python:contextObj.portal_membership.getMemberInfo(actorid);
-                      fullname actor/fullname|nothing;
-                      username actor/username|nothing"
-          tal:content="python:fullname or username or actorid"/>
-      <td tal:content="python:contextObj.restrictedTraverse('@@plone').toLocalizedTime(event['time'],long_format=True)"/>
-      <td tal:condition="not: isDataChange"><tal:comment condition="rhComments" tal:content="structure rhComments"/>
-        <tal:noComment condition="not: rhComments" i18n:translate="no_comments" i18n:domain="plone"/></td>
-      <td tal:condition="isDataChange">
-        <tal:comment replace="nothing">
-          Display the previous values of the fields whose value were modified in this change.</tal:comment>
-        <table class="appyChanges" width="100%">
-          <tr>
-            <th align="left" width="30%" tal:content="python: tool.translate('modified_field')"></th>
-            <th align="left" width="70%" tal:content="python: tool.translate('previous_value')"></th>
-          </tr>
-          <tr tal:repeat="change event/changes/items" valign="top">
-            <td tal:content="python: tool.translate(change[1][1])"></td>
-            <td tal:define="appyType python:contextObj.getAppyType(change[0]);
-                            appyValue python: contextObj.getAppyValue(change[0], appyType, True, change[1][0]);
-                            severalValues python: (appyType['multiplicity'][1] &gt; 1) or (appyType['multiplicity'][1] == None)">
-              <span tal:condition="not: severalValues" tal:replace="appyValue"></span>
-              <ul tal:condition="python: severalValues">
-                <li tal:repeat="av appyValue" tal:content="av"></li>
-              </ul>
-            </td>
-          </tr>
-        </table>
-      </td>
-    </tr>
-    </tal:event>
-  </table>
-  </tal:history>
-</metal:history>
-
-<div metal:define-macro="pagePrologue">
-  <tal:comment replace="nothing">Global elements used in every page.</tal:comment>
-
-  <tal:comment replace="nothing">Javascript messages</tal:comment>
-  <script language="javascript" tal:content="tool/getJavascriptMessages"></script>
-
-  <tal:comment replace="nothing">"Static" javascripts</tal:comment>
-  <script language="javascript">
-  <!--
-  var isIe = (navigator.appName == "Microsoft Internet Explorer");
-  // AJAX machinery
-  var xhrObjects = new Array(); // An array of XMLHttpRequest objects
-  function XhrObject() { // Wraps a XmlHttpRequest object
-    this.freed = 1; // Is this xhr object already dealing with a request or not?
-    this.xhr = false;
-    if (window.XMLHttpRequest) this.xhr = new XMLHttpRequest();
-    else this.xhr = new ActiveXObject("Microsoft.XMLHTTP");
-    this.hook = '';  /* The ID of the HTML element in the page that will be
-                        replaced by result of executing the Ajax request. */
-    this.onGet = ''; /* The name of a Javascript function to call once we
-                        receive the result. */
-    this.info = {};  /* An associative array for putting anything else. */
-  }
-
-  function getAjaxChunk(pos) {
-    // This function is the callback called by the AJAX machinery (see function
-    // askAjaxChunk below) when an Ajax response is available.
-    // First, find back the correct XMLHttpRequest object
-    if ( (typeof(xhrObjects[pos]) != 'undefined') &&
-         (xhrObjects[pos].freed == 0)) {
-      var hook = xhrObjects[pos].hook;
-      if (xhrObjects[pos].xhr.readyState == 1) {
-        // The request has been initialized: display the waiting radar
-        var hookElem = document.getElementById(hook);
-        if (hookElem) hookElem.innerHTML = "<div align=\"center\"><img src=\"skyn/waiting.gif\"/><\/div>";
-      }
-      if (xhrObjects[pos].xhr.readyState == 4) {
-        // We have received the HTML chunk
-        var hookElem = document.getElementById(hook);
-        if (hookElem && (xhrObjects[pos].xhr.status == 200)) {
-          hookElem.innerHTML = xhrObjects[pos].xhr.responseText;
-          // Call a custom Javascript function if required
-          if (xhrObjects[pos].onGet) {
-            xhrObjects[pos].onGet(xhrObjects[pos], hookElem);
-          }
-        }
-        xhrObjects[pos].freed = 1;
-      }
-    }
-  }
-
-  function askAjaxChunk(hook,mode,url,page,macro,params,beforeSend,onGet) {
-    /* This function will ask to get a chunk of HTML on the server through a
-       XMLHttpRequest. p_mode can be 'GET' or 'POST'. p_url is the URL of a
-       given server object. On this URL we will call the page "ajax.pt" that
-       will call a specific p_macro in a given p_page with some additional
-       p_params (must be an associative array) if required.
-
-       p_hook is the ID of the HTML element that will be filled with the HTML
-       result from the server.
-
-       p_beforeSend is a Javascript function to call before sending the request.
-       This function will get 2 args: the XMLHttpRequest object and the
-       p_params. This method can return, in a string, additional parameters to
-       send, ie: "&param1=blabla&param2=blabla".
-
-       p_onGet is a Javascript function to call when we will receive the answer.
-       This function will get 2 args, too: the XMLHttpRequest object and the
-       HTML node element into which the result has been inserted.
-    */
-    // First, get a non-busy XMLHttpRequest object.
-    var pos = -1;
-    for (var i=0; i < xhrObjects.length; i++) {
-      if (xhrObjects[i].freed == 1) { pos = i; break; }
-    }
-    if (pos == -1) {
-      pos = xhrObjects.length;
-      xhrObjects[pos] = new XhrObject();
-    }
-    xhrObjects[pos].hook = hook;
-    xhrObjects[pos].onGet = onGet;
-    if (xhrObjects[pos].xhr) {
-      var rq = xhrObjects[pos];
-      rq.freed = 0;
-      // Construct parameters
-      var paramsFull = 'page=' + page + '&macro=' + macro;
-      if (params) {
-        for (var paramName in params)
-          paramsFull = paramsFull + '&' + paramName + '=' + params[paramName];
-      }
-      // Call beforeSend if required
-      if (beforeSend) {
-         var res = beforeSend(rq, params);
-         if (res) paramsFull = paramsFull + res;
-      }
-      // Construct the URL to call
-      var urlFull = url + '/skyn/ajax';
-      if (mode == 'GET') {
-        urlFull = urlFull + '?' + paramsFull;
-      }
-      // Perform the asynchronous HTTP GET or POST
-      rq.xhr.open(mode, urlFull, true);
-      if (mode == 'POST') {
-        // Set the correct HTTP headers
-        rq.xhr.setRequestHeader(
-          "Content-Type", "application/x-www-form-urlencoded");
-        rq.xhr.setRequestHeader("Content-length", paramsFull.length);
-        rq.xhr.setRequestHeader("Connection", "close");
-        rq.xhr.onreadystatechange = function(){ getAjaxChunk(pos); }
-        rq.xhr.send(paramsFull);
-      }
-      else if (mode == 'GET') {
-        rq.xhr.onreadystatechange = function() { getAjaxChunk(pos); }
-        if (window.XMLHttpRequest) { rq.xhr.send(null); }
-        else if (window.ActiveXObject) { rq.xhr.send(); }
-      }
-    }
-  }
-
-  /* The functions below wrap askAjaxChunk for getting specific content through
-     an Ajax request. */
-  function askQueryResult(hookId, objectUrl, contentType, flavourNumber,
-              searchName, startNumber, sortKey, sortOrder, filterKey) {
-    // Sends an Ajax request for getting the result of a query.
-    var params = {'type_name': contentType, 'flavourNumber': flavourNumber,
-                  'search': searchName, 'startNumber': startNumber};
-    if (sortKey) params['sortKey'] = sortKey;
-    if (sortOrder) params['sortOrder'] = sortOrder;
-    if (filterKey) {
-      var filterWidget = document.getElementById(hookId + '_' + filterKey);
-      if (filterWidget && filterWidget.value) {
-        params['filterKey'] = filterKey;
-        params['filterValue'] = filterWidget.value;
-      }
-    }
-    askAjaxChunk(hookId,'GET',objectUrl,'macros','queryResult',params);
-  }
-
-  function askObjectHistory(hookId, objectUrl, startNumber) {
-    // Sends an Ajax request for getting the history of an object
-    var params = {'startNumber': startNumber};
-    askAjaxChunk(hookId, 'GET', objectUrl, 'macros', 'history', params);
-  }
-
-  function askRefField(hookId, objectUrl, fieldName, isBack, innerRef, labelId,
-                       descrId, startNumber, action, actionParams){
-    // Sends an Ajax request for getting the content of a reference field.
-    var startKey = hookId + '_startNumber';
-    var params = {'fieldName': fieldName, 'isBack': isBack,
-                  'innerRef': innerRef, 'labelId': labelId,
-                  'descrId': descrId };
-    params[startKey] =  startNumber;
-    if (action) params['action'] = action;
-    if (actionParams) {
-        for (key in actionParams) { params[key] = actionParams[key]; };
-    }
-    askAjaxChunk(hookId, 'GET', objectUrl, 'ref', 'showReferenceContent',
-                 params);
-  }
-
-  // Function used by checkbox widgets for having radio-button-like behaviour
-  function toggleCheckbox(visibleCheckbox, hiddenBoolean) {
-    vis = document.getElementById(visibleCheckbox);
-    hidden = document.getElementById(hiddenBoolean);
-    if (vis.checked) hidden.value = 'True';
-    else hidden.value = 'False';
-  }
-  // Functions used for master/slave relationships between widgets
-  function getMasterValue(widget) {
-    // Returns an array of selected options in a select widget
-    res = new Array();
-    if (widget.type == 'checkbox') {
-      var mv = widget.checked + '';
-      mv = mv.charAt(0).toUpperCase() + mv.substr(1);
-      res.push(mv);
-    }
-    else { // SELECT widget
-      for (var i=0; i < widget.options.length; i++) {
-        if (widget.options[i].selected) res.push(widget.options[i].value);
-      }
-    }
-    return res;
-  }
-  function updateSlaves(masterValues, appyTypeId) {
-    // Given the value(s) selected in a master field, this function updates the
-    // state of all corresponding slaves.
-    var slaves = cssQuery('div.slave_' + appyTypeId);
-    for (var i=0; i< slaves.length; i++){
-      slaves[i].style.display = "none";
-    }
-    for (var i=0; i < masterValues.length; i++) {
-      var activeSlaves = cssQuery('div.slaveValue_' + appyTypeId + '_' + masterValues[i]);
-      for (var j=0; j < activeSlaves.length; j++){
-        activeSlaves[j].style.display = "";
-      }
-    }
-  }
-  // Function used for triggering a workflow transition
-  function triggerTransition(transitionId) {
-    var theForm = document.getElementById('triggerTransitionForm');
-    theForm.workflow_action.value = transitionId;
-    theForm.submit();
-  }
-  function onDeleteObject(objectUid) {
-    if (confirm(delete_confirm)) {
-       f = document.getElementById('deleteForm');
-       f.objectUid.value = objectUid;
-       f.submit();
-    }
-  }
-  function toggleCookie(cookieId) {
-    // What is the state of this boolean (expanded/collapsed) cookie?
-    var state = readCookie(cookieId);
-    if ((state != 'collapsed') && (state != 'expanded')) {
-      // No cookie yet, create it.
-      createCookie(cookieId, 'collapsed');
-      state = 'collapsed';
-    }
-    var hook = document.getElementById(cookieId); // The hook is the part of
-    // the HTML document that needs to be shown or hidden.
-    var displayValue = 'none';
-    var newState = 'collapsed';
-    var imgSrc = 'skyn/expand.gif';
-    if (state == 'collapsed') {
-      // Show the HTML zone
-      displayValue = 'block';
-      imgSrc = 'skyn/collapse.gif';
-      newState = 'expanded';
-    }
-    // Update the corresponding HTML element
-    hook.style.display = displayValue;
-    var img = document.getElementById(cookieId + '_img');
-    img.src = imgSrc;
-    // Inverse the cookie value
-    createCookie(cookieId, newState);
-  }
-  // Function that allows to generate a document from a pod template.
-  function generatePodDocument(contextUid, templateUid, fieldName, podFormat) {
-    var theForm = document.forms["podTemplateForm"];
-    theForm.objectUid.value = contextUid;
-    theForm.templateUid.value = templateUid;
-    theForm.fieldName.value = fieldName;
-    theForm.podFormat.value = podFormat;
-    theForm.askAction.value = "False";
-    var askActionWidget = document.getElementById(contextUid + '_' + fieldName);
-    if (askActionWidget && askActionWidget.checked) {
-        theForm.askAction.value = "True";
-    }
-    theForm.submit();
-  }
-  // Functions for opening and closing a popup
-  function openPopup(popupId) {
-    // Open the popup
-    var popup = document.getElementById(popupId);
-    // Put it at the right place on the screen
-    var scrollTop = window.pageYOffset || document.documentElement.scrollTop || 0;
-    popup.style.top = (scrollTop + 150) + 'px';
-    popup.style.display = "block";
-    // Show the greyed zone
-    var greyed = document.getElementById('appyGrey');
-    greyed.style.top = scrollTop + 'px';
-    greyed.style.display = "block";
-  }
-  function closePopup(popupId) {
-    // Close the popup
-    var popup = document.getElementById(popupId);
-    popup.style.display = "none";
-    // Hide the greyed zone
-    var greyed = document.getElementById('appyGrey');
-    greyed.style.display = "none";
-  }
-  // Function triggered when an action needs to be confirmed by the user
-  function askConfirm(formId) {
-    // Store the ID of the form to send if the users confirms.
-    var confirmForm = document.getElementById('confirmActionForm');
-    confirmForm.actionFormId.value = formId;
-    openPopup("confirmActionPopup");
-  }
-  // Function triggered when an action confirmed by the user must be performed
-  function doConfirm() {
-    // The user confirmed: retrieve the form to send and send it.
-    var confirmForm = document.getElementById('confirmActionForm');
-    var actionFormId = confirmForm.actionFormId.value;
-    var actionForm = document.getElementById(actionFormId);
-    actionForm.submit();
-  }
--->
-  </script>
-  <tal:comment replace="nothing">Global form for deleting an object</tal:comment>
-  <form id="deleteForm" method="post" action="skyn/do">
-    <input type="hidden" name="action" value="Delete"/>
-    <input type="hidden" name="objectUid"/>
-  </form>
-  <tal:comment replace="nothing">Global form for generating a document from a pod template.</tal:comment>
-  <form name="podTemplateForm" method="post"
-        tal:attributes="action python: flavour.absolute_url() + '/generateDocument'">
-    <input type="hidden" name="objectUid"/>
-    <tal:comment replace="nothing">templateUid is given if class-wide pod, fieldName and podFormat are given if podField.</tal:comment>
-    <input type="hidden" name="templateUid"/>
-    <input type="hidden" name="fieldName"/>
-    <input type="hidden" name="podFormat"/>
-    <input type="hidden" name="askAction"/>
-  </form>
-</div>
-
-<div metal:define-macro="showPageHeader"
-     tal:define="showCommonInfo python: not isEdit;
-                 hasHistory contextObj/hasHistory;
-                 historyExpanded python: tool.getCookieValue('appyHistory', default='collapsed') == 'expanded';
-                 creator contextObj/Creator"
-     tal:condition="not: contextObj/isTemporary">
-
-    <tal:comment replace="nothing">Information that is common to all tabs (object title, state, etc)</tal:comment>
-    <table width="100%" tal:condition="showCommonInfo" class="appyCommonInfo">
-      <tr valign="bottom">
-        <tal:comment replace="nothing">Title, edit icon and state</tal:comment>
-        <td width="80%">
-          <b class="appyTitle" tal:content="contextObj/title_or_id"></b>
-          <tal:comment replace="nothing">Show the phase name tied to this page</tal:comment>
-          <span class="discreet" tal:condition="python: phaseInfo['totalNbOfPhases']&gt;1">&minus;
-            <span tal:replace="python:contextObj.translate('phase')"/>:
-            <span tal:replace="python:tool.translate('%s_phase_%s' % (contextObj.meta_type, phase))"/>
-          </span>
-          <tal:comment replace="nothing">When no tabs are shown, we provide an edit icon.</tal:comment>
-          <img tal:define="editPageName python:test(pageName=='main', 'default', pageName);
-                           nav request/nav|nothing;
-                           nav python: test(nav, '&nav=%s' % nav, '')"
-               title="Edit" i18n:domain="plone" i18n:attributes="title" style="cursor:pointer"
-               tal:attributes="onClick python: 'href: window.location=\'%s/skyn/edit?fieldset=%s&phase=%s%s\'' % (contextObj.absolute_url(), editPageName, phase, nav);
-                               src string: $portal_url/skyn/edit.gif"
-               tal:condition="python: (len(appyPages)==1) and member.has_permission('Modify portal content', contextObj)"/>
-        </td>
-        <td><metal:actions use-macro="here/document_actions/macros/document_actions"/>
-        </td>
-      </tr>
-      <tr tal:define="descrLabel python: contextObj.translate('%s_edit_descr' % contextObj.portal_type)"
-          tal:condition="descrLabel/strip" >
-        <tal:comment replace="nothing">Content type description</tal:comment>
-        <td colspan="2" class="discreet" tal:content="descrLabel"/>
-      </tr>
-      <tr>
-        <td class="documentByLine">
-          <tal:comment replace="nothing">Creator and last modification date</tal:comment>
-            <tal:comment replace="nothing">Plus/minus icon for accessing history</tal:comment>
-            <tal:accessHistory condition="hasHistory">
-            <img align="left" style="cursor:pointer" onClick="javascript:toggleCookie('appyHistory')"
-                 tal:attributes="src python:test(historyExpanded, 'skyn/collapse.gif', 'skyn/expand.gif');"
-                 id="appyHistory_img"/>&nbsp;
-            <span i18n:translate="label_history" i18n:domain="plone" class="appyHistory"></span>&nbsp;
-            </tal:accessHistory>
-
-            <tal:comment replace="nothing">Show document creator</tal:comment>
-            <tal:creator condition="creator"
-                 define="author python:contextObj.portal_membership.getMemberInfo(creator)">
-            <span class="documentAuthor" i18n:domain="plone" i18n:translate="label_by_author">
-            by <a tal:attributes="href string:${portal_url}/author/${creator}"
-                  tal:content="python:author and author['fullname'] or creator"
-                  tal:omit-tag="not:author" i18n:name="author"/>
-            &mdash;
-            </span>
-            </tal:creator>
-            <tal:comment replace="nothing">Show last modification date</tal:comment>
-            <span i18n:translate="box_last_modified" i18n:domain="plone"></span>
-            <span tal:replace="python:contextObj.restrictedTraverse('@@plone').toLocalizedTime(contextObj.ModificationDate(),long_format=1)"></span>
-        </td>
-        <td valign="top"><metal:pod use-macro="here/skyn/macros/macros/listPodTemplates"/>
-        </td>
-      </tr>
-      <tal:comment replace="nothing">Object history</tal:comment>
-      <tr tal:condition="hasHistory">
-        <td colspan="2">
-          <span id="appyHistory"
-                tal:attributes="style python:test(historyExpanded, 'display:block', 'display:none')">
-          <div tal:define="ajaxHookId python: contextObj.UID() + '_history';"
-               tal:attributes="id ajaxHookId">
-             <script language="javascript" tal:content="python: 'askObjectHistory(\'%s\',\'%s\',0)' % (ajaxHookId, contextObj.absolute_url())">
-             </script>
-          </div>
-          </span>
-        </td>
-      </tr>
-
-      <tal:comment replace="nothing">Workflow-related information and actions</tal:comment>
-      <tr tal:condition="python: showWorkflow and contextObj.getWorkflowLabel()">
-        <td colspan="2" class="appyWorkflow">
-          <table width="100%">
-            <tr>
-              <td><metal:states use-macro="here/skyn/macros/macros/states"/></td>
-              <td align="right"><metal:states use-macro="here/skyn/macros/macros/transitions"/></td>
-            </tr>
-          </table>
-        </td>
-      </tr>
-    </table>
-    <metal:nav use-macro="here/skyn/navigate/macros/objectNavigate"/>
-
-    <tal:comment replace="nothing">Tabs</tal:comment>
-    <ul class="contentViews appyTabs" tal:condition="python: len(appyPages)&gt;1">
-      <li tal:repeat="thePage appyPages"
-          tal:attributes="class python:test(thePage == pageName, 'selected', 'plain')">
-        <tal:tab define="pageLabel python: tool.translate('%s_page_%s' % (contextObj.meta_type, thePage))">
-          <a tal:content="pageLabel"
-             tal:attributes="href python: contextObj.absolute_url() + '/skyn/view?phase=%s&pageName=%s' % (phase, thePage)">
-          </a>
-          <img tal:define="editPageName python:test(thePage=='main', 'default', thePage);
-                           nav request/nav|nothing;
-                           nav python: test(nav, '&nav=%s' % nav, '')"
-               title="Edit" i18n:domain="plone" i18n:attributes="title" style="cursor:pointer" class="appyPlusImg"
-               tal:attributes="onClick python: 'href: window.location=\'%s/skyn/edit?fieldset=%s&phase=%s%s\'' % (contextObj.absolute_url(), editPageName, phase, nav);
-                               src string: $portal_url/skyn/edit.gif"
-               tal:condition="python: member.has_permission('Modify portal content', contextObj)"/>
-        </tal:tab>
-      </li>
-    </ul>
-</div>
-
-<div metal:define-macro="showPageFooter">
-  <script language="javascript">
-  <!--
-    // When the current page is loaded, we must set the correct state for all slave fields.
-    var masters = cssQuery('.appyMaster');
-    for (var i=0; i < masters.length; i++) {
-      var cssClasses = masters[i].className.split(' ');
-      for (var j=0; j < cssClasses.length; j++) {
-        if (cssClasses[j].indexOf('master_') == 0) {
-          var appyId = cssClasses[j].split('_')[1];
-          var masterValue = [];
-          if (masters[i].nodeName == 'SPAN'){
-            var idField = masters[i].id;
-            if (idField == '') {
-              masterValue.push(idField);
-            }
-            else {
-              if (idField[0] == '(') {
-                // There are multiple values, split it
-                var subValues = idField.substring(1, idField.length-1).split(',');
-                for (var k=0; k < subValues.length; k++){
-                  var subValue = subValues[k].strip();
-                  masterValue.push(subValue.substring(1, subValue.length-1));
-                }
-              }
-              else { masterValue.push(masters[i].id);
-              }
-            }
-          }
-          else { masterValue = getMasterValue(masters[i]);
-          }
-          updateSlaves(masterValue, appyId);
-        }
-      }
-    }
-  -->
-  </script>
-</div>
-
 <metal:queryResults define-macro="queryResult"
    tal:define="tool          python: contextObj;
                contentType   request/type_name;
@@ -856,7 +45,7 @@
 
     <table tal:define="fieldDescrs python: tool.getResultColumns(objs[0], contentType)"
          class="listing nosort" width="100%" cellpadding="0" cellspacing="0">
-    <tal:comment replace="nothing">Every item in fieldDescr is a FieldDescr instance,
+    <tal:comment replace="nothing">Every item in fieldDescrs is an Appy type (dict version),
       excepted for workflow state (which is not a field): in this case it is simply the
       string "workflow_state".</tal:comment>
 
@@ -871,12 +60,12 @@
 
       <tal:comment replace="nothing">Columns corresponding to other fields</tal:comment>
       <tal:columnHeader repeat="fieldDescr fieldDescrs">
-       <th tal:define="fieldName  fieldDescr/atField/getName|string:workflow_state;
-                       sortable   fieldDescr/sortable|nothing;
+       <th tal:define="fieldName  fieldDescr/name|string:workflow_state;
+                       sortable   fieldDescr/indexed|nothing;
                        filterable fieldDescr/filterable|nothing;">
         <tal:comment replace="nothing">Display header for a "standard" field</tal:comment>
         <tal:standardField condition="python: fieldName != 'workflow_state'">
-          <span tal:replace="python: tool.translate(fieldDescr['atField'].widget.label_msgid)"/>
+          <span tal:replace="python: tool.translate(fieldDescr['labelId'])"/>
         </tal:standardField>
         <tal:comment replace="nothing">Display header for the workflow state</tal:comment>
         <tal:workflowState condition="python: fieldName == 'workflow_state'">
@@ -906,23 +95,22 @@
         tal:content="obj/Title" tal:attributes="href python: obj.getUrl() + '/?' + navInfo"></a></td>
 
       <tal:comment replace="nothing">Columns corresponding to other fields</tal:comment>
-      <tal:otherFields repeat="fieldDescr fieldDescrs">
-        <tal:standardField condition="python: fieldDescr != 'workflowState'">
-          <td tal:condition="fieldDescr/atField"
-              tal:attributes="id python:'field_%s' % fieldDescr['atField'].getName()">
+      <tal:otherFields repeat="widget fieldDescrs">
+        <tal:standardField condition="python: widget != 'workflowState'">
+          <td tal:condition="python: '_wrong' not in widget"
+              tal:attributes="id python:'field_%s' % widget['name']">
             <tal:field define="contextObj python:obj;
-                               isEdit python:False;
-                               showLabel python:False;
+                               layoutType  python:'cell';
                                innerRef python:True"
-                       condition="python: contextObj.showField(fieldDescr)">
-              <metal:field use-macro="here/skyn/macros/macros/showArchetypesField"/>
+                       condition="python: contextObj.showField(widget['name'], 'view')">
+              <metal:field use-macro="here/skyn/widgets/show/macros/field"/>
             </tal:field>
           </td>
-          <td tal:condition="not: fieldDescr/atField" style="color:red">Field
-            <span tal:replace="fieldDescr/name"/> not found.
+          <td tal:condition="python: '_wrong' in widget" style="color:red">Field
+            <span tal:replace="widget/name"/> not found.
           </td>
         </tal:standardField>
-        <tal:workflowState condition="python: fieldDescr == 'workflowState'">
+        <tal:workflowState condition="python: widget == 'workflowState'">
           <td id="field_workflow_state" tal:content="python: tool.translate(obj.getWorkflowLabel())"></td>
         </tal:workflowState>
       </tal:otherFields>
@@ -969,70 +157,3 @@
   </tal:noResult>
 
 </metal:queryResults>
-
-<metal:phases define-macro="phases">
-  <tal:comment replace="nothing">This macro displays phases defined for a given content type,
-     only if more than one phase is defined.</tal:comment>
-    <table width="100%" tal:define="phases contextObj/getAppyPhases|nothing"
-           tal:condition="python: phases and (len(phases)&gt;1)" cellspacing="1" cellpadding="0">
-      <tal:phase repeat="phase phases">
-        <tr>
-          <td tal:define="label python:'%s_phase_%s' % (contextObj.meta_type, phase['name']);
-                          displayLink python: (phase['phaseStatus'] != 'Future') and ('/portal_factory' not in contextObj.absolute_url())"
-              tal:attributes="class python: 'appyPhase step' + phase['phaseStatus']">
-            <a tal:attributes="href python: '%s?phase=%s&pageName=%s' % (contextObj.getUrl(), phase['name'], phase['pages'][0]);" tal:condition="displayLink"
-               tal:content="python: tool.translate(label)"/>
-            <span tal:condition="not: displayLink" tal:content="python: tool.translate(label)"/>
-          </td>
-        </tr>
-        <tr tal:condition="python: phase['name'] != phases[-1]['name']">
-          <td align="center"><img tal:attributes="src string: $portal_url/skyn/nextPhase.png"/></td>
-        </tr>
-      </tal:phase>
-    </table>
-</metal:phases>
-
-<metal:states define-macro="states"
-              tal:define="showAllStatesInPhase python: flavour.getAttr('showAllStatesInPhaseFor' + contextObj.meta_type);
-                          states python: contextObj.getAppyStates(phase, currentOnly=not showAllStatesInPhase)"
-              tal:condition="python: test(showAllStatesInPhase, len(states)&gt;1, True)">
-  <table>
-    <tr>
-      <tal:state repeat="stateInfo states">
-        <td tal:attributes="class python: 'appyState step' + stateInfo['stateStatus']"
-            tal:content="python: tool.translate(contextObj.getWorkflowLabel(stateInfo['name']))">
-        </td>
-        <td tal:condition="python: stateInfo['name'] != states[-1]['name']">
-          <img tal:attributes="src string: $portal_url/skyn/nextState.png"/>
-        </td>
-      </tal:state>
-    </tr>
-  </table>
-</metal:states>
-
-<metal:transitions define-macro="transitions"
-                   tal:define="transitions contextObj/getAppyTransitions"
-                   tal:condition="transitions">
-  <form id="triggerTransitionForm" method="post"
-        tal:attributes="action python: contextObj.absolute_url() + '/skyn/do'">
-    <input type="hidden" name="action" value="TriggerTransition"/>
-    <input type="hidden" name="workflow_action"/>
-    <table>
-      <tr>
-        <tal:comment replace="nothing">Input field allowing to enter a comment before triggering a transition</tal:comment>
-        <td tal:define="showCommentsField python:flavour.getAttr('showWorkflowCommentFieldFor'+contextObj.meta_type)"
-            align="right" tal:condition="showCommentsField">
-          <span tal:content="python: tool.translate('workflow_comment')" class="discreet"></span>
-          <input type="text" id="comment" name="comment" size="35"/>
-        </td>
-
-        <tal:comment replace="nothing">Buttons for triggering transitions</tal:comment>
-        <td align="right" tal:repeat="transition transitions">
-          <input type="button" class="context"
-                 tal:attributes="value python: tool.translate(transition['name']);
-                                 onClick python: 'javascript: triggerTransition(\'%s\')' % transition['id'];"/>
-        </td>
-    </tr>
-    </table>
-  </form>
-</metal:transitions>

gen/plone25/skin/page.pt

@@ -0,0 +1,728 @@
+<tal:comment replace="nothing">
+  This macro contains global page-related Javascripts.
+</tal:comment>
+<div metal:define-macro="prologue">
+  <tal:comment replace="nothing">Global elements used in every page.</tal:comment>
+
+  <tal:comment replace="nothing">Javascript messages</tal:comment>
+  <script language="javascript" tal:content="tool/getJavascriptMessages"></script>
+
+  <tal:comment replace="nothing">"Static" javascripts</tal:comment>
+  <script language="javascript">
+  <!--
+  var isIe = (navigator.appName == "Microsoft Internet Explorer");
+  // AJAX machinery
+  var xhrObjects = new Array(); // An array of XMLHttpRequest objects
+  function XhrObject() { // Wraps a XmlHttpRequest object
+    this.freed = 1; // Is this xhr object already dealing with a request or not?
+    this.xhr = false;
+    if (window.XMLHttpRequest) this.xhr = new XMLHttpRequest();
+    else this.xhr = new ActiveXObject("Microsoft.XMLHTTP");
+    this.hook = '';  /* The ID of the HTML element in the page that will be
+                        replaced by result of executing the Ajax request. */
+    this.onGet = ''; /* The name of a Javascript function to call once we
+                        receive the result. */
+    this.info = {};  /* An associative array for putting anything else. */
+  }
+
+  function getAjaxChunk(pos) {
+    // This function is the callback called by the AJAX machinery (see function
+    // askAjaxChunk below) when an Ajax response is available.
+    // First, find back the correct XMLHttpRequest object
+    if ( (typeof(xhrObjects[pos]) != 'undefined') &&
+         (xhrObjects[pos].freed == 0)) {
+      var hook = xhrObjects[pos].hook;
+      if (xhrObjects[pos].xhr.readyState == 1) {
+        // The request has been initialized: display the waiting radar
+        var hookElem = document.getElementById(hook);
+        if (hookElem) hookElem.innerHTML = "<div align=\"center\"><img src=\"skyn/waiting.gif\"/><\/div>";
+      }
+      if (xhrObjects[pos].xhr.readyState == 4) {
+        // We have received the HTML chunk
+        var hookElem = document.getElementById(hook);
+        if (hookElem && (xhrObjects[pos].xhr.status == 200)) {
+          hookElem.innerHTML = xhrObjects[pos].xhr.responseText;
+          // Call a custom Javascript function if required
+          if (xhrObjects[pos].onGet) {
+            xhrObjects[pos].onGet(xhrObjects[pos], hookElem);
+          }
+        }
+        xhrObjects[pos].freed = 1;
+      }
+    }
+  }
+
+  function askAjaxChunk(hook,mode,url,page,macro,params,beforeSend,onGet) {
+    /* This function will ask to get a chunk of HTML on the server through a
+       XMLHttpRequest. p_mode can be 'GET' or 'POST'. p_url is the URL of a
+       given server object. On this URL we will call the page "ajax.pt" that
+       will call a specific p_macro in a given p_page with some additional
+       p_params (must be an associative array) if required.
+
+       p_hook is the ID of the HTML element that will be filled with the HTML
+       result from the server.
+
+       p_beforeSend is a Javascript function to call before sending the request.
+       This function will get 2 args: the XMLHttpRequest object and the
+       p_params. This method can return, in a string, additional parameters to
+       send, ie: "&param1=blabla&param2=blabla".
+
+       p_onGet is a Javascript function to call when we will receive the answer.
+       This function will get 2 args, too: the XMLHttpRequest object and the
+       HTML node element into which the result has been inserted.
+    */
+    // First, get a non-busy XMLHttpRequest object.
+    var pos = -1;
+    for (var i=0; i < xhrObjects.length; i++) {
+      if (xhrObjects[i].freed == 1) { pos = i; break; }
+    }
+    if (pos == -1) {
+      pos = xhrObjects.length;
+      xhrObjects[pos] = new XhrObject();
+    }
+    xhrObjects[pos].hook = hook;
+    xhrObjects[pos].onGet = onGet;
+    if (xhrObjects[pos].xhr) {
+      var rq = xhrObjects[pos];
+      rq.freed = 0;
+      // Construct parameters
+      var paramsFull = 'page=' + page + '&macro=' + macro;
+      if (params) {
+        for (var paramName in params)
+          paramsFull = paramsFull + '&' + paramName + '=' + params[paramName];
+      }
+      // Call beforeSend if required
+      if (beforeSend) {
+         var res = beforeSend(rq, params);
+         if (res) paramsFull = paramsFull + res;
+      }
+      // Construct the URL to call
+      var urlFull = url + '/skyn/ajax';
+      if (mode == 'GET') {
+        urlFull = urlFull + '?' + paramsFull;
+      }
+      // Perform the asynchronous HTTP GET or POST
+      rq.xhr.open(mode, urlFull, true);
+      if (mode == 'POST') {
+        // Set the correct HTTP headers
+        rq.xhr.setRequestHeader(
+          "Content-Type", "application/x-www-form-urlencoded");
+        rq.xhr.setRequestHeader("Content-length", paramsFull.length);
+        rq.xhr.setRequestHeader("Connection", "close");
+        rq.xhr.onreadystatechange = function(){ getAjaxChunk(pos); }
+        rq.xhr.send(paramsFull);
+      }
+      else if (mode == 'GET') {
+        rq.xhr.onreadystatechange = function() { getAjaxChunk(pos); }
+        if (window.XMLHttpRequest) { rq.xhr.send(null); }
+        else if (window.ActiveXObject) { rq.xhr.send(); }
+      }
+    }
+  }
+
+  /* The functions below wrap askAjaxChunk for getting specific content through
+     an Ajax request. */
+  function askQueryResult(hookId, objectUrl, contentType, flavourNumber,
+              searchName, startNumber, sortKey, sortOrder, filterKey) {
+    // Sends an Ajax request for getting the result of a query.
+    var params = {'type_name': contentType, 'flavourNumber': flavourNumber,
+                  'search': searchName, 'startNumber': startNumber};
+    if (sortKey) params['sortKey'] = sortKey;
+    if (sortOrder) params['sortOrder'] = sortOrder;
+    if (filterKey) {
+      var filterWidget = document.getElementById(hookId + '_' + filterKey);
+      if (filterWidget && filterWidget.value) {
+        params['filterKey'] = filterKey;
+        params['filterValue'] = filterWidget.value;
+      }
+    }
+    askAjaxChunk(hookId,'GET',objectUrl,'macros','queryResult',params);
+  }
+
+  function askObjectHistory(hookId, objectUrl, startNumber) {
+    // Sends an Ajax request for getting the history of an object
+    var params = {'startNumber': startNumber};
+    askAjaxChunk(hookId, 'GET', objectUrl, 'page', 'objectHistory', params);
+  }
+
+  function askRefField(hookId, objectUrl, fieldName, innerRef, startNumber,
+                       action, actionParams){
+    // Sends an Ajax request for getting the content of a reference field.
+    var startKey = hookId + '_startNumber';
+    var params = {'fieldName': fieldName, 'innerRef': innerRef, };
+    params[startKey] =  startNumber;
+    if (action) params['action'] = action;
+    if (actionParams) {
+        for (key in actionParams) { params[key] = actionParams[key]; };
+    }
+    askAjaxChunk(hookId, 'GET', objectUrl, 'widgets/ref', 'viewContent',params);
+  }
+
+  // Function used by checkbox widgets for having radio-button-like behaviour
+  function toggleCheckbox(visibleCheckbox, hiddenBoolean) {
+    vis = document.getElementById(visibleCheckbox);
+    hidden = document.getElementById(hiddenBoolean);
+    if (vis.checked) hidden.value = 'True';
+    else hidden.value = 'False';
+  }
+  // Functions used for master/slave relationships between widgets
+  function getMasterValue(widget) {
+    // Returns an array of selected options in a select widget
+    res = new Array();
+    if (widget.type == 'checkbox') {
+      var mv = widget.checked + '';
+      mv = mv.charAt(0).toUpperCase() + mv.substr(1);
+      res.push(mv);
+    }
+    else { // SELECT widget
+      for (var i=0; i < widget.options.length; i++) {
+        if (widget.options[i].selected) res.push(widget.options[i].value);
+      }
+    }
+    return res;
+  }
+  function updateSlaves(masterValues, appyTypeId) {
+    // Given the value(s) selected in a master field, this function updates the
+    // state of all corresponding slaves.
+    var slaves = cssQuery('table.slave_' + appyTypeId);
+    for (var i=0; i< slaves.length; i++){
+      slaves[i].style.display = "none";
+    }
+    for (var i=0; i < masterValues.length; i++) {
+      var activeSlaves = cssQuery('table.slaveValue_' + appyTypeId + '_' + masterValues[i]);
+      for (var j=0; j < activeSlaves.length; j++){
+        activeSlaves[j].style.display = "";
+      }
+    }
+  }
+  // Function used for triggering a workflow transition
+  function triggerTransition(transitionId) {
+    var theForm = document.getElementById('triggerTransitionForm');
+    theForm.workflow_action.value = transitionId;
+    theForm.submit();
+  }
+  function onDeleteObject(objectUid) {
+    if (confirm(delete_confirm)) {
+       f = document.getElementById('deleteForm');
+       f.objectUid.value = objectUid;
+       f.submit();
+    }
+  }
+  function toggleCookie(cookieId) {
+    // What is the state of this boolean (expanded/collapsed) cookie?
+    var state = readCookie(cookieId);
+    if ((state != 'collapsed') && (state != 'expanded')) {
+      // No cookie yet, create it.
+      createCookie(cookieId, 'collapsed');
+      state = 'collapsed';
+    }
+    var hook = document.getElementById(cookieId); // The hook is the part of
+    // the HTML document that needs to be shown or hidden.
+    var displayValue = 'none';
+    var newState = 'collapsed';
+    var imgSrc = 'skyn/expand.gif';
+    if (state == 'collapsed') {
+      // Show the HTML zone
+      displayValue = 'block';
+      imgSrc = 'skyn/collapse.gif';
+      newState = 'expanded';
+    }
+    // Update the corresponding HTML element
+    hook.style.display = displayValue;
+    var img = document.getElementById(cookieId + '_img');
+    img.src = imgSrc;
+    // Inverse the cookie value
+    createCookie(cookieId, newState);
+  }
+  // Function that allows to generate a document from a pod template.
+  function generatePodDocument(contextUid, templateUid, fieldName, podFormat) {
+    var theForm = document.forms["podTemplateForm"];
+    theForm.objectUid.value = contextUid;
+    theForm.templateUid.value = templateUid;
+    theForm.fieldName.value = fieldName;
+    theForm.podFormat.value = podFormat;
+    theForm.askAction.value = "False";
+    var askActionWidget = document.getElementById(contextUid + '_' + fieldName);
+    if (askActionWidget && askActionWidget.checked) {
+        theForm.askAction.value = "True";
+    }
+    theForm.submit();
+  }
+  // Functions for opening and closing a popup
+  function openPopup(popupId) {
+    // Open the popup
+    var popup = document.getElementById(popupId);
+    // Put it at the right place on the screen
+    var scrollTop = window.pageYOffset || document.documentElement.scrollTop || 0;
+    popup.style.top = (scrollTop + 150) + 'px';
+    popup.style.display = "block";
+    // Show the greyed zone
+    var greyed = document.getElementById('appyGrey');
+    greyed.style.top = scrollTop + 'px';
+    greyed.style.display = "block";
+  }
+  function closePopup(popupId) {
+    // Close the popup
+    var popup = document.getElementById(popupId);
+    popup.style.display = "none";
+    // Hide the greyed zone
+    var greyed = document.getElementById('appyGrey');
+    greyed.style.display = "none";
+  }
+  // Function triggered when an action needs to be confirmed by the user
+  function askConfirm(formId) {
+    // Store the ID of the form to send if the users confirms.
+    var confirmForm = document.getElementById('confirmActionForm');
+    confirmForm.actionFormId.value = formId;
+    openPopup("confirmActionPopup");
+  }
+  // Function triggered when an action confirmed by the user must be performed
+  function doConfirm() {
+    // The user confirmed: retrieve the form to send and send it.
+    var confirmForm = document.getElementById('confirmActionForm');
+    var actionFormId = confirmForm.actionFormId.value;
+    var actionForm = document.getElementById(actionFormId);
+    actionForm.submit();
+  }
+  // Function that shows or hides a tab. p_action is 'show' or 'hide'.
+  function manageTab(tabId, action) {
+    // Manage the tab content (show it or hide it)
+    var content = document.getElementById('tabcontent_' + tabId);
+    if (action == 'show')   { content.style.display = 'table-row'; }
+    else                    { content.style.display = 'none'; }
+    // Manage the tab itself (show as selected or unselected)
+    var left = document.getElementById('tab_' + tabId + '_left');
+    var tab = document.getElementById('tab_' + tabId);
+    var right = document.getElementById('tab_' + tabId + '_right');
+    if (action == 'show') {
+        left.src  = "skyn/tabLeft.png";
+        tab.style.backgroundImage = "url(skyn/tabBg.png)";
+        right.src = "skyn/tabRight.png";
+    }
+    if (action == 'hide') {
+        left.src  = "skyn/tabLeftu.png";
+        tab.style.backgroundImage = "url(skyn/tabBgu.png)";
+        right.src = "skyn/tabRightu.png";
+    }
+  }
+  // Function used for displaying/hiding content of a tab
+  function showTab(tabId) {
+    // 1st, show the tab to show
+    manageTab(tabId, 'show');
+    // Compute the number of tabs.
+    var idParts = tabId.split('_');
+    var prefix = idParts[0] + '_';
+    // Store the currently selected tab in a cookie.
+    createCookie('tab_' + idParts[0], tabId);
+    var nbOfTabs = idParts[2]*1;
+    // Then, hide the other tabs.
+    for (var i=0; i<nbOfTabs; i++) {
+       var idTab = prefix + (i+1) + '_' + nbOfTabs;
+       if (idTab != tabId) {
+         manageTab(idTab, 'hide');
+       }
+    }
+  }
+  // Function that initializes the state of a tab
+  function initTab(cookieId, defaultValue) {
+    var toSelect = readCookie(cookieId);
+    if (!toSelect) { showTab(defaultValue) }
+    else { showTab(toSelect); }
+  }
+-->
+  </script>
+  <tal:comment replace="nothing">Global form for deleting an object</tal:comment>
+  <form id="deleteForm" method="post" action="skyn/do">
+    <input type="hidden" name="action" value="Delete"/>
+    <input type="hidden" name="objectUid"/>
+  </form>
+  <tal:comment replace="nothing">Global form for generating a document from a pod template.</tal:comment>
+  <form name="podTemplateForm" method="post"
+        tal:attributes="action python: flavour.absolute_url() + '/generateDocument'">
+    <input type="hidden" name="objectUid"/>
+    <tal:comment replace="nothing">templateUid is given if class-wide pod, fieldName and podFormat are given if podField.</tal:comment>
+    <input type="hidden" name="templateUid"/>
+    <input type="hidden" name="fieldName"/>
+    <input type="hidden" name="podFormat"/>
+    <input type="hidden" name="askAction"/>
+  </form>
+</div>
+
+<tal:comment replace="nothing">
+  This macro shows the content of page. Because a page is a layouted object,
+  we simply call the macro that displays a layouted object.
+    contextObj         The Zope object for which this page must be shown
+    layoutType         The kind of layout: "view"? "edit"? "cell"?
+    layout             The layout object that will dictate how object content
+                       will be rendered.
+</tal:comment>
+<metal:show define-macro="show">
+  <metal:layout use-macro="here/skyn/widgets/show/macros/layout"/>
+</metal:show>
+
+<tal:comment replace="nothing">
+  This macro displays all widgets of a given page. It requires:
+    contextObj         The Zope object for which widgets must be shown
+    page               We show widgets of a given page
+    layoutType         We must know if we must render the widgets in a "view",
+                       "edit" or "cell" layout
+</tal:comment>
+<table metal:define-macro="widgets" cellpadding="0" cellspacing="0">
+  <tr tal:repeat="widget python: contextObj.getGroupedAppyTypes(layoutType, page)">
+    <td tal:condition="python: widget['type'] == 'group'">
+      <metal:call use-macro="portal/skyn/widgets/show/macros/group"/>
+    </td>
+    <td tal:condition="python: widget['type'] != 'group'">
+      <metal:call use-macro="portal/skyn/widgets/show/macros/field"/>
+    </td>
+  </tr>
+</table>
+
+<tal:comment replace="nothing">
+  This macro lists the POD templates that are available. It is used by macro "header" below.
+</tal:comment>
+<div metal:define-macro="listPodTemplates" class="appyPod" tal:condition="podTemplates"
+     tal:define="podTemplates python: flavour.getAvailablePodTemplates(contextObj, phase);">
+  <tal:podTemplates define="maxShownTemplates python: flavour.getMaxShownTemplates(contextObj)">
+    <tal:comment replace="nothing">Display templates as links if a few number of templates must be shown</tal:comment>
+    <span class="discreet" tal:condition="python: len(podTemplates)&lt;=maxShownTemplates"
+          tal:repeat="podTemplate podTemplates">
+      <a style="cursor: pointer"
+         tal:define="podFormat podTemplate/getPodFormat"
+         tal:attributes="onclick python: 'javascript:generatePodDocument(\'%s\',\'%s\', \'\', \'\')' % (contextObj.UID(), podTemplate.UID())" >
+        <img tal:attributes="src string: $portal_url/skyn/$podFormat.png"/>
+        <span tal:replace="podTemplate/Title"/>
+      </a>
+  &nbsp;</span>
+  <tal:comment replace="nothing">Display templates as a list if a lot of templates must be shown</tal:comment>
+  <select tal:condition="python: len(podTemplates)&gt;maxShownTemplates">
+    <option value="" tal:content="python: tool.translate('choose_a_doc')"></option>
+    <option tal:repeat="podTemplate podTemplates" tal:content="podTemplate/Title"
+            tal:attributes="onclick python: 'javascript:generatePodDocument(\'%s\',\'%s\', \'\', \'\')' % (contextObj.UID(), podTemplate.UID())" />
+  </select>
+  </tal:podTemplates>
+</div>
+
+<tal:comment replace="nothing">
+  This macro displays an object's history. It is used by macro "header" below.
+</tal:comment>
+<metal:history define-macro="objectHistory"
+      tal:define="startNumber request/startNumber|python:0;
+                  startNumber python: int(startNumber);
+                  historyInfo python: contextObj.getHistory(startNumber);
+                  objs        historyInfo/events;
+                  batchSize   historyInfo/batchSize;
+                  totalNumber historyInfo/totalNumber;
+                  ajaxHookId  python:'appyHistory';
+                  navBaseCall python: 'askObjectHistory(\'%s\',\'%s\',**v**)' % (ajaxHookId, contextObj.absolute_url());
+                  tool        contextObj/getTool">
+
+  <tal:comment replace="nothing">Table containing the history</tal:comment>
+  <tal:history condition="objs">
+  <metal:nav use-macro="here/skyn/navigate/macros/appyNavigate"/>
+  <table width="100%" class="listing nosort">
+    <tr i18n:domain="plone">
+      <th i18n:translate="listingheader_action"/>
+      <th i18n:translate="listingheader_performed_by"/>
+      <th i18n:translate="listingheader_date_and_time"/>
+      <th i18n:translate="listingheader_comment"/>
+    </tr>
+    <tal:event repeat="event objs">
+    <tr tal:define="odd repeat/event/odd;
+                    rhComments event/comments|nothing;
+                    state event/review_state|nothing;
+                    isDataChange python: event['action'] == '_datachange_'"
+        tal:attributes="class python:test(odd, 'even', 'odd')" valign="top">
+      <td tal:condition="isDataChange" tal:content="python: tool.translate('data_change')"></td>
+      <td tal:condition="not: isDataChange"
+          tal:content="python: tool.translate(contextObj.getWorkflowLabel(event['action']))"
+          tal:attributes="class string:state-${state}"/>
+      <td tal:define="actorid python:event.get('actor');
+                      actor python:contextObj.portal_membership.getMemberInfo(actorid);
+                      fullname actor/fullname|nothing;
+                      username actor/username|nothing"
+          tal:content="python:fullname or username or actorid"/>
+      <td tal:content="python:contextObj.restrictedTraverse('@@plone').toLocalizedTime(event['time'],long_format=True)"/>
+      <td tal:condition="not: isDataChange"><tal:comment condition="rhComments" tal:content="structure rhComments"/>
+        <tal:noComment condition="not: rhComments" i18n:translate="no_comments" i18n:domain="plone"/></td>
+      <td tal:condition="isDataChange">
+        <tal:comment replace="nothing">
+          Display the previous values of the fields whose value were modified in this change.</tal:comment>
+        <table class="appyChanges" width="100%">
+          <tr>
+            <th align="left" width="30%" tal:content="python: tool.translate('modified_field')"></th>
+            <th align="left" width="70%" tal:content="python: tool.translate('previous_value')"></th>
+          </tr>
+          <tr tal:repeat="change event/changes/items" valign="top">
+            <td tal:content="python: tool.translate(change[1][1])"></td>
+            <td tal:define="appyValue python: contextObj.getFormattedValue(change[0], useParamValue=True, value=change[1][0]);
+                            appyType python:contextObj.getAppyType(change[0], asDict=True);
+                            severalValues python: (appyType['multiplicity'][1] &gt; 1) or (appyType['multiplicity'][1] == None)">
+              <span tal:condition="not: severalValues" tal:replace="appyValue"></span>
+              <ul tal:condition="python: severalValues">
+                <li tal:repeat="av appyValue" tal:content="av"></li>
+              </ul>
+            </td>
+          </tr>
+        </table>
+      </td>
+    </tr>
+    </tal:event>
+  </table>
+  </tal:history>
+</metal:history>
+
+<tal:comment replace="nothing">
+  This macro displays an object's state(s). It is used by macro "header" below.
+</tal:comment>
+<metal:states define-macro="states"
+              tal:define="showAllStatesInPhase python: flavour.getAttr('showAllStatesInPhaseFor' + contextObj.meta_type);
+                          states python: contextObj.getAppyStates(phase, currentOnly=not showAllStatesInPhase)"
+              tal:condition="python: test(showAllStatesInPhase, len(states)&gt;1, True)">
+  <table>
+    <tr>
+      <tal:state repeat="stateInfo states">
+        <td tal:attributes="class python: 'appyState step' + stateInfo['stateStatus']"
+            tal:content="python: tool.translate(contextObj.getWorkflowLabel(stateInfo['name']))">
+        </td>
+        <td tal:condition="python: stateInfo['name'] != states[-1]['name']">
+          <img tal:attributes="src string: $portal_url/skyn/nextState.png"/>
+        </td>
+      </tal:state>
+    </tr>
+  </table>
+</metal:states>
+
+<tal:comment replace="nothing">
+  This macro displays an object's transitions(s). It is used by macro "header" below.
+</tal:comment>
+<metal:transitions define-macro="transitions"
+                   tal:define="transitions contextObj/getAppyTransitions"
+                   tal:condition="transitions">
+  <form id="triggerTransitionForm" method="post"
+        tal:attributes="action python: contextObj.absolute_url() + '/skyn/do'">
+    <input type="hidden" name="action" value="TriggerTransition"/>
+    <input type="hidden" name="workflow_action"/>
+    <table>
+      <tr>
+        <tal:comment replace="nothing">Input field allowing to enter a comment before triggering a transition</tal:comment>
+        <td tal:define="showCommentsField python:flavour.getAttr('showWorkflowCommentFieldFor'+contextObj.meta_type)"
+            align="right" tal:condition="showCommentsField">
+          <span tal:content="python: tool.translate('workflow_comment')" class="discreet"></span>
+          <input type="text" id="comment" name="comment" size="35"/>
+        </td>
+
+        <tal:comment replace="nothing">Buttons for triggering transitions</tal:comment>
+        <td align="right" tal:repeat="transition transitions">
+          <input type="button" class="context"
+                 tal:attributes="value python: tool.translate(transition['name']);
+                                 onClick python: 'javascript: triggerTransition(\'%s\')' % transition['id'];"/>
+        </td>
+    </tr>
+    </table>
+  </form>
+</metal:transitions>
+
+<tal:comment replace="nothing">
+   This macros displays the page header, containing object title,
+   workflow-related info, object history, etc.
+</tal:comment>
+<div metal:define-macro="header"
+     tal:define="showCommonInfo python: layoutType == 'view';
+                 hasHistory contextObj/hasHistory;
+                 historyExpanded python: tool.getCookieValue('appyHistory', default='collapsed') == 'expanded';
+                 creator contextObj/Creator"
+     tal:condition="not: contextObj/isTemporary">
+
+    <tal:comment replace="nothing">Information that is common to all tabs (object title, state, etc)</tal:comment>
+    <table width="100%" tal:condition="showCommonInfo" class="appyCommonInfo">
+      <tr valign="bottom">
+        <tal:comment replace="nothing">Title and state</tal:comment>
+        <td width="80%">
+          <b class="appyTitle" tal:content="contextObj/title_or_id"></b>
+        </td>
+        <td><metal:actions use-macro="here/document_actions/macros/document_actions"/>
+        </td>
+      </tr>
+      <tr tal:define="descrLabel python: contextObj.translate('%s_edit_descr' % contextObj.portal_type)"
+          tal:condition="descrLabel/strip" >
+        <tal:comment replace="nothing">Content type description</tal:comment>
+        <td colspan="2" class="discreet" tal:content="descrLabel"/>
+      </tr>
+      <tr>
+        <td class="documentByLine">
+          <tal:comment replace="nothing">Creator and last modification date</tal:comment>
+            <tal:comment replace="nothing">Plus/minus icon for accessing history</tal:comment>
+            <tal:accessHistory condition="hasHistory">
+            <img align="left" style="cursor:pointer" onClick="javascript:toggleCookie('appyHistory')"
+                 tal:attributes="src python:test(historyExpanded, 'skyn/collapse.gif', 'skyn/expand.gif');"
+                 id="appyHistory_img"/>&nbsp;
+            <span i18n:translate="label_history" i18n:domain="plone" class="appyHistory"></span>&nbsp;
+            </tal:accessHistory>
+
+            <tal:comment replace="nothing">Show document creator</tal:comment>
+            <tal:creator condition="creator"
+                 define="author python:contextObj.portal_membership.getMemberInfo(creator)">
+            <span class="documentAuthor" i18n:domain="plone" i18n:translate="label_by_author">
+            by <a tal:attributes="href string:${portal_url}/author/${creator}"
+                  tal:content="python:author and author['fullname'] or creator"
+                  tal:omit-tag="not:author" i18n:name="author"/>
+            &mdash;
+            </span>
+            </tal:creator>
+            <tal:comment replace="nothing">Show last modification date</tal:comment>
+            <span i18n:translate="box_last_modified" i18n:domain="plone"></span>
+            <span tal:replace="python:contextObj.restrictedTraverse('@@plone').toLocalizedTime(contextObj.ModificationDate(),long_format=1)"></span>
+        </td>
+        <td valign="top"><metal:pod use-macro="here/skyn/page/macros/listPodTemplates"/>
+        </td>
+      </tr>
+      <tal:comment replace="nothing">Object history</tal:comment>
+      <tr tal:condition="hasHistory">
+        <td colspan="2">
+          <span id="appyHistory"
+                tal:attributes="style python:test(historyExpanded, 'display:block', 'display:none')">
+          <div tal:define="ajaxHookId python: contextObj.UID() + '_history';"
+               tal:attributes="id ajaxHookId">
+             <script language="javascript" tal:content="python: 'askObjectHistory(\'%s\',\'%s\',0)' % (ajaxHookId, contextObj.absolute_url())">
+             </script>
+          </div>
+          </span>
+        </td>
+      </tr>
+      <tal:comment replace="nothing">Workflow-related information and actions</tal:comment>
+      <tr tal:condition="python: showWorkflow and contextObj.getWorkflowLabel()">
+        <td colspan="2" class="appyWorkflow">
+          <table width="100%">
+            <tr>
+              <td><metal:states use-macro="here/skyn/page/macros/states"/></td>
+              <td align="right"><metal:states use-macro="here/skyn/page/macros/transitions"/></td>
+            </tr>
+          </table>
+        </td>
+      </tr>
+    </table>
+</div>
+
+<tal:comment replace="nothing">
+  The page footer.
+</tal:comment>
+<metal:footer define-macro="footer">
+<tal:dummy define="messages putils/showPortalMessages"/>
+<script language="javascript">
+<!--
+  // When the current page is loaded, we must set the correct state for all slave fields.
+  var masters = cssQuery('.appyMaster');
+  for (var i=0; i < masters.length; i++) {
+    var cssClasses = masters[i].className.split(' ');
+    for (var j=0; j < cssClasses.length; j++) {
+      if (cssClasses[j].indexOf('master_') == 0) {
+        var appyId = cssClasses[j].split('_')[1];
+        var masterValue = [];
+        if (masters[i].nodeName == 'SPAN'){
+          var idField = masters[i].id;
+          if (idField == '') {
+            masterValue.push(idField);
+          }
+          else {
+            if (idField[0] == '(') {
+              // There are multiple values, split it
+              var subValues = idField.substring(1, idField.length-1).split(',');
+              for (var k=0; k < subValues.length; k++){
+                var subValue = subValues[k].strip();
+                masterValue.push(subValue.substring(1, subValue.length-1));
+              }
+            }
+            else { masterValue.push(masters[i].id);
+            }
+          }
+        }
+        else { masterValue = getMasterValue(masters[i]);
+        }
+        updateSlaves(masterValue, appyId);
+      }
+    }
+  }
+-->
+</script>
+</metal:footer>
+
+<tal:comment replace="nothing">
+  This macro shows the range of buttons (next, previous, save,...).
+</tal:comment>
+<div metal:define-macro="buttons"
+     tal:define="previousPage   python: contextObj.getPreviousPage(phaseInfo, page);
+                 nextPage       python: contextObj.getNextPage(phaseInfo, page);
+                 isEdit         python: layoutType == 'edit';">
+    <br/>
+    <tal:previousButton condition="previousPage">
+      <tal:button condition="isEdit">
+        <input type="image" class="imageInput" style="cursor:pointer" name="buttonPrevious"
+               title="label_previous" i18n:attributes="title" i18n:domain="plone"
+               tal:attributes="src string:$portal_url/skyn/previous.png"/>
+        <input type="hidden" name="previousPage"  tal:attributes="value previousPage"/>
+      </tal:button>
+      <tal:link condition="not: isEdit">
+        <a tal:attributes="href python: contextObj.getUrl()+'?page=%s' % previousPage">
+          <img tal:attributes="src string:$portal_url/skyn/previous.png"
+               title="label_previous" i18n:attributes="title" i18n:domain="plone"/>
+        </a>
+      </tal:link>
+    </tal:previousButton>
+
+    <tal:saveButton condition="isEdit">
+      <input type="image" class="imageInput" style="cursor:pointer" name="buttonOk"
+             title="label_save" i18n:attributes="title" i18n:domain="plone"
+             tal:attributes="src string:$portal_url/skyn/save.png"/>
+    </tal:saveButton>
+
+    <tal:cancelButton condition="isEdit">
+      <input type="image" class="imageInput" style="cursor:pointer" name="buttonCancel"
+             title="label_cancel" i18n:attributes="title" i18n:domain="plone"
+             tal:attributes="src string:$portal_url/skyn/cancel.png"/>
+    </tal:cancelButton>
+
+    <tal:editLink condition="not:isEdit">
+      <img tal:define="nav request/nav|nothing;
+                       nav python: test(nav, '&nav=%s' % nav, '')"
+           title="Edit" i18n:domain="plone" i18n:attributes="title" style="cursor:pointer"
+           tal:attributes="onClick python: 'href: window.location=\'%s/skyn/edit?page=%s%s\'' % (contextObj.absolute_url(), page, nav);
+                           src string: $portal_url/skyn/editBig.png"
+           tal:condition="python: member.has_permission('Modify portal content', contextObj)"/>
+    </tal:editLink>
+
+    <tal:nextButton condition="nextPage">
+      <tal:button condition="isEdit">
+        <input type="image" class="imageInput" style="cursor:pointer" name="buttonNext"
+               title="label_next" i18n:attributes="title" i18n:domain="plone"
+               tal:attributes="src string:$portal_url/skyn/next.png"/>
+        <input type="hidden" name="nextPage"  tal:attributes="value nextPage"/>
+      </tal:button>
+      <tal:link condition="not: isEdit">
+        <a tal:attributes="href python: contextObj.getUrl()+'?&page=%s' % nextPage">
+          <img tal:attributes="src string:$portal_url/skyn/next.png"
+               title="label_next" i18n:attributes="title" i18n:domain="plone"/>
+        </a>
+      </tal:link>
+    </tal:nextButton>
+</div>
+
+<tal:comment replace="nothing">
+  This macro displays the global message on the page.
+</tal:comment>
+<metal:message define-macro="message" i18n:domain="plone" >
+  <tal:comment replace="nothing">Single message from portal_status_message request key</tal:comment>
+  <div tal:define="msg request/portal_status_message | nothing"
+       tal:condition="msg" class="portalMessage" tal:content="msg" i18n:translate=""></div>
+
+  <tal:comment replace="nothing">Messages added via plone_utils</tal:comment>
+  <tal:messages define="messages putils/showPortalMessages" condition="messages">
+    <tal:msgs define="type_css_map python: {'info':'portalMessage', 'warn':'portalWarningMessage',
+                                            'stop':'portalStopMessage'};"
+              repeat="msg messages">
+      <div tal:define="mtype msg/type | nothing;"
+           tal:attributes="class python:mtype and type_css_map[mtype] or 'info';"
+           tal:content="structure msg/message | nothing" i18n:translate=""></div>
+    </tal:msgs>
+  </tal:messages>
+</metal:message>

gen/plone25/skin/portlet.pt

@@ -2,9 +2,10 @@
     This macro displays the content of the application portlet.
 </tal:comment>
 <metal:portletContent define-macro="portletContent"
-   tal:define="queryUrl python: '%s/skyn/query' % appFolder.absolute_url();
-               currentSearch request/search|nothing;
-               currentType request/type_name|nothing;">
+   tal:define="queryUrl           python: '%s/skyn/query' % appFolder.absolute_url();
+               currentSearch      request/search|nothing;
+               currentType        request/type_name|nothing;
+               contextObj         python: tool.getPublishedObject(rootClasses)">
   <tal:comment replace="nothing">Portlet title, with link to tool.</tal:comment>
   <dt class="portletHeader">
     <tal:comment replace="nothing">If there is only one flavour, clicking on the portlet
@@ -27,6 +28,14 @@
     </td>
   </dt>
 
+  <tal:publishedObject condition="python: contextObj">
+  <dt class="portletAppyItem portletCurrent">
+    <a tal:attributes="href python: contextObj.getUrl() + '?page=main'"
+       tal:content="contextObj/Title"></a>
+  </dt>
+  <dt class="portletAppyItem"><metal:phases use-macro="here/skyn/portlet/macros/phases"/></dt>
+  </tal:publishedObject>
+
   <tal:comment replace="nothing">TODO: implement a widget for selecting the needed flavour.</tal:comment>
   
   <tal:comment replace="nothing">Create a section for every root class.</tal:comment>
@@ -34,7 +43,7 @@
                define="flavourNumber python:1;
                        flavour python: tool.getFlavour('Dummy_%d' % flavourNumber)">
     <tal:comment replace="nothing">Section title, with action icons</tal:comment>
-    <dt tal:attributes="class python:test(repeat['rootClass'].number()==1, 'portletAppyItem', 'portletAppyItem portletSep')">
+    <dt tal:attributes="class python:test((repeat['rootClass'].number()==1) and not contextObj, 'portletAppyItem', 'portletAppyItem portletSep')">
       <table width="100%" cellspacing="0" cellpadding="0" class="no-style-table">
         <tr>
           <td>
@@ -44,7 +53,7 @@
           </td>
           <td align="right"
               tal:define="addPermission python: '%s: Add %s' % (appName, rootClass);
-                          userMayAdd python: member.has_permission(addPermission, appFolder);
+                          userMayAdd python: member.has_permission(addPermission, appFolder) and tool.userMayAdd(rootClass);
                           createMeans python: tool.getCreateMeans(rootClass)">
             <tal:comment replace="nothing">Create a new object from a web form</tal:comment>
             <img style="cursor:pointer"
@@ -115,11 +124,6 @@
                        href python:'%s?type_name=%s&flavourNumber=%d' % (queryUrl, rootClassesQuery, flavourNumber)"></a>
   </dt-->
 
-  <dt class="portletAppyItem" tal:define="contextObj tool/getPublishedObject"
-      tal:condition="python: contextObj.meta_type in rootClasses">
-    <metal:phases use-macro="here/skyn/macros/macros/phases"/>
-  </dt>
-
   <tal:comment replace="nothing">
     Greyed transparent zone that is deployed on the
     whole screen when a popup is displayed.
@@ -140,3 +144,52 @@
   </form>
   </div>
 </metal:portletContent>
+
+<tal:comment replace="nothing">
+   This macro displays, within the portlet, the navigation tree for the
+   currently shown object, made of phases and contained pages.
+</tal:comment>
+<metal:phases define-macro="phases">
+<table tal:define="phases   contextObj/getAppyPhases|nothing;
+                   page python: request.get('page', 'main')"
+       tal:condition="python: phases and not ((len(phases)==1) and len(phases[0]['pages'])==1)"
+       cellspacing="1" cellpadding="0" width="100%">
+  <tal:phase repeat="phase phases">
+    <tal:comment replace="nothing">The box containing phase-related information</tal:comment>
+    <tr>
+      <td tal:define="label python:'%s_phase_%s' % (contextObj.meta_type, phase['name']);
+                      displayLink python: (phase['phaseStatus'] != 'Future') and ('/portal_factory' not in contextObj.absolute_url()) and (len(phase['pages']) == 1)"
+          tal:attributes="class python: 'appyPhase step' + phase['phaseStatus']">
+        <span class="portletGroup" tal:condition="python: len(phases) &gt; 1">
+        <a tal:attributes="href python: '%s?page=%s' % (contextObj.getUrl(), phase['pages'][0]);"
+           tal:condition="displayLink"
+           tal:content="python: tool.translate(label)"></a>
+        <span tal:condition="not: displayLink" tal:replace="python: tool.translate(label)"/>
+        </span>
+        <table width="100%" cellpadding="0" cellspacing="0"
+               tal:condition="python: len(phase['pages']) &gt; 1">
+          <tr tal:repeat="aPage phase/pages" valign="top">
+            <td tal:attributes="class python: test(aPage == page, 'portletCurrent portletPageItem', 'portletPageItem')">
+              <a tal:attributes="href python: contextObj.getUrl()+'?page=%s' % aPage"
+                 tal:content="structure python: tool.translate('%s_page_%s' % (contextObj.meta_type, aPage))">
+              </a>
+            </td>
+            <td>
+              <img tal:define="nav request/nav|nothing;
+                               nav python: test(nav, '&nav=%s' % nav, '')"
+                   title="Edit" i18n:domain="plone" i18n:attributes="title" style="cursor:pointer"
+                   tal:attributes="onClick python: 'href: window.location=\'%s/skyn/edit?page=%s%s\'' % (contextObj.absolute_url(), aPage, nav);
+                               src string: $portal_url/skyn/edit.gif"
+                   tal:condition="python: member.has_permission('Modify portal content', contextObj)"/>
+            </td>
+          </tr>
+        </table>
+      </td>
+    </tr>
+    <tal:comment replace="nothing">The down arrow pointing to the next phase (if any)</tal:comment>
+    <tr tal:condition="python: phase['name'] != phases[-1]['name']">
+      <td>&nbsp;&nbsp;<img tal:attributes="src string: $portal_url/skyn/nextPhase.png"/></td>
+    </tr>
+  </tal:phase>
+</table>
+</metal:phases>

gen/plone25/skin/query.pt

@@ -20,7 +20,7 @@
                  flavourNumber python:int(context.REQUEST.get('flavourNumber'));
                  searchName python:context.REQUEST.get('search', '')">
 
-  <div metal:use-macro="here/skyn/macros/macros/pagePrologue"/>
+  <div metal:use-macro="here/skyn/page/macros/prologue"/>
   <tal:comment replace="nothing">Query result</tal:comment>
   <div id="queryResult"></div>
 

gen/plone25/skin/search.pt

@@ -32,13 +32,13 @@
     <table class="no-style-table" cellpadding="0" cellspacing="0" width="100%"
            tal:define="numberOfColumns python: flavour.getAttr('numberOfSearchColumnsFor%s' % contentType)">
       <tr tal:repeat="searchRow python: tool.tabularize(searchableFields, numberOfColumns)" valign="top">
-        <td tal:repeat="searchField searchRow" tal:attributes="width python:'%d%%' % (100/numberOfColumns)">
-          <tal:field condition="searchField">
-            <tal:showSearchField define="fieldName python:searchField[0];
-                                         appyType python:searchField[1];
-                                         widgetName python: 'w_%s' % fieldName">
-              <metal:searchField use-macro="python: appFolder.skyn.widgets.macros.get('search%s' % searchField[1]['type'])"/>
-            </tal:showSearchField>
+        <td tal:repeat="widget searchRow" tal:attributes="width python:'%d%%' % (100/numberOfColumns)">
+          <tal:field condition="widget">
+            <tal:show define="name widget/name;
+                                   widgetName python: 'w_%s' % name;
+                                   macroPage python: widget['type'].lower()">
+              <metal:call use-macro="python: appFolder.skyn.widgets.get(macroPage).macros.get('search')"/>
+            </tal:show>
           </tal:field><br class="discreet"/>
         </td>
       </tr>

gen/plone25/skin/view.pt

@@ -18,20 +18,19 @@
       tal:define="contextObj python:context.getParentNode();
                   portal_type python:here.getPortalTypeName().lower().replace(' ', '_');
                   errors python:request.get('errors', {});
-                  isEdit python:False;
+                  layoutType python:'view';
+                  layout python: contextObj.getPageLayout(layoutType);
                   tool contextObj/getTool;
                   flavour python: tool.getFlavour(contextObj);
                   appFolder tool/getAppFolder;
-                  appName appFolder/id;
-                  phaseInfo python: contextObj.getAppyPhases(currentOnly=True, forPlone=False);
-                  phase request/phase|phaseInfo/name;
-                  appyPages python: contextObj.getAppyPages(phase);
-                  pageName python: contextObj.getAppyPage(isEdit, phaseInfo, appyPages);
+                  appName appFolder/getId;
+                  page request/page|python:'main';
+                  phaseInfo python: contextObj.getAppyPhases(page=page);
+                  phase phaseInfo/name;
                   showWorkflow python: flavour.getAttr('showWorkflowFor' + contextObj.meta_type)">
-      <metal:prologue use-macro="here/skyn/macros/macros/pagePrologue"/>
-      <metal:header   use-macro="here/skyn/macros/macros/showPageHeader"/>
-      <metal:fields   use-macro="here/skyn/macros/macros/listFields" />
-      <metal:footer   use-macro="here/skyn/macros/macros/showPageFooter"/>
+      <metal:prologue use-macro="here/skyn/page/macros/prologue"/>
+      <metal:show     use-macro="here/skyn/page/macros/show"/>
+      <metal:footer   use-macro="here/skyn/page/macros/footer"/>
     </metal:fill>
   </body>
 </html>

gen/plone25/skin/widgets.pt

@@ -1,142 +0,0 @@
-<metal:searchInteger define-macro="searchInteger">
-  <label tal:content="python: tool.translate(appyType['label'])"></label><br>&nbsp;&nbsp;
-  <tal:from define="fromName python: '%s*int' % widgetName">
-    <label tal:attributes="for fromName" tal:content="python: tool.translate('search_from')"></label>
-    <input type="text" tal:attributes="name fromName" size="4"/>
-  </tal:from>
-  <tal:to define="toName python: '%s_to' % fieldName">
-    <label tal:attributes="for toName" tal:content="python: tool.translate('search_to')"></label>
-    <input type="text" tal:attributes="name toName" size="4"/>
-  </tal:to><br/>
-</metal:searchInteger>
-
-<metal:searchFloat define-macro="searchFloat">
-  <label tal:content="python: tool.translate(appyType['label'])"></label><br>&nbsp;&nbsp;
-  <tal:from define="fromName python: '%s*float' % widgetName">
-    <label tal:attributes="for fromName" tal:content="python: tool.translate('search_from')"></label>
-    <input type="text" tal:attributes="name fromName" size="4"/>
-  </tal:from>
-  <tal:to define="toName python: '%s_to' % fieldName">
-    <label tal:attributes="for toName" tal:content="python: tool.translate('search_to')"></label>
-    <input type="text" tal:attributes="name toName" size="4"/>
-  </tal:to><br/>
-</metal:searchFloat>
-
-<metal:searchString define-macro="searchString">
-  <label tal:attributes="for widgetName" tal:content="python: tool.translate(appyType['label'])"></label><br>&nbsp;&nbsp;
-  <tal:comment replace="nothing">Show a simple search field for most String fields.</tal:comment>
-  <tal:simpleSearch condition="not: appyType/isSelect">
-    <input type="text" tal:attributes="name python: '%s*string-%s' % (widgetName, appyType['transform']);
-                                       style python: 'text-transform:%s' % appyType['transform']"/>
-  </tal:simpleSearch>
-  <tal:comment replace="nothing">Show a multi-selection box for fields whose validator defines a list of values, with a "AND/OR" checkbox.</tal:comment>
-  <tal:selectSearch condition="appyType/isSelect">
-    <tal:comment replace="nothing">The "and" / "or" radio buttons</tal:comment>
-    <tal:operator define="operName python: 'o_%s'   % fieldName;
-                          orName   python: '%s_or'  % operName;
-                          andName  python: '%s_and' % operName;"
-                  condition="python: appyType['multiplicity'][1]!=1">
-    <input type="radio" class="noborder" tal:attributes="name operName; id orName" checked="checked" value="or"/>
-    <label tal:attributes="for orName" tal:content="python: tool.translate('search_or')"></label>
-    <input type="radio" class="noborder" tal:attributes="name operName; id andName" value="and"/>
-    <label tal:attributes="for andName" tal:content="python: tool.translate('search_and')"></label><br/>
-    </tal:operator>
-    <tal:comment replace="nothing">The list of values</tal:comment>
-    <select tal:attributes="name widgetName" multiple="multiple" size="5">
-      <option tal:repeat="v python:tool.getSelectValues(appyType)"
-              tal:attributes="value python:v[0]" tal:content="python: v[1]">
-      </option>
-    </select>
-  </tal:selectSearch><br/>
-</metal:searchString>
-
-<metal:searchBoolean define-macro="searchBoolean"
-                     tal:define="typedWidget python:'%s*bool' % widgetName">
-  <label tal:attributes="for widgetName" tal:content="python: tool.translate(appyType['label'])"></label><br>&nbsp;&nbsp;
-  <tal:yes define="valueId python:'%s_yes' % fieldName">
-    <input type="radio" class="noborder" value="True" tal:attributes="name typedWidget; id valueId"/>
-    <label tal:attributes="for valueId" i18n:translate="yes" i18n:domain="plone"></label>
-  </tal:yes>
-  <tal:no define="valueId python:'%s_no' % fieldName">
-    <input type="radio" class="noborder" value="False" tal:attributes="name typedWidget; id valueId"/>
-    <label tal:attributes="for valueId" i18n:translate="no" i18n:domain="plone"></label>
-  </tal:no>
-  <tal:whatever define="valueId python:'%s_whatever' % fieldName">
-    <input type="radio" class="noborder" value="" tal:attributes="name typedWidget; id valueId" checked="checked"/>
-    <label tal:attributes="for valueId" tal:content="python: tool.translate('whatever')"></label>
-  </tal:whatever><br/>
-</metal:searchBoolean>
-
-<metal:searchDate define-macro="searchDate">
-  <label tal:content="python: tool.translate(appyType['label'])"></label>
-  <table cellpadding="0" cellspacing="0">
-    <tal:comment replace="nothing">From</tal:comment>
-    <tr tal:define="fromName python: '%s*date' % widgetName">
-      <td width="10px">&nbsp;</td>
-      <td>
-        <label tal:content="python: tool.translate('search_from')"></label>
-      </td>
-      <td>
-        <select tal:attributes="name fromName">
-          <option value="">--</option>
-          <option tal:repeat="value python:range(appyType['startYear'], appyType['endYear']+1)"
-                  tal:content="value" tal:attributes="value value"></option>
-        </select> /
-        <select tal:attributes="name python: '%s_from_month' % fieldName">
-          <option value="">--</option>
-          <option tal:repeat="value python: [str(v).zfill(2) for v in range(1, 13)]"
-                  tal:content="python:tool.getMonthName(value)" tal:attributes="value value"></option>
-        </select> /
-        <select tal:attributes="name python: '%s_from_day' % fieldName">
-          <option value="">--</option>
-          <option tal:repeat="value python: [str(v).zfill(2) for v in range(1, 32)]"
-                  tal:content="value" tal:attributes="value value"></option>
-        </select>
-      </td>
-    </tr>
-    <tal:comment replace="nothing">To</tal:comment>
-    <tr>
-      <td></td>
-      <td>
-        <label tal:content="python: tool.translate('search_to')"></label>
-      </td>
-      <td>
-        <select tal:attributes="name python: '%s_to_year' % fieldName">
-          <option value="">--</option>
-          <option tal:repeat="value python:range(appyType['startYear'], appyType['endYear']+1)"
-                 tal:content="value" tal:attributes="value value"></option>
-        </select> /
-        <select tal:attributes="name python: '%s_to_month' % fieldName">
-          <option value="">--</option>
-          <option tal:repeat="value python: [str(v).zfill(2) for v in range(1, 13)]"
-                  tal:content="python:tool.getMonthName(value)" tal:attributes="value value"></option>
-        </select> /
-        <select tal:attributes="name python: '%s_to_day' % fieldName">
-          <option value="">--</option>
-          <option tal:repeat="value python: [str(v).zfill(2) for v in range(1, 32)]"
-                  tal:content="value" tal:attributes="value value"></option>
-        </select>
-      </td>
-    </tr>
-  </table>
-</metal:searchDate>
-
-<metal:searchFile define-macro="searchFile">
-  <p tal:content="fieldName"></p>
-</metal:searchFile>
-
-<metal:searchRef define-macro="searchRef">
-  <p tal:content="fieldName"></p>
-</metal:searchRef>
-
-<metal:searchComputed define-macro="searchComputed">
-  <p tal:content="fieldName"></p>
-</metal:searchComputed>
-
-<metal:searchAction define-macro="searchAction">
-  <p tal:content="fieldName"></p>
-</metal:searchAction>
-
-<metal:searchInfo define-macro="searchInfo">
-  <p tal:content="fieldName"></p>
-</metal:searchInfo>

gen/plone25/skin/widgets/action.pt

@@ -0,0 +1,30 @@
+<tal:comment replace="nothing">View macro for an Action.</tal:comment>
+<metal:view define-macro="view">
+  <form name="executeAppyAction"
+        tal:define="formId python: '%s_%s' % (contextObj.UID(), name);
+                    label  python: contextObj.translate(widget['labelId'])"
+        tal:attributes="id formId; action python: contextObj.absolute_url()+'/skyn/do'">
+    <input type="hidden" name="action" value="ExecuteAppyAction"/>
+    <input type="hidden" name="objectUid" tal:attributes="value contextObj/UID"/>
+    <input type="hidden" name="fieldName" tal:attributes="value name"/>
+    <input type="button" tal:condition="widget/confirm"
+           tal:attributes="value label;
+                           onClick python: 'javascript:askConfirm(\'%s\')' % formId"/>
+    <input type="submit" name="do" tal:condition="not: widget/confirm"
+           tal:attributes="value label" onClick="javascript:;"/>
+    <tal:comment replace="nothing">The previous onClick is simply used to prevent Plone
+      from adding a CSS class that displays a popup when the user triggers the form multiple
+      times.</tal:comment>
+  </form>
+</metal:view>
+
+<tal:comment replace="nothing">Edit macro for an Action.</tal:comment>
+<metal:edit define-macro="edit"></metal:edit>
+
+<tal:comment replace="nothing">Cell macro for an Action.</tal:comment>
+<metal:cell define-macro="cell">
+  <metal:call use-macro="portal/skyn/widgets/action/macros/view"/>
+</metal:cell>
+
+<tal:comment replace="nothing">Search macro for an Action.</tal:comment>
+<metal:search define-macro="search"></metal:search>

gen/plone25/skin/widgets/boolean.pt

@@ -0,0 +1,39 @@
+<tal:comment replace="nothing">View macro for a Boolean.</tal:comment>
+<metal:view define-macro="view"><span tal:replace="value"/></metal:view>
+
+<tal:comment replace="nothing">Edit macro for an Boolean.</tal:comment>
+<metal:edit define-macro="edit">
+  <input type="checkbox"
+         tal:attributes="name python: name + '_visible';
+                         id name;
+                         checked python:contextObj.checkboxChecked(name);
+                         onClick python:'toggleCheckbox(\'%s\', \'%s_hidden\');;updateSlaves(getMasterValue(this), \'%s\')' % (name, name, widget['id']);
+                         class python: 'noborder ' + widget['master_css']"/>
+  <input tal:attributes="name name;
+                         id string:${name}_hidden;
+                         value python: test(contextObj.checkboxChecked(name), 'True', 'False')"
+         type="hidden" />&nbsp;
+</metal:edit>
+
+<tal:comment replace="nothing">Cell macro for an Boolean.</tal:comment>
+<metal:cell define-macro="cell">
+  <metal:call use-macro="portal/skyn/widgets/boolean/macros/view"/>
+</metal:cell>
+
+<tal:comment replace="nothing">Search macro for an Boolean.</tal:comment>
+<metal:search define-macro="search"
+              tal:define="typedWidget python:'%s*bool' % widgetName">
+  <label tal:attributes="for widgetName" tal:content="python: tool.translate(widget['labelId'])"></label><br>&nbsp;&nbsp;
+  <tal:yes define="valueId python:'%s_yes' % name">
+    <input type="radio" class="noborder" value="True" tal:attributes="name typedWidget; id valueId"/>
+    <label tal:attributes="for valueId" i18n:translate="yes" i18n:domain="plone"></label>
+  </tal:yes>
+  <tal:no define="valueId python:'%s_no' % name">
+    <input type="radio" class="noborder" value="False" tal:attributes="name typedWidget; id valueId"/>
+    <label tal:attributes="for valueId" i18n:translate="no" i18n:domain="plone"></label>
+  </tal:no>
+  <tal:whatever define="valueId python:'%s_whatever' % name">
+    <input type="radio" class="noborder" value="" tal:attributes="name typedWidget; id valueId" checked="checked"/>
+    <label tal:attributes="for valueId" tal:content="python: tool.translate('whatever')"></label>
+  </tal:whatever><br/>
+</metal:search>

gen/plone25/skin/widgets/computed.pt

@@ -0,0 +1,18 @@
+<tal:comment replace="nothing">View macro for a Computed.</tal:comment>
+<metal:view define-macro="view">
+  <span tal:condition="widget/plainText" tal:replace="value"/>
+  <span tal:condition="not: widget/plainText" tal:replace="structure value"/>
+</metal:view>
+
+<tal:comment replace="nothing">Edit macro for a Computed.</tal:comment>
+<metal:edit define-macro="edit">
+  <metal:call use-macro="portal/skyn/widgets/computed/macros/view"/>
+</metal:edit>
+
+<tal:comment replace="nothing">Cell macro for a Computed.</tal:comment>
+<metal:cell define-macro="cell">
+  <metal:call use-macro="portal/skyn/widgets/computed/macros/view"/>
+</metal:cell>
+
+<tal:comment replace="nothing">Search macro for a Computed.</tal:comment>
+<metal:search define-macro="search"></metal:search>

gen/plone25/skin/widgets/date.pt

@@ -0,0 +1,132 @@
+<tal:comment replace="nothing">View macro for a Date.</tal:comment>
+<metal:view define-macro="view"><span tal:replace="value"/></metal:view>
+
+<tal:comment replace="nothing">Edit macro for an Date.</tal:comment>
+<metal:edit define-macro="edit"
+            tal:define="years python:range(widget['startYear'], widget['endYear']+1);
+                        dummyName python: '_d_ummy_%s' % name">
+  <tal:comment replace="nothing">This field is not used but required by the Javascript popup.</tal:comment>
+  <input type="hidden" tal:attributes="name dummyName; id dummyName"/>
+  <tal:comment replace="nothing">Day</tal:comment>
+  <select tal:define="days python:range(1,32)"
+          tal:attributes="name string:${name}_day;
+                          id   string:${name}_day;">
+    <option value="">-</option>
+    <tal:days repeat="day days">
+      <option tal:define="zDay python: str(day).zfill(2)"
+              tal:attributes="value zDay;
+                              selected python:contextObj.dateValueSelected(name, 'day', day)"
+              tal:content="zDay"></option>
+    </tal:days>
+  </select>
+
+  <tal:comment replace="nothing">Month</tal:comment>
+  <select tal:define="months python:range(1,13)"
+          tal:attributes="name string:${name}_month;
+                          id   string:${name}_month;">
+    <option value="">-</option>
+    <tal:months repeat="month months">
+      <option tal:define="zMonth python: str(month).zfill(2)"
+              tal:attributes="value zMonth;
+                              selected python:contextObj.dateValueSelected(name, 'month', month)"
+              tal:content="zMonth"></option>
+    </tal:months>
+  </select>
+
+  <tal:comment replace="nothing">Year</tal:comment>
+  <select tal:attributes="name string:${name}_year;
+                          id   string:${name}_year;">
+    <option value="">-</option>
+    <option tal:repeat="year years"
+            tal:attributes="value year;
+                            selected python:contextObj.dateValueSelected(name, 'year', year)"
+            tal:content="year"></option>
+  </select>
+  <tal:comment replace="nothing">The icon for displaying the date chooser</tal:comment>
+  <a tal:attributes="onclick python: 'return showJsCalendar(\'%s_month\', \'%s\', \'%s_year\', \'%s_month\', \'%s_day\', null, null, %d, %d)' % (name, dummyName, name, name, name, years[0], years[-1])"><img tal:attributes="src string: $portal_url/popup_calendar.gif"/></a>
+
+  <tal:hour condition="python: widget['format'] == 0">
+    <select tal:define="hours python:range(0,24);"
+            tal:attributes="name string:${name}_hour;
+                            id   string:${name}_hour;">
+      <option value="">-</option>
+      <tal:hours repeat="hour hours">
+        <option tal:define="zHour python: str(hour).zfill(2)"
+                tal:attributes="value zHour;
+                                selected python:contextObj.dateValueSelected(name, 'hour', hour)"
+                tal:content="zHour"></option>
+      </tal:hours>
+    </select> :
+    <select tal:define="minutes python:range(0,60,5);"
+            tal:attributes="name string:${name}_minute;
+                            id   string:${name}_minute;">
+      <option value="">-</option>
+      <tal:minutes repeat="minute minutes">
+        <option tal:define="zMinute python: str(minute).zfill(2)"
+                tal:attributes="value zMinute;
+                                selected python:contextObj.dateValueSelected(name, 'minute', minute)"
+                tal:content="zMinute"></option>
+      </tal:minutes>
+    </select>
+  </tal:hour>
+</metal:edit>
+
+<tal:comment replace="nothing">Cell macro for an Date.</tal:comment>
+<metal:cell define-macro="cell">
+  <metal:call use-macro="portal/skyn/widgets/date/macros/view"/>
+</metal:cell>
+
+<tal:comment replace="nothing">Search macro for an Date.</tal:comment>
+<metal:search define-macro="search">
+  <label tal:content="python: tool.translate(widget['labelId'])"></label>
+  <table cellpadding="0" cellspacing="0">
+    <tal:comment replace="nothing">From</tal:comment>
+    <tr tal:define="fromName python: '%s*date' % widgetName">
+      <td width="10px">&nbsp;</td>
+      <td>
+        <label tal:content="python: tool.translate('search_from')"></label>
+      </td>
+      <td>
+        <select tal:attributes="name fromName">
+          <option value="">--</option>
+          <option tal:repeat="value python:range(widget['startYear'], widget['endYear']+1)"
+                  tal:content="value" tal:attributes="value value"></option>
+        </select> /
+        <select tal:attributes="name python: '%s_from_month' % name">
+          <option value="">--</option>
+          <option tal:repeat="value python: [str(v).zfill(2) for v in range(1, 13)]"
+                  tal:content="python:tool.getMonthName(value)" tal:attributes="value value"></option>
+        </select> /
+        <select tal:attributes="name python: '%s_from_day' % name">
+          <option value="">--</option>
+          <option tal:repeat="value python: [str(v).zfill(2) for v in range(1, 32)]"
+                  tal:content="value" tal:attributes="value value"></option>
+        </select>
+      </td>
+    </tr>
+    <tal:comment replace="nothing">To</tal:comment>
+    <tr>
+      <td></td>
+      <td>
+        <label tal:content="python: tool.translate('search_to')"></label>
+      </td>
+      <td>
+        <select tal:attributes="name python: '%s_to_year' % name">
+          <option value="">--</option>
+          <option tal:repeat="value python:range(widget['startYear'], widget['endYear']+1)"
+                 tal:content="value" tal:attributes="value value"></option>
+        </select> /
+        <select tal:attributes="name python: '%s_to_month' % name">
+          <option value="">--</option>
+          <option tal:repeat="value python: [str(v).zfill(2) for v in range(1, 13)]"
+                  tal:content="python:tool.getMonthName(value)" tal:attributes="value value"></option>
+        </select> /
+        <select tal:attributes="name python: '%s_to_day' % name">
+          <option value="">--</option>
+          <option tal:repeat="value python: [str(v).zfill(2) for v in range(1, 32)]"
+                  tal:content="value" tal:attributes="value value"></option>
+        </select>
+      </td>
+    </tr>
+  </table>
+</metal:search>

gen/plone25/skin/widgets/file.pt

@@ -0,0 +1,73 @@
+<tal:comment replace="nothing">View macro for a File.</tal:comment>
+<metal:view define-macro="view"
+            tal:define="empty python: not value or not value.size;
+                        imageSrc string:${contextObj/absolute_url}/download?name=$name">
+  <tal:file condition="python: not empty and not widget['isImage']">
+    <img tal:define="icon value/getBestIcon"
+         tal:condition="icon" tal:attributes="src string: $portal_url/$icon"/>
+    <a tal:attributes="href imageSrc"
+       tal:content="value/filename">
+    </a>&nbsp;&nbsp;-
+    <i class="discreet" tal:content="python:'%sKb' % (value.size / 1024)"></i>
+  </tal:file>
+  <tal:image condition="python: not empty and widget['isImage']">
+    <img tal:attributes="src python: imageSrc" />
+  </tal:image>
+  <tal:nothing tal:condition="empty">-</tal:nothing>
+</metal:view>
+
+<tal:comment replace="nothing">Edit macro for an File.</tal:comment>
+<metal:edit define-macro="edit">
+<tal:showFile condition="python: value and value.size">
+  <metal:call use-macro="portal/skyn/widgets/file/macros/view"/><br/>
+</tal:showFile>
+<tal:editButtons condition="python: value and value.size">
+  <tal:comment replace="nothing">Keep the file untouched.</tal:comment>
+  <input class="noborder" type="radio" value="nochange"
+         tal:attributes="checked python:test(value.size!=0, 'checked', None);
+                         name string:${name}_delete;
+                         id string:${name}_nochange;
+                         onclick string:document.getElementById('${name}_file').disabled=true;"/>
+  <label tal:attributes="for string:${name}_nochange"
+         i18n:translate="nochange_file" i18n:domain="plone">
+  </label>
+  <br/>
+  <tal:comment replace="nothing">Delete the file.</tal:comment>
+  <tal:delete condition="not: widget/required">
+  <input class="noborder" type="radio" value="delete"
+         tal:attributes="name string:${name}_delete;
+                         id string:${name}_delete;
+                         onclick string:document.getElementById('${name}_file').disabled=true;"/>
+  <label tal:attributes="for string:${name}_delete"
+         i18n:translate="delete_file" i18n:domain="plone">
+  </label>
+  <br/>
+  </tal:delete>
+  <tal:comment replace="nothing">Replace with a new file.</tal:comment>
+  <input class="noborder" type="radio" value=""
+         tal:attributes="checked python:test(value.size==0, 'checked', None);
+                         name string:${name}_delete;
+                         id string:${name}_upload;
+                         onclick string:document.getElementById('${name}_file').disabled=false"/>
+  <label tal:attributes="for string:${name}_upload;"
+         i18n:translate="upload_file" i18n:domain="plone">
+  </label>
+  <br/>
+</tal:editButtons>
+<tal:comment replace="nothing">The upload field.</tal:comment>
+<input type="file" size="30"
+       tal:attributes="name string:${name}_file;
+                       id string:${name}_file;"/>
+<script type="text/javascript" 
+        tal:define="isDisabled python:test(value and value.size, 'true', 'false')"
+        tal:content="string: document.getElementById('${name}_file').disabled=$isDisabled;">
+</script>
+</metal:edit>
+
+<tal:comment replace="nothing">Cell macro for an File.</tal:comment>
+<metal:cell define-macro="cell">
+  <metal:call use-macro="portal/skyn/widgets/file/macros/view"/>
+</metal:cell>
+
+<tal:comment replace="nothing">Search macro for an File.</tal:comment>
+<metal:search define-macro="search"></metal:search>

gen/plone25/skin/widgets/float.pt

@@ -0,0 +1,29 @@
+<tal:comment replace="nothing">View macro for a Float.</tal:comment>
+<metal:view define-macro="view">
+  <span tal:content="value"
+        tal:attributes="id value; class widget/master_css"></span>
+</metal:view>
+
+<tal:comment replace="nothing">Edit macro for an Float.</tal:comment>
+<metal:edit define-macro="edit">
+  <input tal:attributes="id name; name name; size widget/width;
+                         value python: test(inRequest, requestValue, value)" type="text"/>
+</metal:edit>
+
+<tal:comment replace="nothing">Cell macro for an Float.</tal:comment>
+<metal:cell define-macro="cell">
+  <metal:call use-macro="portal/skyn/widgets/float/macros/view"/>
+</metal:cell>
+
+<tal:comment replace="nothing">Search macro for an Float.</tal:comment>
+<metal:search define-macro="search">
+  <label tal:content="python: tool.translate(widget['labelId'])"></label><br>&nbsp;&nbsp;
+  <tal:from define="fromName python: '%s*float' % widgetName">
+    <label tal:attributes="for fromName" tal:content="python: tool.translate('search_from')"></label>
+    <input type="text" tal:attributes="name fromName" size="4"/>
+  </tal:from>
+  <tal:to define="toName python: '%s_to' % name">
+    <label tal:attributes="for toName" tal:content="python: tool.translate('search_to')"></label>
+    <input type="text" tal:attributes="name toName" size="4"/>
+  </tal:to><br/>
+</metal:search>

gen/plone25/skin/widgets/info.pt

@@ -0,0 +1,11 @@
+<tal:comment replace="nothing">View macro for an Info.</tal:comment>
+<metal:view define-macro="view"><tal:comment replace="nothing">Shows nothing more.</tal:comment></metal:view>
+
+<tal:comment replace="nothing">Edit macro for an Info.</tal:comment>
+<metal:edit define-macro="edit"></metal:edit>
+
+<tal:comment replace="nothing">Cell macro for an Info.</tal:comment>
+<metal:cell define-macro="cell"></metal:cell>
+
+<tal:comment replace="nothing">Search macro for an Info.</tal:comment>
+<metal:search define-macro="search"></metal:search>

gen/plone25/skin/widgets/integer.pt

@@ -0,0 +1,28 @@
+<tal:comment replace="nothing">View macro for an Integer.</tal:comment>
+<metal:view define-macro="view">
+  <span tal:content="value" tal:attributes="id value; class widget/master_css"></span>
+</metal:view>
+
+<tal:comment replace="nothing">Edit macro for an Integer.</tal:comment>
+<metal:edit define-macro="edit">
+  <input tal:attributes="id name; name name; size widget/width;
+                         value python: test(inRequest, requestValue, value)" type="text"/>
+</metal:edit>
+
+<tal:comment replace="nothing">Cell macro for an Integer.</tal:comment>
+<metal:cell define-macro="cell">
+  <metal:call use-macro="portal/skyn/widgets/integer/macros/view"/>
+</metal:cell>
+
+<tal:comment replace="nothing">Search macro for an Integer.</tal:comment>
+<metal:search define-macro="search">
+  <label tal:content="python: tool.translate(widget['labelId'])"></label><br>&nbsp;&nbsp;
+  <tal:from define="fromName python: '%s*int' % widgetName">
+    <label tal:attributes="for fromName" tal:content="python: tool.translate('search_from')"></label>
+    <input type="text" tal:attributes="name fromName" size="4"/>
+  </tal:from>
+  <tal:to define="toName python: '%s_to' % name">
+    <label tal:attributes="for toName" tal:content="python: tool.translate('search_to')"></label>
+    <input type="text" tal:attributes="name toName" size="4"/>
+  </tal:to><br/>
+</metal:search>

gen/plone25/skin/widgets/pod.pt

@@ -0,0 +1,26 @@
+<tal:comment replace="nothing">View macro for a Pod.</tal:comment>
+<metal:view define-macro="view">
+  <tal:askAction condition="widget/askAction"
+                 define="doLabel   python:'%s_askaction' % widget['labelId'];
+                         chekboxId python: '%s_%s' % (contextObj.UID(), name)">
+    <input type="checkbox" tal:attributes="name doLabel; id chekboxId"/>
+    <label tal:attributes="for chekboxId" class="discreet"
+           tal:content="python: tool.translate(doLabel)"></label>
+  </tal:askAction>
+  <img tal:repeat="podFormat python:flavour.getPodInfo(contextObj, name)['formats']"
+       tal:attributes="src string: $portal_url/skyn/${podFormat}.png;
+                       onClick python: 'javascript:generatePodDocument(\'%s\',\'\',\'%s\',\'%s\')' % (contextObj.UID(), name, podFormat);
+                       title podFormat/capitalize"
+       style="cursor:pointer"/>
+</metal:view>
+
+<tal:comment replace="nothing">Edit macro for a Pod.</tal:comment>
+<metal:edit define-macro="edit"></metal:edit>
+
+<tal:comment replace="nothing">Cell macro for a Pod.</tal:comment>
+<metal:cell define-macro="cell">
+  <metal:call use-macro="portal/skyn/widgets/pod/macros/view"/>
+</metal:cell>
+
+<tal:comment replace="nothing">Search macro for a Pod.</tal:comment>
+<metal:search define-macro="search"></metal:search>

gen/plone25/skin/widgets/ref.pt

@@ -1,5 +1,6 @@
-<tal:comment replace="nothing"> We begin with some sub-macros used within
-  macro "showReference" defined below.</tal:comment>
+<tal:comment replace="nothing">
+  We begin with some sub-macros used within macro "show" defined below.
+</tal:comment>
 
 <metal:objectTitle define-macro="objectTitle">
   <tal:comment replace="nothing">Displays the title of a referenced object, with a link on
@@ -9,7 +10,7 @@
     from one object to the next/previous on skyn/view.</tal:comment>
   <a tal:define="viewUrl obj/getUrl;
                  navInfo python:'nav=ref.%s.%s.%d.%d' % (contextObj.UID(), fieldName, repeat['obj'].number()+startNumber, totalNumber);
-                 fullUrl python: test(isBack, viewUrl + '/?pageName=%s&phase=%s' % (appyType['page'], appyType['phase']), viewUrl + '/?' + navInfo)"
+                 fullUrl python: test(appyType['isBack'], viewUrl + '/?page=%s' % appyType['page'], viewUrl + '/?' + navInfo)"
      tal:attributes="href fullUrl" tal:content="obj/Title"></a>
 </metal:objectTitle>
 
@@ -77,42 +78,28 @@
                        onClick python: ajaxBaseCall.replace('**v**', 'True')"/>
 </metal:sortIcons>
 
-<tal:comment replace="nothing">
-  This macro shows a reference field. More precisely, it shows nothing, but calls
-  a Javascript function that will asynchonously call (via a XmlHttpRequest object) the
-  macro 'showReferenceContent' defined below, that will really show content.
-  It requires:
-   - isBack (bool) Is the reference a backward or forward reference?
-   - fieldName (string) The name of the reference field (if it is a forward reference)
-                        or the name of the Archetypes relationship (if it is a backward reference)
-   - innerRef (bool) Are we rendering a reference within a reference or not?
-   - contextObj (object) the object from which the reference starts
-   - labelId (string) the i18n id of the reference field label
-   - descrId (string) the i18n id of the reference field description
-</tal:comment>
-<div metal:define-macro="showReference"
-     tal:define="ajaxHookId   python: contextObj.UID() + fieldName"
-     tal:attributes="id ajaxHookId">
+<tal:comment replace="nothing">View macro for a Ref.</tal:comment>
+<div metal:define-macro="view"
+     tal:define= "innerRef   innerRef|python:False;
+                  ajaxHookId python: contextObj.UID() + name"
+     tal:attributes = "id ajaxHookId">
   <script language="javascript"
-          tal:content="python: 'askRefField(\'%s\',\'%s\',\'%s\',\'%s\',\'%s\',\'%s\',\'%s\',0)' % (ajaxHookId, contextObj.absolute_url(), fieldName, isBack, innerRef, labelId, descrId)">
+          tal:content="python: 'askRefField(\'%s\',\'%s\',\'%s\',\'%s\',0)' % (ajaxHookId, contextObj.absolute_url(), name, innerRef)">
   </script>
 </div>
 
 <tal:comment replace="nothing">
-   This macro is called by a XmlHttpRequest for displaying the paginated referred objects
-   of a reference field.
+   This macro is called by a XmlHttpRequest for displaying the paginated
+   referred objects of a reference field.
 </tal:comment>
-<div metal:define-macro="showReferenceContent"
+<div metal:define-macro="viewContent"
      tal:define="fieldName request/fieldName;
-                 isBack python: test(request['isBack']=='True', True, False);
+                 appyType python: contextObj.getAppyType(fieldName, asDict=True);
                  innerRef python: test(request['innerRef']=='True', True, False);
-                 labelId request/labelId;
-                 descrId request/descrId;
                  ajaxHookId python: contextObj.UID()+fieldName;
                  startNumber python: int(request.get('%s_startNumber' % ajaxHookId, 0));
-                 appyType python: contextObj.getAppyType(fieldName, not isBack);
                  tool contextObj/getTool;
-                 refObjects python:contextObj.getAppyRefs(fieldName, not isBack, startNumber);
+                 refObjects python:contextObj.getAppyRefs(appyType, startNumber);
                  objs refObjects/objects;
                  totalNumber refObjects/totalNumber;
                  batchSize refObjects/batchSize;
@@ -120,14 +107,14 @@
                  flavour python:tool.getFlavour(contextObj);
                  linkedPortalType python:flavour.getPortalType(appyType['klass']);
                  addPermission python: '%s: Add %s' % (tool.getAppName(), linkedPortalType);
-                 canWrite python: not isBack and member.has_permission(contextObj.getField(fieldName).write_permission, contextObj);
-                 multiplicity python:test(isBack, appyType['backd']['multiplicity'], appyType['multiplicity']);
+                 canWrite python: not appyType['isBack'] and member.has_permission(appyType['writePermission'], contextObj);
+                 multiplicity appyType/multiplicity;
                  maxReached python:(multiplicity[1] != None) and (len(objs) >= multiplicity[1]);
-                 showPlusIcon python:not isBack and appyType['add'] and not maxReached and member.has_permission(addPermission, folder) and canWrite;
+                 showPlusIcon python:not appyType['isBack'] and appyType['add'] and not maxReached and member.has_permission(addPermission, folder) and canWrite;
                  atMostOneRef python: (multiplicity[1] == 1) and (len(objs)&lt;=1);
-                 label python: tool.translate(labelId);
-                 description python: tool.translate(descrId);
-                 navBaseCall python: 'askRefField(\'%s\',\'%s\',\'%s\',\'%s\',\'%s\',\'%s\',\'%s\',**v**)' % (ajaxHookId, contextObj.absolute_url(), fieldName, isBack, innerRef, labelId, descrId)">
+                 label python: tool.translate(appyType['labelId']);
+                 description python: tool.translate(appyType['descrId']);
+                 navBaseCall python: 'askRefField(\'%s\',\'%s\',\'%s\',\'%s\',**v**)' % (ajaxHookId, contextObj.absolute_url(), fieldName, innerRef)">
 
   <tal:comment replace="nothing">This macro displays the Reference widget on a "consult" page.
 
@@ -139,20 +126,20 @@
     <tal:comment replace="nothing">Display a simplified widget if maximum number of
       referenced objects is 1.</tal:comment>
     <table class="no-style-table" cellpadding="0" cellspacing="0"><tr valign="top">
-      <td><span class="appyLabel" tal:condition="not: innerRef" tal:content="label"></span></td>
+      <td><span class="appyLabel" tal:condition="not: innerRef" tal:content="structure label"></span></td>
 
       <tal:comment replace="nothing">If there is no object...</tal:comment>
       <tal:noObject condition="not:objs">
         <td tal:content="python: tool.translate('no_ref')"></td>
-        <td><metal:plusIcon use-macro="here/skyn/ref/macros/plusIcon"/></td>
+        <td><metal:plusIcon use-macro="portal/skyn/widgets/ref/macros/plusIcon"/></td>
       </tal:noObject>
 
       <tal:comment replace="nothing">If there is an object...</tal:comment>
       <tal:objectIsPresent condition="python: len(objs) == 1">
         <tal:obj repeat="obj objs">
-          <td><metal:showObjectTitle use-macro="here/skyn/ref/macros/objectTitle" /></td>
-          <td tal:condition="not: isBack">
-            <metal:showObjectActions use-macro="here/skyn/ref/macros/objectActions" />
+          <td><metal:showObjectTitle use-macro="portal/skyn/widgets/ref/macros/objectTitle" /></td>
+          <td tal:condition="not: appyType/isBack">
+            <metal:showObjectActions use-macro="portal/skyn/widgets/ref/macros/objectActions" />
           </td>
         </tal:obj>
       </tal:objectIsPresent>
@@ -165,12 +152,12 @@
       <legend tal:condition="python: not innerRef or showPlusIcon">
         <span tal:condition="not: innerRef" tal:content="label"/>
         (<span tal:replace="totalNumber"/>)
-        <metal:plusIcon use-macro="here/skyn/ref/macros/plusIcon"/>
+        <metal:plusIcon use-macro="portal/skyn/widgets/ref/macros/plusIcon"/>
       </legend>
 
       <tal:comment replace="nothing">Object description</tal:comment>
-      <p tal:condition="python: not innerRef and description.strip()"
-         tal:content="description" class="discreet" ></p>
+      <!--p tal:condition="python: not innerRef and description.strip()"
+         tal:content="description" class="discreet" ></p-->
 
       <tal:comment replace="nothing">Appy (top) navigation</tal:comment>
       <metal:nav use-macro="here/skyn/navigate/macros/appyNavigate"/>
@@ -184,35 +171,29 @@
 
         <tal:comment replace="nothing">Show backward reference(s)</tal:comment>
         <table class="no-style-table" cellspacing="0" cellpadding="0"
-               tal:condition="python: isBack and objs">
+               tal:condition="python: appyType['isBack'] and objs">
           <tr tal:repeat="obj objs">
-            <td><metal:showObjectTitle use-macro="here/skyn/ref/macros/objectTitle" />
+            <td><metal:showObjectTitle use-macro="portal/skyn/widgets/ref/macros/objectTitle" />
             </td>
           </tr>
         </table>
 
         <tal:comment replace="nothing">Show forward reference(s)</tal:comment>
         <table tal:attributes="class python:test(innerRef, '', 'listing nosort');
-                               width python:test(innerRef, '100%', test(appyType['wide'], '100%', ''))"
-               align="right" tal:condition="python: not isBack and objs" cellpadding="0" cellspacing="0">
+                               width python:test(innerRef, '100%', appyType['layouts']['view']['width']);"
+               align="right" tal:condition="python: not appyType['isBack'] and objs" cellpadding="0" cellspacing="0">
+          <tal:widgets define="widgets python: objs[0].getAppyTypesFromNames(appyType['shownInfo'])">
           <tr tal:condition="appyType/showHeaders">
             <th tal:condition="python: 'title' not in appyType['shownInfo']"
                 tal:define="shownField python:'title'">
               <span tal:content="python: tool.translate('ref_name')"></span>
-              <metal:sortIcons use-macro="here/skyn/ref/macros/sortIcons" />
+              <metal:sortIcons use-macro="portal/skyn/widgets/ref/macros/sortIcons" />
             </th>
-            <th tal:repeat="shownField appyType/shownInfo">
-              <tal:showHeader condition="python: objs[0].getField(shownField)">
-                <tal:titleHeader condition="python: shownField == 'title'">
-                  <span tal:content="python: tool.translate('ref_name')"></span>
-                  <metal:sortIcons use-macro="here/skyn/ref/macros/sortIcons" />
-                </tal:titleHeader>
-                <tal:otherHeader condition="python: shownField != 'title'"
-                                 define="labelId python: objs[0].getField(shownField).widget.label_msgid">
-                  <span tal:content="python: tool.translate(labelId)"></span>
-                  <metal:sortIcons use-macro="here/skyn/ref/macros/sortIcons" />
-                </tal:otherHeader>
-              </tal:showHeader>
+            <th tal:repeat="widget widgets">
+              <tal:header define="shownField widget/name">
+                <span tal:content="python: tool.translate(widget['labelId'])"></span>
+                <metal:sortIcons use-macro="portal/skyn/widgets/ref/macros/sortIcons" />
+              </tal:header>
             </th>
             <th tal:content="python: tool.translate('ref_actions')"></th>
           </tr>
@@ -222,41 +203,27 @@
             <tal:comment replace="nothing">Object title, shown here if not specified somewhere
               else in appyType.shownInfo.</tal:comment>
             <td tal:condition="python: 'title' not in appyType['shownInfo']"><metal:showObjectTitle
-                use-macro="here/skyn/ref/macros/objectTitle"/>&nbsp;
+                use-macro="portal/skyn/widgets/ref/macros/objectTitle"/>&nbsp;
             </td>
             <tal:comment replace="nothing">Additional fields that must be shown</tal:comment>
-            <td tal:repeat="shownField appyType/shownInfo">
-              <tal:showTitle condition="python: shownField == 'title'">
-                <metal:showObjectTitle use-macro="here/skyn/ref/macros/objectTitle"/>
+            <td tal:repeat="widget widgets">
+              <tal:showTitle condition="python: widget['name'] == 'title'">
+                <metal:showObjectTitle use-macro="portal/skyn/widgets/ref/macros/objectTitle"/>
               </tal:showTitle>
-              <tal:showOtherField define="appyType python: obj.getAppyType(shownField);
-                                          field python:obj.getField(shownField);
-                                          contextObj python:obj;"
-                                  condition="python: appyType and (shownField != 'title')">
-                <tal:showNormalField condition="python: appyType['type'] not in ('Ref', 'Computed', 'Action')">
-                  <metal:viewField use-macro="python: obj.widget(shownField, 'view', use_label=0)"/>
-                </tal:showNormalField>
-                <tal:showRef condition="python: appyType['type'] == 'Ref'">
-                  <tal:ref tal:define="isBack python:appyType['isBack'];
-                                       fieldName python: test(isBack, field.relationship, field.getName());
-                                       innerRef python:True">
-                    <metal:showField use-macro="here/skyn/ref/macros/showReference" />
-                  </tal:ref>
-                </tal:showRef>
-                <tal:showComputed condition="python: appyType['type'] == 'Computed'">
-                  <tal:computed content="python: obj.getComputedValue(appyType)"/>
-                </tal:showComputed>
-                <tal:showAction condition="python: appyType['type'] == 'Action'">
-                  <metal:action use-macro="here/skyn/macros/macros/showActionField" />
-                </tal:showAction>
+              <tal:showOtherField define="contextObj python:obj;
+                                          layoutType python: 'cell';
+                                          innerRef python:True"
+                                  condition="python: widget['name'] != 'title'">
+                <metal:showField use-macro="portal/skyn/widgets/show/macros/field" />
               </tal:showOtherField>&nbsp;
             </td>
             <tal:comment replace="nothing">Actions</tal:comment>
             <td align="right">
-              <metal:showObjectActions use-macro="here/skyn/ref/macros/objectActions" />
+              <metal:showObjectActions use-macro="portal/skyn/widgets/ref/macros/objectActions" />
             </td>
           </tr>
           </tal:row>
+          </tal:widgets>
         </table>
 
         </td></tr>
@@ -272,18 +239,17 @@
   </tal:anyNumberOfReferences>
 </div>
 
-<div metal:define-macro="editReference"
-     tal:define="refPortalType python:here.getAppyRefPortalType(field.getName());
-                 appyType python:here.getAppyType(field.getName());
+<tal:comment replace="nothing">Edit macro for an Ref.</tal:comment>
+<div define-macro="edit"
+     tal:condition="widget/link"
+     tal:define="refPortalType python: contextObj.getAppyRefPortalType(name);
                  allBrains python:here.uid_catalog(portal_type=refPortalType);
-                 brains python:here.callAppySelect(appyType['select'], allBrains);
-                 refUids python: [o.UID() for o in here.getAppyRefs(field.getName())['objects']];
-                 isMultiple python:test(appyType['multiplicity'][1]!=1, 'multiple', '');
-                 appyFieldName python: 'appy_ref_%s' % field.getName();
-                 inError python:test(errors.has_key(field.getName()), True, False);
-                 defaultValue python: contextObj.getDefault(field.getName());
-                 defaultValueUID defaultValue/UID|nothing;
-                 isBeingCreated python: contextObj.portal_factory.isTemporary(contextObj) or ('/portal_factory/' in contextObj.absolute_url())"
+                 brains python:contextObj.callAppySelect(widget['select'], allBrains);
+                 refUids python: [o.UID() for o in here.getAppyRefs(name)['objects']];
+                 isMultiple python:test(widget['multiplicity'][1]!=1, 'multiple', '');
+                 appyFieldName python: 'appy_ref_%s' % name;
+                 inError python:test(errors.has_key(name), True, False);
+                 isBeingCreated python: contextObj.isTemporary() or ('/portal_factory/' in contextObj.absolute_url())"
      tal:attributes="class python:'appyRefEdit field' + test(inError, ' error', '')">
 
   <tal:comment replace="nothing">This macro displays the Reference widget on an "edit" page</tal:comment>
@@ -301,3 +267,11 @@
                         selected python:test((valueIsInReq and (brain.UID in request.get(appyFieldName, []))) or (not valueIsInReq and ((brain.UID in refUids) or (isBeingCreated and (brain.UID==defaultValueUID)))), True, False)"/>
   </select>
 </div>
+
+<tal:comment replace="nothing">Cell macro for a Ref.</tal:comment>
+<metal:cell define-macro="cell">
+  <metal:call use-macro="portal/skyn/widgets/ref/macros/view"/>
+</metal:cell>
+
+<tal:comment replace="nothing">Search macro for a Ref.</tal:comment>
+<metal:search define-macro="search"></metal:search>

gen/plone25/skin/widgets/show.pt

@@ -0,0 +1,203 @@
+<tal:comment replace="nothing">
+  This macro shows the content of a layouted object, like a page or widget.
+  It requires:
+    contextObj         The Zope object on which we are working
+    layoutType         The kind of layout: "view"? "edit"? "cell"?
+    layout             The layout object that will dictate how object content
+                       will be rendered.
+  Options:
+    contextMacro       The base on folder containing the macros to call for
+                       rendering the elements within the layout.
+                       Defaults to portal.skyn
+</tal:comment>
+<metal:show define-macro="layout"
+            tal:define="contextMacro contextMacro| python: portal.skyn">
+ <table tal:attributes="cellpadding  layout/cellpadding;
+                        cellspacing  layout/cellspacing;
+                        width        layout/width;
+                        align        layout/align;
+                        class        layout/css_class;
+                        style        layout/style">
+   <tal:comment replace="nothing">The table header row</tal:comment>
+   <tr tal:condition="layout/headerRow" tal:attributes="valign layout/headerRow/valign">
+     <th tal:repeat="cell layout/headerRow/cells"
+         tal:attributes="align cell/align; width cell/width;">
+     </th>
+   </tr>
+   <tal:comment replace="nothing">The table content</tal:comment>
+   <tr tal:repeat="row layout/rows" tal:attributes="valign row/valign">
+     <td tal:repeat="cell row/cells"
+         tal:attributes="align cell/align; colspan cell/colspan;
+                         style python: test(repeat['cell'].end, '', 'padding-right: 0.4em')">
+       <tal:content repeat="elem cell/content">
+         <tal:field condition="python: elem == '?'">
+           <metal:call use-macro="python: contextMacro.get(widget['type'].lower()).macros.get(layoutType)"/>
+         </tal:field>
+         <tal:other condition="python: elem != '?'">
+           <metal:call use-macro="python: contextMacro.get(elem[0]).macros.get(elem[1])"/>
+         </tal:other>
+         <img tal:condition="not: repeat/elem/end" tal:attributes="src string: $portal_url/skyn/space.gif"/>
+       </tal:content>
+     </td>
+   </tr>
+ </table>
+</metal:show>
+
+<tal:comment replace="nothing">
+  This macro displays the widget corresponding to a given field. It requires:
+    contextObj         The Zope object for which this widget must be rendered
+    page               The page where the widget lies
+    layoutType         "edit"? "view"? "cell?"
+    widget             The widget to render
+</tal:comment>
+<metal:field define-macro="field"
+       tal:define="contextMacro    python: portal.skyn.widgets;
+                   layout          python: widget['layouts'][layoutType];
+                   name            widget/name;
+                   value           python: contextObj.getFormattedValue(name);
+                   requestValue    python: request.get(name, None);
+                   inRequest       python: request.has_key(name);
+                   errors          errors | python: ();
+                   inError         python: test(widget['name'] in errors, True, False)">
+  <metal:layout use-macro="here/skyn/widgets/show/macros/layout"/>
+</metal:field>
+
+<tal:comment replace="nothing">
+  This macro displays the widget corresponding to a group of widgets.
+  It requires:
+    contextObj         The Zope object for which this widget must be rendered
+    page               The page where the widget lies
+    layoutType         "edit"? "view"? "cell?"
+    widget             The widget to render
+</tal:comment>
+<metal:group define-macro="group">
+  <fieldset tal:condition="python: widget['style'] == 'fieldset'">
+    <legend tal:condition="widget/hasLabel">
+      <i tal:content="structure python: contextObj.translate(widget['labelId'])"></i>
+      <tal:help condition="widget/hasHelp">
+        <metal:call use-macro="portal/skyn/widgets/show/macros/help"/>
+      </tal:help>
+    </legend>
+    <div tal:condition="widget/hasDescr" class="discreet" 
+         tal:content="structure python: contextObj.translate(widget['descrId'])"></div>
+    <metal:content use-macro="portal/skyn/widgets/show/macros/groupContent"/>
+  </fieldset>
+  <tal:asSection condition="python: widget['style'] not in ('fieldset', 'tabs')">
+    <metal:content use-macro="portal/skyn/widgets/show/macros/groupContent"/>
+  </tal:asSection>
+  <tal:asTabs condition="python: widget['style'] == 'tabs'">
+  <table cellpadding="0" cellspacing="0" tal:attributes="width python: test(widget['wide'], '100%', '')">
+    <tal:comment replace="nothing">First row: the tabs.</tal:comment>
+    <tr><td style="border-bottom: 1px solid #ff8040">
+      <table cellpadding="0" cellspacing="0" style="position:relative; bottom:-1px;">
+        <tr valign="bottom">
+          <tal:tab repeat="widgetRow widget/widgets">
+          <tal:id define="tabId python:'tab_%s_%d_%d' % (widget['name'], repeat['widgetRow'].number(), len(widget['widgets']))">
+          <td><img tal:attributes="src string: $portal_url/skyn/tabLeft.png;
+                                   id python: '%s_left' % tabId"/><td>
+          <td tal:attributes="style python:'background-image: url(%s/skyn/tabBg.png)' % portal_url;
+                              id tabId">
+            <a style="cursor:pointer"
+               tal:content="python: tool.translate('%s_col%d' % (widget['labelId'], repeat['widgetRow'].number()))"
+               tal:attributes="onClick python: 'javascript:showTab(\'%s_%d_%d\')' % (widget['name'], repeat['widgetRow'].number(), len(widget['widgets']))"></a>
+          </td>
+          <td><img tal:attributes="src string: $portal_url/skyn/tabRight.png;
+                                   id python: '%s_right' % tabId"/><td>
+          </tal:id>
+          </tal:tab>
+        </tr>
+      </table>
+    </td></tr>
+    <tal:comment replace="nothing">Other rows: the widgets.</tal:comment>
+    <tr tal:repeat="widgetRow widget/widgets"
+        tal:attributes="id python: 'tabcontent_%s_%d_%d' % (widget['name'], repeat['widgetRow'].number(), len(widget['widgets']));
+                        style python: test(repeat['widgetRow'].number()==1, 'display:table-row', 'display:none')">
+      <td tal:define="widget python: widgetRow[0]">
+        <tal:group condition="python: widget['type'] == 'group'">
+          <metal:call use-macro="portal/skyn/widgets/show/macros/group"/>
+        </tal:group>
+        <tal:field condition="python: widget['type'] != 'group'">
+          <metal:call use-macro="portal/skyn/widgets/show/macros/field"/>
+        </tal:field>
+      </td>
+    </tr>
+  </table>
+  <script language="javascript"
+          tal:content="python: 'initTab(\'tab_%s\', \'%s_1_%d\')' % (widget['name'], widget['name'], len(widget['widgets']))"></script>
+  </tal:asTabs>
+</metal:group>
+
+<tal:comment replace="nothing">
+  This macro displays the content of a group of widgets.
+  It is exclusively called by macro "group" above.
+</tal:comment>
+<table metal:define-macro="groupContent" align="center"
+       tal:attributes="width python: test(widget['wide'], '100%', '')">
+  <tal:comment replace="nothing">Display the title of the group if it is not rendered a fieldset.</tal:comment>
+  <tr tal:condition="python: (widget['style'] != 'fieldset') and widget['hasLabel']">
+    <td tal:attributes="colspan python: len(widget['columnsWidths']);
+                        class widget/style">
+      <span tal:replace="structure python: contextObj.translate(widget['labelId'])"/>
+      <tal:help condition="widget/hasHelp">
+        <metal:call use-macro="portal/skyn/widgets/show/macros/help"/>
+      </tal:help>
+    </td>
+  </tr>
+  <tr tal:condition="python: (widget['style'] != 'fieldset') and widget['hasDescr']">
+    <td tal:attributes="colspan python: len(widget['columnsWidths'])" class="discreet"
+        tal:content="structure python: contextObj.translate(widget['descrId'])">
+    </td>
+  </tr>
+  <tr> <tal:comment replace="nothing">The column headers</tal:comment>
+    <th tal:repeat="colNb python:range(len(widget['columnsWidths']))"
+        tal:attributes="width python:widget['columnsWidths'][colNb];
+                        align python:widget['columnsAligns'][colNb]"
+        tal:content="structure python: test(widget['hasHeaders'], contextObj.translate('%s_col%d' % (widget['labelId'], colNb+1)), '')">
+    </th>
+  </tr>
+  <tal:comment replace="nothing">The rows of widgets</tal:comment>
+  <tr valign="top" tal:repeat="widgetRow widget/widgets">
+    <td tal:repeat="widget widgetRow"
+        tal:attributes="colspan widget/colspan|python:1;
+                        style python: test(repeat['widget'].number() != len(widgetRow), 'padding-right: 0.6em', '')">
+      <tal:showWidget condition="widget">
+        <tal:group condition="python: widget['type'] == 'group'">
+          <metal:call use-macro="portal/skyn/widgets/show/macros/group"/>
+        </tal:group>
+        <tal:field condition="python: widget['type'] != 'group'">
+          <metal:call use-macro="portal/skyn/widgets/show/macros/field"/>
+        </tal:field>
+      </tal:showWidget>
+    </td>
+  </tr>
+</table>
+
+<tal:comment replace="nothing">Displays a field label.</tal:comment>
+<tal:label metal:define-macro="label" condition="widget/hasLabel">
+  <label tal:attributes="for widget/name"
+         tal:condition="python: widget['type'] not in ('Action', 'Ref')"
+         tal:content="structure python: contextObj.translate(widget['labelId'])"></label>
+</tal:label>
+
+<tal:comment replace="nothing">Displays a field description.</tal:comment>
+<tal:description metal:define-macro="description" condition="widget/hasDescr">
+  <span class="discreet" tal:content="structure python: contextObj.translate(widget['descrId'])"></span>
+</tal:description>
+
+<tal:comment replace="nothing">Displays a field help.</tal:comment>
+<tal:help metal:define-macro="help">
+  <acronym tal:attributes="title python: contextObj.translate(widget['helpId'])">
+    <img tal:attributes="src string: $portal_url/skyn/help.png"/>
+  </acronym>
+</tal:help>
+
+<tal:comment replace="nothing">Displays validation-error-related info about a field.</tal:comment>
+<tal:validation metal:define-macro="validation">
+  <acronym tal:condition="inError" tal:attributes="title python: errors[name]">
+    <img tal:attributes="src string: $portal_url/skyn/warning.png"/>
+  </acronym>
+  <img tal:condition="not: inError" tal:attributes="src string: $portal_url/skyn/warning_no.png"/>
+</tal:validation>
+
+<tal:comment replace="nothing">Displays the fact that a field is required.</tal:comment>
+<tal:required metal:define-macro="required"><img tal:attributes="src string: $portal_url/skyn/required.png"/></tal:required>

gen/plone25/skin/widgets/string.pt

@@ -0,0 +1,102 @@
+<tal:comment replace="nothing">View macro for a String.</tal:comment>
+<metal:view define-macro="view"
+       tal:define="fmt widget/format;
+                   maxMult python: widget['multiplicity'][1];
+                   severalValues python: (maxMult == None) or (maxMult &gt; 1)">
+  <span tal:condition="python: fmt in (0, 3)"
+        tal:attributes="class widget/master_css;
+                        id python: contextObj.getFormattedValue(name, forMasterId=True)">
+    <ul class="appyList" tal:condition="python: value and severalValues">
+      <li class="appyBullet" tal:repeat="sv value"><i tal:content="structure sv"></i></li>
+    </ul>
+    <tal:singleValue condition="python: value and not severalValues">
+      <span tal:condition="python: fmt != 3" tal:replace="structure value"/>
+      <span tal:condition="python: fmt == 3">********</span>
+    </tal:singleValue>
+  </span>
+  <tal:formattedString condition="python: fmt not in (0, 3)">
+    <span tal:condition="python: value and (fmt == 1)"
+          tal:replace="structure python: value.replace('\n', '&lt;br&gt;')"/>
+    <span tal:condition="python: value and (fmt == 2)" tal:replace="structure value"/>
+  </tal:formattedString>
+</metal:view>
+
+<tal:comment replace="nothing">Edit macro for a String.</tal:comment>
+<metal:edit define-macro="edit"
+            tal:define="fmt widget/format;
+                        isSelect widget/isSelect;
+                        isMaster widget/slaves;
+                        isOneLine python: fmt in (0,3)">
+
+  <tal:choice condition="isSelect">
+  <select tal:define="possibleValues python:contextObj.getPossibleValues(name, withTranslations=True, withBlankValue=True)"
+          tal:attributes="name name;
+                          id name;
+                          multiple python: test(widget['multiplicity'][1] != 1, 'multiple', '');
+                          onchange python: test(isMaster, 'javascript:updateSlaves(getMasterValue(this), \'%s\')' % widget['id'], '');
+                          class    widget/master_css">
+    <option tal:repeat="possibleValue possibleValues"
+            tal:attributes="value python: possibleValue[0];
+                            selected python:contextObj.fieldValueSelected(name, possibleValue[0])"
+            tal:content="python:tool.truncateValue(possibleValue[1], widget)"></option>
+  </select>
+  </tal:choice>
+  <tal:line condition="python: isOneLine and not isSelect">
+    <input tal:attributes="id name; name name; size widget/width;
+                           value python: test(inRequest, requestValue, value)" type="text"/>
+  </tal:line>
+  <tal:textarea condition="python: fmt == 1">
+    <textarea tal:attributes="id name; name name;
+                              cols widget/width;
+                              rows widget/height;"
+              tal:content="python: test(inRequest, requestValue, value)">
+    </textarea>
+    <input type="hidden" value="text/plain" originalvalue="text/plain"
+           tal:attributes="name python: '%s_text_format' % name"/>
+  </tal:textarea>
+  <tal:rich condition="python: fmt == 2">
+    <tal:editor define="editor python: member.getProperty('wysiwyg_editor','').lower();
+                        macrosFile python: path('nocall:here/%s_wysiwyg_support' % editor);
+                        fieldName name;
+                        inputname name;
+                        inputvalue python: test(inRequest, requestValue, value);
+                        dummy python: request.set('%s_text_format' % name, 'text/html')">
+     <metal:box use-macro="macrosFile/macros/wysiwygEditorBox"/>
+    </tal:editor>
+  </tal:rich>
+</metal:edit>
+
+<tal:comment replace="nothing">Cell macro for a String.</tal:comment>
+<metal:cell define-macro="cell">
+  <metal:call use-macro="portal/skyn/widgets/string/macros/view"/>
+</metal:cell>
+
+<tal:comment replace="nothing">Search macro for a String.</tal:comment>
+<metal:search define-macro="search">
+  <label tal:attributes="for widgetName" tal:content="python: tool.translate(widget['labelId'])"></label><br>&nbsp;&nbsp;
+  <tal:comment replace="nothing">Show a simple search field for most String fields.</tal:comment>
+  <tal:simpleSearch condition="not: widget/isSelect">
+    <input type="text" tal:attributes="name python: '%s*string-%s' % (widgetName, widget['transform']);
+                                       style python: 'text-transform:%s' % widget['transform']"/>
+  </tal:simpleSearch>
+  <tal:comment replace="nothing">Show a multi-selection box for fields whose
+    validator defines a list of values, with a "AND/OR" checkbox.</tal:comment>
+  <tal:selectSearch condition="widget/isSelect">
+    <tal:comment replace="nothing">The "and" / "or" radio buttons</tal:comment>
+    <tal:operator define="operName python: 'o_%s'   % fieldName;
+                          orName   python: '%s_or'  % operName;
+                          andName  python: '%s_and' % operName;"
+                  condition="python: widget['multiplicity'][1]!=1">
+    <input type="radio" class="noborder" tal:attributes="name operName; id orName" checked="checked" value="or"/>
+    <label tal:attributes="for orName" tal:content="python: tool.translate('search_or')"></label>
+    <input type="radio" class="noborder" tal:attributes="name operName; id andName" value="and"/>
+    <label tal:attributes="for andName" tal:content="python: tool.translate('search_and')"></label><br/>
+    </tal:operator>
+    <tal:comment replace="nothing">The list of values</tal:comment>
+    <select tal:attributes="name widgetName" multiple="multiple" size="5">
+      <option tal:repeat="v python:tool.getPossibleValues(name, withTranslations=True, withBlankValue=False, className=contentType)"
+              tal:attributes="value python:v[0]" tal:content="python: v[1]">
+      </option>
+    </select>
+  </tal:selectSearch><br/>
+</metal:search>

gen/plone25/templates/ArchetypesTemplate.py

@@ -26,7 +26,6 @@ class <!genClassName!>(<!parents!>):
     suppl_views = ()
     typeDescription = '<!genClassName!>'
     typeDescMsgId = '<!genClassName!>_edit_descr'
-    _at_rename_after_creation = True
     i18nDomain = '<!applicationName!>'
     schema = fullSchema
     wrapperClass = <!genClassName!>_Wrapper

gen/plone25/templates/FlavourTemplate.py

@@ -6,11 +6,9 @@ import Products.<!applicationName!>.config
 from appy.gen.plone25.mixins.FlavourMixin import FlavourMixin
 from Extensions.appyWrappers import <!wrapperClass!>
 
-predefinedSchema = Schema((<!predefinedFields!>
-),)
 schema = Schema((<!fields!>
 ),)
-fullSchema = OrderedBaseFolderSchema.copy() + predefinedSchema.copy() + schema.copy()
+fullSchema = OrderedBaseFolderSchema.copy() + schema.copy()
 
 class <!flavourName!>(OrderedBaseFolder, FlavourMixin):
     '''Configuration flavour class for <!applicationName!>.'''
@@ -32,10 +30,8 @@ class <!flavourName!>(OrderedBaseFolder, FlavourMixin):
     schema = fullSchema
     allMetaTypes = <!metaTypes!>
     wrapperClass = <!wrapperClass!>
-    _at_rename_after_creation = True
     for elem in dir(FlavourMixin):
         if not elem.startswith('__'): security.declarePublic(elem)
 <!commonMethods!>
-<!predefinedMethods!>
 <!methods!>
 registerType(<!flavourName!>, '<!applicationName!>')

gen/plone25/templates/PodTemplate.py

@@ -27,7 +27,6 @@ class <!applicationName!>PodTemplate(BaseContent, PodTemplateMixin):
     suppl_views = ()
     typeDescription = "<!applicationName!>PodTemplate"
     typeDescMsgId = '<!applicationName!>_edit_descr'
-    _at_rename_after_creation = True
     wrapperClass = <!wrapperClass!>
     schema = fullSchema
     for elem in dir(PodTemplateMixin):

gen/plone25/templates/Portlet.pt

@@ -7,7 +7,7 @@
                      flavour python: tool.getFlavour(tool);"
          tal:condition="tool/showPortlet">
       <metal:block metal:use-macro="here/global_defines/macros/defines" />
-      <metal:prologue use-macro="here/skyn/macros/macros/pagePrologue"/>
+      <metal:prologue use-macro="here/skyn/page/macros/prologue"/>
       <dl tal:define="rootClasses tool/getRootClasses;
                       appName string:<!applicationName!>;
                       appFolder tool/getAppFolder;

gen/plone25/templates/Styles.css.dtml

@@ -4,23 +4,16 @@
 
 #portal-breadcrumbs { display: none; }
 #importedElem { color: grey; font-style: italic; }
-
-.appyList { line-height: 1.1em; margin: 0 0 0.5em 1.2em;  padding: 0; }
-.appyBullet { margin: 0; }
-.appyPod { float:right; }
-.appyNav { padding: 0.4em 0 0.4em 0; }
-.appyFocus { color: #900101; }
-.appyTabs { margin-bottom: 1em; }
-.appyTabs li a { border-bottom:1px solid transparent; font-size: 90%; }
-.appyTabs li a:visited { color: #578308; }
-.appyTitle { padding-top: 0.5em; font-size: 110%; }
-.appyLabel { font-weight: bold; padding-right: 0.4em; }
-.appyRefEdit { line-height: 1.5em; }
-
-.appyWorkflow {
-  text-align: center;
-  background-color: &dtml-globalBackgroundColor;;
-}
+label         { font-weight: bold;  font-style: italic; }
+.discreet     { font-size: 94%; }
+.appyList     { line-height: 1.1em; margin: 0 0 0.5em 1.2em;  padding: 0; }
+.appyBullet   { margin: 0; }
+.appyPod      { float:right; }
+.appyNav      { padding: 0.4em 0 0.4em 0; }
+.appyFocus    { color: #900101; }
+.appyTitle    { padding-top: 0.5em; font-size: 110%; }
+.appyRefEdit  { line-height: 1.5em; }
+.appyWorkflow { text-align: center; background-color: &dtml-globalBackgroundColor;;}
 
 .appyPlusImg {
   vertical-align: top;
@@ -30,10 +23,9 @@
 }
 
 .appyPhase {
-  border-style: solid;
+  border-style: dashed;
   border-width: thin;
-  text-align: center;
-  padding: 0 1em 0 1.3em;
+  padding: 0 0.1em 0 1em;
 }
 
 .appyState {
@@ -75,14 +67,14 @@
   background-color: #cde2a7;
   background-image: url(&dtml-portal_url;/skyn/done.png);
   background-repeat: no-repeat;
-  background-position: center left;
+  background-position: -1px 4px;
 }
 
 .stepCurrent {
-  background-color: #ffce7b;
+  background-color: #eef3f5;
   background-image: url(&dtml-portal_url;/skyn/current.png);
   background-repeat: no-repeat;
-  background-position: center left;
+  background-position: -1px 4px;
 }
 
 .stepFuture {
@@ -104,13 +96,7 @@
 }
 
 /* With fields layout in columns, standard error frame is too large */
-.error {
-  padding: 0.4em;
-}
-
-.odd {
-  background-color: white;
-}
+.odd {  background-color: white; }
 
 /* Table styles */
 .no-style-table {
@@ -125,18 +111,41 @@
   margin: 0 !important;
 }
 
-/* Minor layout changes in fieldsets and tables */
 fieldset {
-  margin: 0 0 0 0;
   line-height: 1em;
+  border: 2px solid #8CACBB;
+  margin: 0.5em 0em 0.5em 0em;
+  padding: 0 0.7em 0.5em;
 }
 
-.fieldset {
-  line-height: 1em;
+th {
+  font-style: italic;
+  font-weight: normal;
 }
-/* Group fieldsets */
-.appyGroup {
-  border-width: 2px;
+
+.section1 {
+  font-size: 120%;
+  margin: 0.45em 0em 0.1em 0;
+  padding: 0.3em 0em 0.2em 0.1em;
+  background-color: #eef3f5;
+  border-top: 1px solid #8CACBB;
+  border-bottom: 1px solid #8CACBB;
+}
+
+.section2 {
+  font-size: 110%;
+  font-style: italic;
+  margin: 0.45em 0em 0.1em 0;
+  border-bottom: 2px solid #8CACBB;
+}
+
+.section3 {
+  font-size: 100%;
+  font-style: italic;
+  margin: 0.45em 0em 0.1em 0;
+  background-color: #efeae8;
+  text-align: center;
+  color: grey;
 }
 
 .imageInput {
@@ -169,6 +178,7 @@ fieldset {
   padding-left: 0.3em;
   padding-top: 0.3em;
   padding-bottom: 0em;
+  border-top : 1px solid #8CACBB;
 }
 
 .vertical td {
@@ -212,9 +222,6 @@ fieldset {
   font-weight: normal;
   text-transform: none;
 }
-.portletSep {
-  border-top: 1px dashed #8cacbb;
-}
 .portletSearch {
   padding: 0 0 0 0.6em;
   font-style: normal;
@@ -225,13 +232,11 @@ fieldset {
   font-weight: bold;
   font-style: normal;
 }
-.portletGroupItem {
-  padding-left: 0.8em;
-  font-style: italic;
-}
-.portletCurrent {
-  font-weight: bold;
-}
+.portletSep       {  border-top: 1px dashed #8cacbb; }
+.portletGroupItem { padding-left: 0.8em; font-style: italic; }
+.portletPageItem  { font-style: italic; }
+.portletCurrent   { font-weight: bold; }
+
 div.appyGrey {
   display: none;
   position: absolute;

gen/plone25/templates/ToolTemplate.py

@@ -7,11 +7,9 @@ import Products.<!applicationName!>.config
 from appy.gen.plone25.mixins.ToolMixin import ToolMixin
 from Extensions.appyWrappers import AbstractWrapper, <!wrapperClass!>
 
-predefinedSchema = Schema((<!predefinedFields!>
-),)
 schema = Schema((<!fields!>
 ),)
-fullSchema = OrderedBaseFolderSchema.copy() + predefinedSchema.copy() + schema.copy()
+fullSchema = OrderedBaseFolderSchema.copy() + schema.copy()
 
 class <!toolName!>(UniqueObject, OrderedBaseFolder, ToolMixin):
     '''Tool for <!applicationName!>.'''
@@ -32,7 +30,6 @@ class <!toolName!>(UniqueObject, OrderedBaseFolder, ToolMixin):
     typeDescMsgId = '<!toolName!>_edit_descr'
     i18nDomain = '<!applicationName!>'
     wrapperClass = <!wrapperClass!>
-    _at_rename_after_creation = True
     schema = fullSchema
     schema["id"].widget.visible = False
     schema["title"].widget.visible = False
@@ -47,6 +44,5 @@ class <!toolName!>(UniqueObject, OrderedBaseFolder, ToolMixin):
         OrderedBaseFolder.__init__(self, '<!toolInstanceName!>')
         self.setTitle('<!applicationName!>')
 <!commonMethods!>
-<!predefinedMethods!>
 <!methods!>
 registerType(<!toolName!>, '<!applicationName!>')

gen/plone25/templates/__init__.py

@@ -45,8 +45,9 @@ def initialize(context):
 <!imports!>
     # I need to do those imports here; else, types and add permissions will not
     # be registered.
+    classes = [<!classes!>]
     ZopeInstaller(context, PROJECTNAME,
         <!applicationName!>Tool.<!applicationName!>Tool,
         DEFAULT_ADD_CONTENT_PERMISSION, ADD_CONTENT_PERMISSIONS,
-        logger, globals()).install()
+        logger, globals(), classes).install()
 # ------------------------------------------------------------------------------

gen/plone25/templates/appyWrappers.py

@@ -1,6 +1,6 @@
 # ------------------------------------------------------------------------------
 from appy.gen import *
-from appy.gen.plone25.wrappers import AbstractWrapper, FileWrapper
+from appy.gen.plone25.wrappers import AbstractWrapper
 from appy.gen.plone25.wrappers.ToolWrapper import ToolWrapper
 from appy.gen.plone25.wrappers.FlavourWrapper import FlavourWrapper
 from appy.gen.plone25.wrappers.PodTemplateWrapper import PodTemplateWrapper

gen/plone25/templates/config.py

@@ -1,11 +1,8 @@
 <!codeHeader!>
-import os, os.path, sys
-try: # New CMF
-    from Products.CMFCore.permissions import setDefaultRoles
-except ImportError: # Old CMF
-    from Products.CMFCore.CMFCorePermissions import setDefaultRoles
-
-import Extensions.appyWrappers
+import os, os.path, sys, copy
+import appy.gen
+from Products.CMFCore.permissions import setDefaultRoles
+import Extensions.appyWrappers as wraps
 <!imports!>
     
 # The following imports are here for allowing mixin classes to access those
@@ -17,7 +14,6 @@ from OFS.Image import File
 from DateTime import DateTime
 from Products.CMFCore.utils import getToolByName
 from Products.CMFPlone.PloneBatch import Batch
-from Products.Archetypes.utils import DisplayList
 import logging
 logger = logging.getLogger('<!applicationName!>')
 
@@ -32,9 +28,7 @@ setDefaultRoles(DEFAULT_ADD_CONTENT_PERMISSION, tuple(defaultAddRoles))
 product_globals = globals()
 applicationRoles = [<!roles!>]
 rootClasses = [<!rootClasses!>]
-referers = {
-<!referers!>
-}
+
 # In the following dict, we keep one instance for every Appy workflow defined
 # in the application. Those prototypical instances will be used for executing
 # user-defined actions and transitions. For each instance, we add a special
@@ -44,6 +38,9 @@ workflowInstances = {}
 <!workflowInstancesInit!>
 
 # In the following dict, we store, for every Appy class, the ordered list of
-# attributes (included inherited attributes).
+# appy types (included inherited ones).
 attributes = {<!attributes!>}
+# In the followinf dict, we store, for every Appy class, a dict of appy types
+# keyed by their names.
+attributesDict = {<!attributesDict!>}
 # ------------------------------------------------------------------------------

gen/plone25/templates/global_statusmessage.pt

@@ -1,20 +1,5 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en" i18n:domain="plone">
 <body>
-<tal:message i18n:domain="plone" metal:define-macro="portal_message">
-    <tal:comment replace="nothing">Single message from portal_status_message request key</tal:comment>
-    <div tal:define="msg request/portal_status_message | nothing"
-         tal:condition="msg" class="portalMessage" tal:content="msg" i18n:translate=""></div>
-
-    <tal:comment replace="nothing">Messages added via plone_utils</tal:comment>
-    <tal:messages define="messages putils/showPortalMessages" condition="messages">
-      <tal:msgs define="type_css_map python: {'info':'portalMessage', 'warn':'portalWarningMessage',
-                                              'stop':'portalStopMessage'};"
-                repeat="msg messages">
-        <div tal:define="mtype msg/type | nothing;"
-             tal:attributes="class python:mtype and type_css_map[mtype] or 'info';"
-             tal:content="structure msg/message | nothing" i18n:translate=""></div>
-      </tal:msgs>
-    </tal:messages>
-</tal:message>
+  <tal:message metal:define-macro="portal_message"></tal:message>
 </body>
 </html>

gen/plone25/utils.py

@@ -33,11 +33,4 @@ def updateRolesForPermission(permission, roles, obj):
             existingRoles = perm.getRoles()
     allRoles = set(existingRoles).union(roles)
     obj.manage_permission(permission, tuple(allRoles), acquire=0)
-
-# ------------------------------------------------------------------------------
-from appy.gen.utils import AppyRequest
-def getAppyRequest(zopeRequest, obj=None):
-    '''This method creates a nice (Appy) object representation of a
-       dictionary-like Zope REQUEST object.'''
-    return AppyRequest(zopeRequest, obj)
 # ------------------------------------------------------------------------------

gen/plone25/wrappers/FlavourWrapper.py

@@ -1,6 +1,8 @@
 # ------------------------------------------------------------------------------
-class FlavourWrapper:
+from appy.gen.plone25.wrappers import AbstractWrapper
 
+# ------------------------------------------------------------------------------
+class FlavourWrapper(AbstractWrapper):
     def onEdit(self, created):
         if created:
             nbOfFlavours = len(self.tool.flavours)
@@ -8,8 +10,7 @@ class FlavourWrapper:
                 self.number = nbOfFlavours
                 self.o.registerPortalTypes()
         # Call the custom flavour "onEdit" method if it exists
-        customFlavour = self.__class__.__bases__[1]
-        if customFlavour.__name__ != 'Flavour':
+        if len(self.__class__.__bases__) > 1:
             # There is a custom flavour
             if customFlavour.__dict__.has_key('onEdit'):
                 customFlavour.__dict__['onEdit'](self, created)

gen/plone25/wrappers/PodTemplateWrapper.py

@@ -1,3 +1,6 @@
 # ------------------------------------------------------------------------------
-class PodTemplateWrapper: pass
+from appy.gen.plone25.wrappers import AbstractWrapper
+
+# ------------------------------------------------------------------------------
+class PodTemplateWrapper(AbstractWrapper): pass
 # ------------------------------------------------------------------------------

gen/plone25/wrappers/ToolWrapper.py

@@ -1,5 +1,32 @@
 # ------------------------------------------------------------------------------
-class ToolWrapper:
+from appy.gen.plone25.wrappers import AbstractWrapper
+
+# ------------------------------------------------------------------------------
+_PY = 'Please specify a file corresponding to a Python interpreter ' \
+      '(ie "/usr/bin/python").'
+FILE_NOT_FOUND = 'Path "%s" was not found.'
+VALUE_NOT_FILE = 'Path "%s" is not a file. ' + _PY
+NO_PYTHON = "Name '%s' does not starts with 'python'. " + _PY
+NOT_UNO_ENABLED_PYTHON = '"%s" is not a UNO-enabled Python interpreter. ' \
+                         'To check if a Python interpreter is UNO-enabled, ' \
+                         'launch it and type "import uno". If you have no ' \
+                         'ImportError exception it is ok.'
+
+# ------------------------------------------------------------------------------
+class ToolWrapper(AbstractWrapper):
+    def validPythonWithUno(self, value):
+        '''This method represents the validator for field unoEnabledPython.'''
+        if value:
+            if not os.path.exists(value):
+                return FILE_NOT_FOUND % value
+            if not os.path.isfile(value):
+                return VALUE_NOT_FILE % value
+            if not os.path.basename(value).startswith('python'):
+                return NO_PYTHON % value
+            if os.system('%s -c "import uno"' % value):
+                return NOT_UNO_ENABLED_PYTHON % value
+        return None
+
     def getInitiator(self):
         '''Retrieves the object that triggered the creation of the object
            being currently created (if any).'''

gen/plone25/wrappers/__init__.py

@@ -5,7 +5,7 @@
 import os, os.path, time, mimetypes, random
 import appy.pod
 from appy.gen import Search
-from appy.gen.utils import sequenceTypes
+from appy.gen.utils import sequenceTypes, FileWrapper
 from appy.shared.utils import getOsTempFolder, executeCommand, normalizeString
 from appy.shared.xml_parser import XmlMarshaller
 
@@ -32,9 +32,9 @@ class AbstractWrapper:
               v MIME type of the file.'''
         ploneFileClass = self.o.getProductConfig().File
         if isinstance(v, ploneFileClass):
-            exec "self.o.set%s%s(v)" % (name[0].upper(), name[1:])
+            setattr(self.o, name, v)
         elif isinstance(v, FileWrapper):
-            setattr(self, name, v._atFile)
+            setattr(self.o, name, v._atFile)
         elif isinstance(v, basestring):
             f = file(v)
             fileName = os.path.basename(v)
@@ -42,7 +42,7 @@ class AbstractWrapper:
             ploneFile = ploneFileClass(fileId, fileName, f)
             ploneFile.filename = fileName
             ploneFile.content_type = mimetypes.guess_type(fileName)[0]
-            setattr(self, name, ploneFile)
+            setattr(self.o, name, ploneFile)
             f.close()
         elif type(v) in sequenceTypes:
             # It should be a 2-tuple or 3-tuple
@@ -61,15 +61,20 @@ class AbstractWrapper:
                 if not mimeType:
                     mimeType = mimetypes.guess_type(fileName)[0]
                 ploneFile.content_type = mimeType
-                setattr(self, name, ploneFile)
+                setattr(self.o, name, ploneFile)
     def __setattr__(self, name, v):
+        if name == 'title':
+            self.o.setTitle(v)
+            return
         appyType = self.o.getAppyType(name)
-        if not appyType and (name != 'title'):
+        if not appyType:
             raise 'Attribute "%s" does not exist.' % name
-        if appyType and (appyType['type'] == 'File'):
+        if appyType.type == 'File':
             self._set_file_attribute(name, v)
+        elif appyType.type == 'Ref':
+            raise "Use methods 'link' or 'create' to modify references."
         else:
-            exec "self.o.set%s%s(v)" % (name[0].upper(), name[1:])
+            setattr(self.o, name, v)
     def __repr__(self):
         return '<%s wrapper at %s>' % (self.klass.__name__, id(self))
     def __cmp__(self, other):
@@ -94,17 +99,18 @@ class AbstractWrapper:
         appName = self.o.getProductConfig().PROJECTNAME
         return self.o.utranslate(self.o.getWorkflowLabel(), domain=appName)
     stateLabel = property(get_stateLabel)
-    def get_klass(self): return self.__class__.__bases__[1]
+    def get_klass(self): return self.__class__.__bases__[-1]
     klass = property(get_klass)
-    def get_url(self): return self.o.absolute_url()+'/skyn/view'
+    def get_url(self): return self.o.absolute_url()
     url = property(get_url)
     def get_history(self):
         key = self.o.workflow_history.keys()[0]
         return self.o.workflow_history[key]
     history = property(get_history)
-    def get_user(self):
-        return self.o.portal_membership.getAuthenticatedMember()
+    def get_user(self): return self.o.portal_membership.getAuthenticatedMember()
     user = property(get_user)
+    def get_fields(self): return self.o.getAllAppyTypes()
+    fields = property(get_fields)
 
     def link(self, fieldName, obj):
         '''This method links p_obj to this one through reference field
@@ -178,7 +184,6 @@ class AbstractWrapper:
         appyObj = ploneObj.appy()
         # Set object attributes
         for attrName, attrValue in kwargs.iteritems():
-            setterName = 'set%s%s' % (attrName[0].upper(), attrName[1:])
             if isinstance(attrValue, AbstractWrapper):
                 try:
                     refAppyType = getattr(appyObj.__class__.__bases__[-1],
@@ -187,7 +192,7 @@ class AbstractWrapper:
                 except AttributeError, ae:
                     pass
             else:
-                getattr(ploneObj, setterName)(attrValue)
+                setattr(appyObj, attrName, attrValue)
         if isField:
             # Link the object to this one
             self.link(fieldName, ploneObj)
@@ -375,85 +380,4 @@ class AbstractWrapper:
            p_data must be a dictionary whose keys are field names (strings) and
            whose values are the previous field values.'''
         self.o.addDataChange(data, labels=False)
-
-# ------------------------------------------------------------------------------
-CONVERSION_ERROR = 'An error occurred while executing command "%s". %s'
-class FileWrapper:
-    '''When you get, from an appy object, the value of a File attribute, you
-       get an instance of this class.'''
-    def __init__(self, atFile):
-        '''This constructor is only used by Appy to create a nice File instance
-           from a Plone/Zope corresponding instance (p_atFile). If you need to
-           create a new file and assign it to a File attribute, use the
-           attribute setter, do not create yourself an instance of this
-           class.'''
-        d = self.__dict__
-        d['_atFile'] = atFile # Not for you!
-        d['name'] = atFile.filename
-        d['content'] = atFile.data
-        d['mimeType'] = atFile.content_type
-        d['size'] = atFile.size # In bytes
-
-    def __setattr__(self, name, v):
-        d = self.__dict__
-        if name == 'name':
-            self._atFile.filename = v
-            d['name'] = v
-        elif name == 'content':
-            self._atFile.update_data(v, self.mimeType, len(v))
-            d['content'] = v
-            d['size'] = len(v)
-        elif name == 'mimeType':
-            self._atFile.content_type = self.mimeType = v
-        else:
-            raise 'Impossible to set attribute %s. "Settable" attributes ' \
-                  'are "name", "content" and "mimeType".' % name
-
-    def dump(self, filePath=None, format=None, tool=None):
-        '''Writes the file on disk. If p_filePath is specified, it is the
-           path name where the file will be dumped; folders mentioned in it
-           must exist. If not, the file will be dumped in the OS temp folder.
-           The absolute path name of the dumped file is returned.
-           If an error occurs, the method returns None. If p_format is
-           specified, OpenOffice will be called for converting the dumped file
-           to the desired format. In this case, p_tool, a Appy tool, must be
-           provided. Indeed, any Appy tool contains parameters for contacting
-           OpenOffice in server mode.'''
-        if not filePath:
-            filePath = '%s/file%f.%s' % (getOsTempFolder(), time.time(),
-                normalizeString(self.name))
-        f = file(filePath, 'w')
-        if self.content.__class__.__name__ == 'Pdata':
-            # The file content is splitted in several chunks.
-            f.write(self.content.data)
-            nextPart = self.content.next
-            while nextPart:
-                f.write(nextPart.data)
-                nextPart = nextPart.next
-        else:
-            # Only one chunk
-            f.write(self.content)
-        f.close()
-        if format:
-            if not tool: return
-            # Convert the dumped file using OpenOffice
-            convScript = '%s/converter.py' % os.path.dirname(appy.pod.__file__)
-            cmd = '%s %s "%s" %s -p%d' % (tool.unoEnabledPython, convScript,
-                filePath, format, tool.openOfficePort)
-            errorMessage = executeCommand(cmd)
-            # Even if we have an "error" message, it could be a simple warning.
-            # So we will continue here and, as a subsequent check for knowing if
-            # an error occurred or not, we will test the existence of the
-            # converted file (see below).
-            os.remove(filePath)
-            # Return the name of the converted file.
-            baseName, ext = os.path.splitext(filePath)
-            if (ext == '.%s' % format):
-                filePath = '%s.res.%s' % (baseName, format)
-            else:
-                filePath = '%s.%s' % (baseName, format)
-            if not os.path.exists(filePath):
-                tool.log(CONVERSION_ERROR % (cmd, errorMessage), type='error')
-                return
-        return filePath
 # ------------------------------------------------------------------------------

gen/plone3/installer.py

@@ -4,35 +4,7 @@
 # ------------------------------------------------------------------------------
 from appy.gen.plone25.installer import PloneInstaller as Plone25Installer
 
-class ZCTextIndexInfo:
-    '''Silly class used for storing information about a ZCTextIndex.'''
-    lexicon_id = "plone_lexicon"
-    index_type = 'Okapi BM25 Rank'
-
 class PloneInstaller(Plone25Installer):
     '''This Plone installer runs every time the generated Plone product is
-       installed or uninstalled (in the Plone configuration interface).'''
-    @staticmethod
-    def updateIndexes(ploneSite, indexInfo, logger):
-        '''This method creates or updates, in a p_ploneSite, definitions of
-           indexes in its portal_catalog, based on index-related information
-           given in p_indexInfo. p_indexInfo is a dictionary of the form
-           {s_indexName:s_indexType}. Here are some examples of index types:
-           "FieldIndex", "ZCTextIndex", "DateIndex".'''
-        catalog = ploneSite.portal_catalog
-        indexNames = catalog.indexes()
-        for indexName, indexType in indexInfo.iteritems():
-            if indexName not in indexNames:
-                # We need to create this index
-                if indexType != 'ZCTextIndex':
-                    catalog.addIndex(indexName, indexType)
-                else:
-                    catalog.addIndex(indexName,indexType,extra=ZCTextIndexInfo)
-                logger.info('Creating index "%s" of type "%s"...' % \
-                            (indexName, indexType))
-                # Indexing database content based on this index.
-                catalog.reindexIndex(indexName, ploneSite.REQUEST)
-                logger.info('Done.')
-        # TODO: if the index already exists but has not the same type, we
-        # re-create it with the same type and we reindex it.
+       installed or uninstalled (in the Plone configuration panel).'''
 # ------------------------------------------------------------------------------

gen/po.py

@@ -69,6 +69,7 @@ class PoMessage:
     SEARCH_AND = 'and'
     WORKFLOW_COMMENT = 'Optional comment'
     WORKFLOW_STATE = 'state'
+    APPY_TITLE = 'Title'
     DATA_CHANGE = 'Data change'
     MODIFIED_FIELD = 'Modified field'
     PREVIOUS_VALUE = 'Previous value'
@@ -78,12 +79,13 @@ class PoMessage:
     CHOOSE_A_DOC = '[ Documents ]'
     MIN_REF_VIOLATED = 'You must choose more elements here.'
     MAX_REF_VIOLATED = 'Too much elements are selected here.'
-    BAD_INT = 'An integer value is expected; do not enter any space.'
+    BAD_LONG = 'An integer value is expected; do not enter any space.'
     BAD_FLOAT = 'A floating-point number is expected; use the dot as decimal ' \
                 'separator, not a comma; do not enter any space.'
     BAD_EMAIL = 'Please enter a valid email.'
     BAD_URL = 'Please enter a valid URL.'
     BAD_ALPHANUMERIC = 'Please enter a valid alphanumeric value.'
+    BAD_SELECT_VALUE = 'The value is not among possible values for this field.'
     ACTION_OK = 'The action has been successfully executed.'
     ACTION_KO = 'A problem occurred while executing the action.'
     FRONT_PAGE_TEXT = 'Welcome to this Appy-powered Plone site.'
@@ -103,11 +105,16 @@ class PoMessage:
     CONFIRM = 'Are you sure ?'
     YES = 'Yes'
     NO = 'No'
+    FIELD_REQUIRED = 'Please fill this field.'
+    FILE_REQUIRED = 'Please select a file.'
+    IMAGE_REQUIRED = 'The uploaded file must be an image.'
 
-    def __init__(self, id, msg, default, fuzzy=False, comments=[]):
+    def __init__(self, id, msg, default, fuzzy=False, comments=[],
+                 niceDefault=False):
         self.id = id
         self.msg = msg
         self.default = default
+        if niceDefault: self.produceNiceDefault()
         self.fuzzy = fuzzy # True if the default value has changed in the pot
         # file: the msg in the po file needs to be translated again.
         self.comments = comments

gen/utils.py

@@ -1,6 +1,6 @@
 # ------------------------------------------------------------------------------
-import re
-
+import re, os, os.path, time
+from appy.shared.utils import getOsTempFolder, normalizeString
 sequenceTypes = (list, tuple)
 
 # Classes used by edit/view templates for accessing information ----------------
@@ -8,111 +8,100 @@ class Descr:
     '''Abstract class for description classes.'''
     def get(self): return self.__dict__
 
-class FieldDescr(Descr):
-    def __init__(self, atField, appyType, fieldRel):
-        # The corresponding Archetypes field (may be None in the case of
-        # backward references)
-        self.atField = atField
-        # The corresponding Appy type
-        self.appyType = appyType
-        # The field relationship, needed when the field description is a
-        # backward reference.
-        self.fieldRel = fieldRel
-        # Can we sort this field ?
-        at = self.appyType
-        self.sortable = False
-        if not fieldRel and ((self.atField.getName() == 'title') or \
-                             (at['indexed'])):
-            self.sortable = True
-        # Can we filter this field?
-        self.filterable = False
-        if not fieldRel and at['indexed'] and (at['type'] == 'String') and \
-           (at['format'] == 0) and not at['isSelect']:
-            self.filterable = True
-        if fieldRel:
-            self.widgetType = 'backField'
-            self.group = appyType['backd']['group']
-            self.show = appyType['backd']['show']
-            self.page = appyType['backd']['page']
-        else:
-            self.widgetType = 'field'
-            self.group = appyType['group']
-            self.show = appyType['show']
-            self.page = appyType['page']
-            fieldName = self.atField.getName()
-
 class GroupDescr(Descr):
-    def __init__(self, name, cols, page):
-        self.name = name
-        self.cols = cols # The nb of columns for placing fields into the group
-        self.rows = None # The number of rows
+    def __init__(self, group, page, metaType):
+        '''Creates the data structure manipulated in ZPTs from p_group, the
+           Group instance used in the field definition.'''
+        self.type = 'group'
+        # All p_group attributes become self attributes.
+        for name, value in group.__dict__.iteritems():
+            if not name.startswith('_'):
+                setattr(self, name, value)
+        self.columnsWidths = [col.width for col in group.columns]
+        self.columnsAligns = [col.align for col in group.columns]
+        # Names of i18n labels
+        self.labelId = '%s_group_%s' % (metaType, self.name)
+        self.descrId = self.labelId + '_descr'
+        self.helpId  = self.labelId + '_help'
+        # The name of the page where the group lies
         self.page = page
-        self.fields = []
-        self.widgetType = 'group'
+        # The widgets belonging to the group that the current user may see.
+        # They will be stored by m_addWidget below as a list of lists because
+        # they will be rendered as a table.
+        self.widgets = [[]]
 
-    def computeRows(groupDict):
-        '''Computes self.rows. But because at this time the object has already
-           been converted to a dict (for being maniputated within ZPTs, this
-           method is a static method that takes the dict as arg.'''
-        groupDict['rows'] = len(groupDict['fields']) / groupDict['cols']
-        if len(groupDict['fields']) % groupDict['cols']:
-            groupDict['rows'] += 1
-    computeRows = staticmethod(computeRows)
+    @staticmethod
+    def addWidget(groupDict, newWidget):
+        '''Adds p_newWidget into p_groupDict['widgets']. We try first to add
+           p_newWidget into the last widget row. If it is not possible, we
+           create a new row.
 
-    def getGroupInfo(groupName):
-        '''In the group name, the user may optionally specify at the end the
-           number of columns for placing fields into the group. This method
-           returns the real group name and the number of columns.'''
-        res = groupName.rsplit('_', 1)
-        if len(res) == 1:
-            res.append(1) # Append the default numer of columns
+           This method is a static method taking p_groupDict as first param
+           instead of being an instance method because at this time the object
+           has already been converted to a dict (for being maniputated within
+           ZPTs).'''
+        # Get the last row
+        widgetRow = groupDict['widgets'][-1]
+        numberOfColumns = len(groupDict['columnsWidths'])
+        # Computes the number of columns already filled by widgetRow
+        rowColumns = 0
+        for widget in widgetRow: rowColumns += widget['colspan']
+        freeColumns = numberOfColumns - rowColumns
+        if freeColumns >= newWidget['colspan']:
+            # We can add the widget in the last row.
+            widgetRow.append(newWidget)
         else:
-            try:
-                res[1] = int(res[1])
-            except ValueError:
-                res[1] = 1
-        return res
-    getGroupInfo = staticmethod(getGroupInfo)
+            if freeColumns:
+                # Terminate the current row by appending empty cells
+                for i in range(freeColumns): widgetRow.append('')
+            # Create a new row
+            newRow = [newWidget]
+            groupDict['widgets'].append(newRow)
 
 class PageDescr(Descr):
-    def getPageInfo(pageOrName, pageKlass):
+    @staticmethod
+    def getPageInfo(pageOrName):
         '''pageOrName can be:
            - a string containing the name of the page
            - a string containing <pageName>_<phaseName>
            - a appy.gen.Page instance for a more detailed page description.
            This method returns a normalized tuple containing page-related
            information.'''
-        if isinstance(pageOrName, pageKlass):
-            res = [pageOrName.name, pageOrName.phase, pageOrName.show]
-        else:
+        if isinstance(pageOrName, basestring):
             res = pageOrName.rsplit('_', 1)
             if len(res) == 1:
                 res.append('main')
             res.append(True)
+        else:
+            res = [pageOrName.name, pageOrName.phase, pageOrName.show]
         return res
-    getPageInfo = staticmethod(getPageInfo)
 
 class PhaseDescr(Descr):
-    def __init__(self, name, states, forPlone, ploneObj):
+    def __init__(self, name, states, obj):
         self.name = name
         self.states = states
-        self.forPlone = forPlone
-        self.ploneObj = ploneObj
+        self.obj = obj
         self.phaseStatus = None
         self.pages = [] # The list of pages in this phase
         self.totalNbOfPhases = None
+        # The following attributes allows to browse, from a given page, to the
+        # last page of the previous phase and to the first page of the following
+        # phase if allowed by phase state.
+        self.previousPhase = None
+        self.nextPhase = None
+
     def addPage(self, appyType, obj):
-        toAdd = appyType['page']
-        if (toAdd == 'main') and self.forPlone:
-            toAdd = 'default'
+        toAdd = appyType.page
         if (toAdd not in self.pages) and \
-           obj._appy_showPage(appyType['page'], appyType['pageShow']):
+           obj._appy_showPage(appyType.page, appyType.pageShow):
             self.pages.append(toAdd)
-    def computeStatus(self):
+
+    def computeStatus(self, allPhases):
         '''Compute status of whole phase based on individual status of states
            in this phase. If this phase includes no state, the concept of phase
            is simply used as a tab, and its status depends on the page currently
-           shown.'''
+           shown. This method also fills fields "previousPhase" and "nextPhase"
+           if relevant, based on list of p_allPhases.'''
         res = 'Current'
         if self.states:
             # Compute status base on states
@@ -124,17 +113,19 @@ class PhaseDescr(Descr):
                         break
         else:
             # Compute status based on current page
-            rq = self.ploneObj.REQUEST
-            if rq.has_key('fieldset'):
-                pageName = rq['fieldset']
-                if not self.forPlone and (pageName == 'default'):
-                    pageName = 'main'
-            else:
-                pageName = rq.get('pageName', 'main')
-            if pageName in self.pages:
+            page = self.obj.REQUEST.get('page', 'main')
+            if page in self.pages:
                 res = 'Current'
             else:
                 res = 'Deselected'
+            # Identify previous and next phases
+            for phaseInfo in allPhases:
+                if phaseInfo['name'] == self.name:
+                    i = allPhases.index(phaseInfo)
+                    if i > 0:
+                        self.previousPhase = allPhases[i-1]
+                    if i < (len(allPhases)-1):
+                        self.nextPhase = allPhases[i+1]
         self.phaseStatus = res
 
 class StateDescr(Descr):
@@ -159,32 +150,7 @@ def produceNiceMessage(msg):
     return res
 
 # ------------------------------------------------------------------------------
-class ValidationErrors: pass
-class AppyRequest:
-    def __init__(self, zopeRequest, appyObj=None):
-        self.zopeRequest = zopeRequest
-        self.appyObj = appyObj
-    def __str__(self): return '<AppyRequest object>'
-    def __repr__(self): return '<AppyRequest object>'
-    def __getattr__(self, attr):
-        res = None
-        if self.appyObj:
-            # I can retrieve type information from the ploneObj.
-            appyType = self.appyObj.o.getAppyType(attr)
-            if appyType['type'] == 'Ref':
-                res = self.zopeRequest.get('appy_ref_%s' % attr, None)
-            else:
-                res = self.zopeRequest.get(attr, None)
-                if appyType['pythonType']:
-                    try:
-                        exec 'res = %s' % res # bool('False') gives True, so we
-                        # can't write: res = appyType['pythonType'](res)
-                    except SyntaxError, se:
-                        # Can happen when for example, an Integer value is empty
-                        res = None
-        else:
-            res = self.zopeRequest.get(attr, None)
-        return res
+class AppyObject: pass
 
 # ------------------------------------------------------------------------------
 class SomeObjects:
@@ -261,4 +227,85 @@ class FakeBrain:
     def pretty_title_or_id(self): return self.Title
     def getObject(self, REQUEST=None): return self
     def getRID(self): return self.url
+
+# ------------------------------------------------------------------------------
+CONVERSION_ERROR = 'An error occurred while executing command "%s". %s'
+class FileWrapper:
+    '''When you get, from an appy object, the value of a File attribute, you
+       get an instance of this class.'''
+    def __init__(self, atFile):
+        '''This constructor is only used by Appy to create a nice File instance
+           from a Plone/Zope corresponding instance (p_atFile). If you need to
+           create a new file and assign it to a File attribute, use the
+           attribute setter, do not create yourself an instance of this
+           class.'''
+        d = self.__dict__
+        d['_atFile'] = atFile # Not for you!
+        d['name'] = atFile.filename
+        d['content'] = atFile.data
+        d['mimeType'] = atFile.content_type
+        d['size'] = atFile.size # In bytes
+
+    def __setattr__(self, name, v):
+        d = self.__dict__
+        if name == 'name':
+            self._atFile.filename = v
+            d['name'] = v
+        elif name == 'content':
+            self._atFile.update_data(v, self.mimeType, len(v))
+            d['content'] = v
+            d['size'] = len(v)
+        elif name == 'mimeType':
+            self._atFile.content_type = self.mimeType = v
+        else:
+            raise 'Impossible to set attribute %s. "Settable" attributes ' \
+                  'are "name", "content" and "mimeType".' % name
+
+    def dump(self, filePath=None, format=None, tool=None):
+        '''Writes the file on disk. If p_filePath is specified, it is the
+           path name where the file will be dumped; folders mentioned in it
+           must exist. If not, the file will be dumped in the OS temp folder.
+           The absolute path name of the dumped file is returned.
+           If an error occurs, the method returns None. If p_format is
+           specified, OpenOffice will be called for converting the dumped file
+           to the desired format. In this case, p_tool, a Appy tool, must be
+           provided. Indeed, any Appy tool contains parameters for contacting
+           OpenOffice in server mode.'''
+        if not filePath:
+            filePath = '%s/file%f.%s' % (getOsTempFolder(), time.time(),
+                normalizeString(self.name))
+        f = file(filePath, 'w')
+        if self.content.__class__.__name__ == 'Pdata':
+            # The file content is splitted in several chunks.
+            f.write(self.content.data)
+            nextPart = self.content.next
+            while nextPart:
+                f.write(nextPart.data)
+                nextPart = nextPart.next
+        else:
+            # Only one chunk
+            f.write(self.content)
+        f.close()
+        if format:
+            if not tool: return
+            # Convert the dumped file using OpenOffice
+            convScript = '%s/converter.py' % os.path.dirname(appy.pod.__file__)
+            cmd = '%s %s "%s" %s -p%d' % (tool.unoEnabledPython, convScript,
+                filePath, format, tool.openOfficePort)
+            errorMessage = executeCommand(cmd)
+            # Even if we have an "error" message, it could be a simple warning.
+            # So we will continue here and, as a subsequent check for knowing if
+            # an error occurred or not, we will test the existence of the
+            # converted file (see below).
+            os.remove(filePath)
+            # Return the name of the converted file.
+            baseName, ext = os.path.splitext(filePath)
+            if (ext == '.%s' % format):
+                filePath = '%s.res.%s' % (baseName, format)
+            else:
+                filePath = '%s.%s' % (baseName, format)
+            if not os.path.exists(filePath):
+                tool.log(CONVERSION_ERROR % (cmd, errorMessage), type='error')
+                return
+        return filePath
 # ------------------------------------------------------------------------------

pod/buffers.py

@@ -23,6 +23,7 @@ from appy.pod import PodError, XML_SPECIAL_CHARS
 from appy.pod.elements import *
 from appy.pod.actions import IfAction, ElseAction, ForAction, VariableAction, \
                              NullAction
+from appy.shared import xmlPrologue
 
 # ------------------------------------------------------------------------------
 class ParsingError(Exception): pass
@@ -158,7 +159,7 @@ class FileBuffer(Buffer):
         Buffer.__init__(self, env, None)
         self.result = result
         self.content = file(result, 'w')
-        self.content.write('<?xml version="1.0" encoding="UTF-8"?>')
+        self.content.write(xmlPrologue)
     def getLength(self): return 0
     # getLength is used to manage insertions into sub-buffers. But in the case
     # of a FileBuffer, we will only have 1 sub-buffer at a time, and we don't

pod/doc_importers.py

@@ -45,6 +45,10 @@ class DocImporter:
         self.svgNs = ns[OdfEnvironment.NS_SVG]
         self.tempFolder = tempFolder
         self.importFolder = self.getImportFolder()
+        # If the importer generates one or several images, we will retain their
+        # names here, because we will need to declare them in
+        # META-INF/manifest.xml
+        self.fileNames = []
         if self.at:
             # Check that the file exists
             if not os.path.isfile(self.at):
@@ -142,6 +146,7 @@ class PdfImporter(DocImporter):
                     self.tempFolder, self.ns)
                 imgImporter.setAnchor('paragraph')
                 self.res += imgImporter.run()
+                self.fileNames += imgImporter.fileNames
                 os.remove(nextImage)
             else:
                 noMoreImages = True
@@ -214,6 +219,7 @@ class ImageImporter(DocImporter):
         # Compute path to image
         i = self.importPath.rfind('/Pictures/')
         imagePath = self.importPath[i+1:]
+        self.fileNames.append(imagePath)
         # Compute image size
         width, height = getSize(self.importPath, self.format)
         if width != None:

pod/renderer.py

@@ -17,7 +17,7 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,USA.
 
 # ------------------------------------------------------------------------------
-import zipfile, shutil, xml.sax, os, os.path, re
+import zipfile, shutil, xml.sax, os, os.path, re, mimetypes, time
 
 from UserDict import UserDict
 
@@ -134,33 +134,45 @@ class Renderer:
         self.stylesManager = None # Manages the styles defined into the ODT
         # template
         self.tempFolder = None
-        self.curdir = os.getcwd()
         self.env = None
         self.pyPath = pythonWithUnoPath
         self.ooPort = ooPort
         self.forceOoCall = forceOoCall
         self.finalizeFunction = finalizeFunction
+        # Retain potential files or images that will be included through
+        # "do ... from document" statements: we will need to declare them in
+        # META-INF/manifest.xml.
+        self.fileNames = []
         self.prepareFolders()
         # Unzip template
         self.unzipFolder = os.path.join(self.tempFolder, 'unzip')
         os.mkdir(self.unzipFolder)
         for zippedFile in self.templateZip.namelist():
-            fileName = os.path.basename(zippedFile)
-            folderName = os.path.dirname(zippedFile)
-            # Create folder if needed
-            fullFolderName = self.unzipFolder
-            if folderName:
-                fullFolderName = os.path.join(fullFolderName, folderName)
-                if not os.path.exists(fullFolderName):
-                    os.makedirs(fullFolderName)
-            # Unzip file
+            # Before writing the zippedFile into self.unzipFolder, create the
+            # intermediary subfolder(s) if needed.
+            fileName = None
+            if zippedFile.endswith('/') or zippedFile.endswith(os.sep):
+                # This is an empty folder. Create it nevertheless.
+                os.makedirs(os.path.join(self.unzipFolder, zippedFile))
+            else:
+                fileName = os.path.basename(zippedFile)
+                folderName = os.path.dirname(zippedFile)
+                fullFolderName = self.unzipFolder
+                if folderName:
+                    fullFolderName = os.path.join(fullFolderName, folderName)
+                    if not os.path.exists(fullFolderName):
+                        os.makedirs(fullFolderName)
+            # Unzip the file in self.unzipFolder
             if fileName:
                 fullFileName = os.path.join(fullFolderName, fileName)
                 f = open(fullFileName, 'wb')
                 fileContent = self.templateZip.read(zippedFile)
-                if fileName == 'content.xml':
+                if (fileName == 'content.xml') and not folderName:
+                    # content.xml files may reside in subfolders.
+                    # We modify only the one in the root folder.
                     self.contentXml = fileContent
-                elif fileName == 'styles.xml':
+                elif (fileName == 'styles.xml') and not folderName:
+                    # Same remark as above.
                     self.stylesManager = StylesManager(fileContent)
                     self.stylesXml = fileContent
                 f.write(fileContent)
@@ -268,7 +280,10 @@ class Renderer:
         imp = importer(content, at, format, self.tempFolder, ns)
         if isImage:
             imp.setAnchor(anchor)
-        return imp.run()
+        res = imp.run()
+        if imp.fileNames:
+            self.fileNames += imp.fileNames
+        return res
 
     def prepareFolders(self):
         # Check if I can write the result
@@ -293,6 +308,27 @@ class Renderer:
         except OSError, oe:
             raise PodError(CANT_WRITE_TEMP_FOLDER % (self.result, oe))
 
+    def patchManifest(self):
+        '''Declares, in META-INF/manifest.xml, images or files included via the
+           "do... from document" statements if any.'''
+        if self.fileNames:
+            j = os.path.join
+            toInsert = ''
+            for fileName in self.fileNames:
+                mimeType = mimetypes.guess_type(fileName)[0]
+                toInsert += ' <manifest:file-entry manifest:media-type="%s" ' \
+                            'manifest:full-path="%s"/>\n' % (mimeType, fileName)
+            manifestName = j(self.unzipFolder, j('META-INF', 'manifest.xml'))
+            f = file(manifestName)
+            manifestContent = f.read()
+            hook = '</manifest:manifest>'
+            manifestContent = manifestContent.replace(hook, toInsert+hook)
+            f.close()
+            # Write the new manifest content
+            f = file(manifestName, 'w')
+            f.write(manifestContent)
+            f.close()
+
     # Public interface
     def run(self):
         '''Renders the result.'''
@@ -303,6 +339,8 @@ class Renderer:
         self.currentParser = self.stylesParser
         # Create the resulting styles.xml
         self.currentParser.parse(self.stylesXml)
+        # Patch META-INF/manifest.xml
+        self.patchManifest()
         # Re-zip the result
         self.finalize()
 
@@ -397,11 +435,18 @@ class Renderer:
             resultOdt = zipfile.ZipFile(resultOdtName,'w', zipfile.ZIP_DEFLATED)
         except RuntimeError:
             resultOdt = zipfile.ZipFile(resultOdtName,'w')
-        os.chdir(self.unzipFolder)
-        for dir, dirnames, filenames in os.walk('.'):
+        for dir, dirnames, filenames in os.walk(self.unzipFolder):
             for f in filenames:
-                resultOdt.write(os.path.join(dir, f)[2:])
-                # [2:] is there to avoid havin './' in the path in the zip file.
+                folderName = dir[len(self.unzipFolder)+1:]
+                resultOdt.write(os.path.join(dir, f),
+                                os.path.join(folderName, f))
+            if not dirnames and not filenames:
+                # This is an empty leaf folder. We must create an entry in the
+                # zip for him
+                folderName = dir[len(self.unzipFolder):]
+                zInfo = zipfile.ZipInfo("%s/" % folderName,time.localtime()[:6])
+                zInfo.external_attr = 48
+                resultOdt.writestr(zInfo, '')
         resultOdt.close()
         resultType = os.path.splitext(self.result)[1]
         try:
@@ -431,6 +476,5 @@ class Renderer:
                     raise PodError(CONVERT_ERROR % output)
                 os.rename(resultName, self.result)
         finally:
-            os.chdir(self.curdir)
             FolderDeleter.delete(self.tempFolder)
 # ------------------------------------------------------------------------------

pod/test/contexts/Chart1.py

@@ -0,0 +1,5 @@
+johnScore = 25
+markScore = 53
+wilsonScore = 12
+meghuScore = 59
+

shared/__init__.py

@@ -18,7 +18,7 @@ mimeTypesExts = {
              'image/jpeg'                             : 'jpg',
              'image/gif'                              : 'gif'
              }
-xmlPrologue = '<?xml version="1.0" encoding="utf-8"?>'
+xmlPrologue = '<?xml version="1.0" encoding="utf-8"?>\n'
 
 # ------------------------------------------------------------------------------
 class UnmarshalledObject:

shared/odf.py

@@ -0,0 +1,58 @@
+'''This module contains some useful classes for constructing ODF documents
+   programmatically.'''
+
+# ------------------------------------------------------------------------------
+class OdtTable:
+    '''This class allows to construct an ODT table programmatically.'''
+    # Some namespace definitions
+    tns = 'table:'
+    txns = 'text:'
+
+    def __init__(self, tableName, paraStyle, cellStyle,
+                 paraHeaderStyle, cellHeaderStyle, nbOfCols):
+        self.tableName = tableName
+        self.paraStyle = paraStyle
+        self.cellStyle = cellStyle
+        self.paraHeaderStyle = paraHeaderStyle
+        self.cellHeaderStyle = cellHeaderStyle
+        self.nbOfCols = nbOfCols
+        self.res = ''
+
+    def dumpCell(self, content, span=1, header=False):
+        if header:
+            paraStyleName = self.paraHeaderStyle
+            cellStyleName = self.cellHeaderStyle
+        else:
+            paraStyleName = self.paraStyle
+            cellStyleName = self.cellStyle
+        self.res += '<%stable-cell %sstyle-name="%s" ' \
+                    '%snumber-columns-spanned="%d">' % \
+                    (self.tns, self.tns, cellStyleName, self.tns, span)
+        self.res += '<%sp %sstyle-name="%s">%s</%sp>' % \
+                    (self.txns, self.txns, paraStyleName, content, self.txns)
+        self.res += '</%stable-cell>' % self.tns
+
+    def startRow(self):
+        self.res += '<%stable-row>' % self.tns
+
+    def endRow(self):
+        self.res += '</%stable-row>' % self.tns
+
+    def startTable(self):
+        self.res += '<%stable %sname="AnalysisTable">' % (self.tns, self.tns)
+        self.res += '<%stable-column %snumber-columns-repeated="%d"/>' % \
+                    (self.tns, self.tns, self.nbOfCols)
+
+    def endTable(self):
+        self.res += '</%stable>' % self.tns
+
+    def dumpFloat(self, number):
+        return str(round(number, 2))
+
+    def get(self):
+        '''Returns the whole table.'''
+        self.startTable()
+        self.getRows()
+        self.endTable()
+        return self.res.decode('utf-8')
+# ------------------------------------------------------------------------------

shared/xml_parser.py

@@ -526,8 +526,7 @@ class XmlMarshaller:
                             mustDump = True
                     if mustDump:
                         self.dumpField(res, fieldName, fieldValue)
-            elif objectType in ('archetype', 'appy'):
-                fields = instance.schema.fields()
+            elif objectType == 'archetype':
                 for field in instance.schema.fields():
                     # Dump only needed fields
                     mustDump = False
@@ -550,18 +549,32 @@ class XmlMarshaller:
                             fieldType = 'ref'
                         self.dumpField(res, field.getName(),field.get(instance),
                                        fieldType=fieldType)
-                if objectType == 'appy':
-                    # Dump the object history.
-                    res.write('<history type="list">')
-                    wfInfo = instance.portal_workflow.getWorkflowsFor(instance)
-                    if wfInfo:
-                        history = instance.workflow_history[wfInfo[0].id]
-                        for event in history:
-                            res.write('<event type="object">')
-                            for k, v in event.iteritems():
-                                self.dumpField(res, k, v)
-                            res.write('</event>')
-                    res.write('</history>')
+            elif objectType == 'appy':
+                for field in instance.getAllAppyTypes():
+                    # Dump only needed fields
+                    if field.name in self.fieldsToExclude: continue
+                    if (field.type == 'Ref') and field.isBack: continue
+                    if (type(self.fieldsToMarshall) in self.sequenceTypes) \
+                        and (field.name not in self.fieldsToMarshall): continue
+                    # Determine field type
+                    fieldType = 'basic'
+                    if field.type == 'File':
+                        fieldType = 'file'
+                    elif field.type == 'Ref':
+                        fieldType = 'ref'
+                    self.dumpField(res, field.name,field.getValue(instance),
+                                   fieldType=fieldType)
+                # Dump the object history.
+                res.write('<history type="list">')
+                wfInfo = instance.portal_workflow.getWorkflowsFor(instance)
+                if wfInfo:
+                    history = instance.workflow_history[wfInfo[0].id]
+                    for event in history:
+                        res.write('<event type="object">')
+                        for k, v in event.iteritems():
+                            self.dumpField(res, k, v)
+                        res.write('</event>')
+                res.write('</history>')
             self.marshallSpecificElements(instance, res)
             res.write('</'); res.write(self.rootElementName); res.write('>')
         else: