## BooleanCombinationExpressionRendererclass BooleanCombinationExpressionRenderer (ExpressionRenderer, Editable):    def _render (self, out, req, session, definition, expression):        expressionName = session.getExpressionName(expression)        out.print('(')        for fei in expression.children:            eChild = definition.get(fei)            _renderExpression(session, out, req, definition, eChild)            if expression.children.indexOf(fei) < len(expression.children)-1:                out.println(' %s<br>' % expressionName)        out.print(')')    def _edit (self, out, req, session, definition, expression):        self._render(out, req, session, definition, expression)        out.println('<br>')        _displayAddButton(req, session, out, expression.id, 'Add conditional clause<br>\n', _getConditionalExpressions(session))## NotExpressionRendererclass NotExpressionRenderer (ExpressionRenderer):    def _render (self, out, req, session, definition, expression):        out.print('(not ')        iChild = expression.childExpressionId        if iChild:            eChild = definition.get(iChild)            _renderExpression(session, out, req, definition, eChild)                elif session.isInEditMode():            _displayAddButton(req, session, out, expression.id, 'Add conditional clause<br>\n', _getConditionalExpressions(session))        out.print(' )')## EqualsExpressionRenderer and friendsclass EqualsExpressionRenderer (BasicRenderer):    def __init__ (self):        BasicRenderer.__init__(self)        self.mandatoryFields = [ VALUE_OPTIONS, OTHER_OPTIONS ]        #self.optionalFields = [ ]        self.operator = '=='    def _render (self, out, req, session, definition, expression):        name, value, options = _getValue(expression, VALUE_OPTIONS)        otherName, otherValue, options = _getValue(expression, OTHER_OPTIONS)        name = _neutralize(name)        value = _neutralize(value)        otherName = _neutralize(otherName)        otherValue = _neutralize(otherValue)        out.print('%s::%s %s %s::%s' % (name, value, self.operator, otherName, otherValue))    def getHelpFileName (self):        return 'h_comparison.htm'class NotEqualsExpressionRenderer (EqualsExpressionRenderer):    def __init__ (self):        EqualsExpressionRenderer.__init__(self)        self.operator = '!='class ComparisonExpressionRenderer (EqualsExpressionRenderer):    def __init__ (self):        EqualsExpressionRenderer.__init__(self)        self.optionalFields = [ ('equals', [ '', 'true' ]) ]        self.operator = '?'    def _render (self, out, req, session, definition, expression):        if expression.orEquals(None) and len(self.operator) <= 1:            self.operator += '='        EqualsExpressionRenderer._render(self, out, req, session, definition, expression)class GreaterThanExpressionRenderer (ComparisonExpressionRenderer):    def __init__ (self):        ComparisonExpressionRenderer.__init__(self)        self.operator = '>'class LesserThanExpressionRenderer (ComparisonExpressionRenderer):    def __init__ (self):        ComparisonExpressionRenderer.__init__(self)        self.operator = '<'## ParticipantExpressionRendererdef cutDate (date):    if not date: return None    i = date.rfind('+')    j = date.rfind('-')    if i > j:        return date[:i]    else:        return date[:j]def determineReplyTime (session, expressionId):    """        Returns the datetime string at which a given expression was        replied to.        A help method for the ParticipantExpressionRenderer.    """    for hi in session.workItem.history:        if not hi.expressionId == expressionId: continue        if not hi.text == 'ok': continue        return cutDate(hi.date)    return Nonedef determineDispatchTime (session, expressionId):    """        If the expressionId matches the lastExpression for the workitem, will        return the dispatch time    """    if session.workItem.lastExpressionId.expressionId != expressionId:         return None    return cutDate(session.workItem.dispatchTime)class ParticipantExpressionRenderer (BasicRenderer):    def __init__ (self):        BasicRenderer.__init__(self)        self.mandatoryFields = [ REFS ]        self.optionalFields = [ 'timeout', 'description', 'filter' ]    def _render (self, out, req, session, definition, expression):        refType = None        refValue = None        for r in REFS:            v = expression.attributes.get(r)            if v:                refType = r                refValue = v                break        out.print(_img(req, IMG_PARTICIPANT))        out.print('<br>\n<small>participant : </small>')        if refType:            out.print(_neutralize(refType))            out.print('::')            out.print(_neutralize(refValue))        else:            out.print('---')        out.print('&nbsp;')        if not session.isInEditMode():            if not session.workItem: return            replyTime = determineReplyTime(session, expression.id.expressionId)            if replyTime:                out.print('<br>\n')                out.print('<small>reply time : %s</small>&nbsp;' % replyTime)            dispatchTime = determineDispatchTime(session, expression.id.expressionId)            if dispatchTime:                out.print('<br>\n')                out.print('<small>dispatch time : %s</small>&nbsp;' % dispatchTime)    def getHelpFileName (self):        return 'h_participant.htm'## save and restore expression rendererclass SaveExpressionRenderer (BasicRenderer):    def __init__ (self):        BasicRenderer.__init__(self)        self.mandatoryFields = [ TO_VARIABLE ]    def _render (self, out, req, session, definition, expression):        out.println('save<br>')        out.println('%s : &nbsp;' % TO_VARIABLE)        out.print(_neutralize(_getValue(expression, TO_VARIABLE)[1]))    def getHelpFileName (self):        return 'h_save.htm'class RestoreExpressionRenderer (BasicRenderer):    def __init__ (self):        BasicRenderer.__init__(self)        self.mandatoryFields = [ FROM_VARIABLE ]        self.optionalFields = [ ('merge-lead', ['', 'restored', 'current']), 'to-field' ]    def _render (self, out, req, session, definition, expression):        out.println('restore<br>')        out.println('%s : &nbsp;' % FROM_VARIABLE)        out.print(_neutralize(_getValue(expression, FROM_VARIABLE)[1]))    def getHelpFileName (self):        return 'h_restore.htm'## Unset/SetExpressionRendererclass SetExpressionRenderer (BasicRenderer):    def __init__ (self):        BasicRenderer.__init__(self)        self.mandatoryFields = [ OPTIONS, VALUE_OPTIONS ]        self.optionalFields = [ ('override', ['', 'true']), ('type', ['', 'boolean', 'integer', 'long', 'double']) ]        self.operator = '='    def _render (self, out, req, session, definition, expression):        targetName, targetValue, nada = _getValue(expression, OPTIONS)        sourceName, sourceValue, nada = _getValue(expression, VALUE_OPTIONS)        name = '?'        value = '?'        if targetName:            name = _neutralize('%s::"%s"' % (targetName, targetValue))        if sourceName:            value = _neutralize('%s::"%s"' % (sourceName, sourceValue))        out.print('<small>%s (</small>' % session.getExpressionName(expression))        out.print('%s %s %s' % (name, self.operator, value))        out.print('<small>)</small>&nbsp;')    def getHelpFileName (self):        return 'h_set.htm'class UnsetExpressionRenderer (BasicRenderer):    def __init__ (self):        BasicRenderer.__init__(self)        self.mandatoryFields = [ OPTIONS ]        #self.optionalFields = [ ]    def _render (self, out, req, session, definition, expression):        targetName, targetValue, nada = _getValue(expression, OPTIONS)        name = '?'        if targetName:            name = '%s::"%s"' % (targetName, targetValue)        out.print('<small>unset (</small>')        out.print(_neutralize(name))        out.print('<small>)</small>&nbsp;')    def getHelpFileName (self):        return 'h_unset.htm'class IncrementExpressionRenderer (SetExpressionRenderer):    def __init__ (self):        SetExpressionRenderer.__init__(self)        self.operator = '+='    def getHelpFileName (self):        return Noneclass SleepExpressionRenderer (BasicRenderer):    def __init__ (self):        BasicRenderer.__init__(self)        #self.mandatoryFields = [ OPTIONS ]        self.optionalFields = [ 'for', 'until' ]    def _render (self, out, req, session, definition, expression):        aFor = expression.attributes.get('for')        aUntil = expression.attributes.get('until')        out.print('<small>sleep ')        if aFor:            out.print('for %s' % aFor)        elif aUntil:            out.print("until %s" % aUntil)        out.print('</small>&nbsp;')    def getHelpFileName (self):        return 'h_sleep.htm'## subProcessRefExpression rendererclass SubProcessRefExpressionRenderer (BasicRenderer):    def __init__ (self):        BasicRenderer.__init__(self)        self.mandatoryFields = REFS        self.optionalFields = [ ('forget', ['', 'true']), 'fields' ]        self.fieldWidth = 70    def _determineRef (self, expression):        tuple = None        if expression.attributes.get(VARIABLE_REF):            tuple = (VARIABLE_REF, expression.attributes[VARIABLE_REF])        elif expression.attributes.get(FIELD_REF):            tuple = (FIELD_REF, expression.attributes[FIELD_REF])        else:            tuple = (REF, expression.attributes.get(REF))        return '<small>%s</small>::%s' % tuple    def _render (self, out, req, session, definition, expression):        out.print(_img(req, IMG_SUBPROCESS))        out.print('<br>\nlaunch subprocess :')        out.println('<br>\n%s' % self._determineRef(expression))    def getHelpFileName (self):        return 'h_subprocess.htm'## {Undefined|Defined}Expression rendererclass DefinedExpressionRenderer (BasicRenderer):    def __init__ (self):        BasicRenderer.__init__(self)        self.mandatoryFields = [ VALUE_OPTIONS[1:] ]            # without 'value'        #self.optionalFields = [ ]    def _determineItem (self, expression):        tuple = None        if expression.attributes.get(VARIABLE_VALUE):            tuple = (VARIABLE_VALUE, expression.attributes[VARIABLE_VALUE])        elif expression.attributes.get(FUNCTION_VALUE):            tuple = (FUNCTION_VALUE, expression.attributes[FUNCTION_VALUE])        else:            tuple = (FIELD_VALUE, expression.attributes.get(FIELD_VALUE))        return '<small>%s</small>::%s' % tuple    def _render (self, out, req, session, definition, expression):        qualifier = 'undefined'        if expressions.DefinedExpression.isAssignableFrom(expression.class):            qualifier = 'defined'        item = self._determineItem(expression)        out.print('%s is %s' % (item, qualifier))    def getHelpFileName (self):        if expressions.DefinedExpression.isAssignableFrom(expression.class):            return 'h_defined.htm'        return 'h_undefined.htm'## FILLING THE RENDERER_MAPRENDERER_MAP[expressions.SequenceExpression] = SequenceExpressionRendererRENDERER_MAP[expressions.ParticipantExpression] = ParticipantExpressionRendererRENDERER_MAP[expressions.SetValueExpression] = SetExpressionRendererRENDERER_MAP[expressions.UnsetValueExpression] = UnsetExpressionRendererRENDERER_MAP[expressions.IncrementExpression] = IncrementExpressionRendererRENDERER_MAP[expressions.ConcurrenceExpression] = ConcurrenceExpressionRendererRENDERER_MAP[expressions.IfExpression] = IfExpressionRendererRENDERER_MAP[expressions.WhenExpression] = WhenExpressionRendererRENDERER_MAP[expressions.OrExpression] = BooleanCombinationExpressionRendererRENDERER_MAP[expressions.AndExpression] = BooleanCombinationExpressionRendererRENDERER_MAP[expressions.NotExpression] = NotExpressionRendererRENDERER_MAP[expressions.EqualsExpression] = EqualsExpressionRendererRENDERER_MAP[expressions.NotEqualsExpression] = NotEqualsExpressionRendererRENDERER_MAP[expressions.GreaterThanExpression] = GreaterThanExpressionRendererRENDERER_MAP[expressions.LesserThanExpression] = LesserThanExpressionRendererRENDERER_MAP[expressions.SubProcessRefExpression] = SubProcessRefExpressionRendererRENDERER_MAP[expressions.DefinedExpression] = DefinedExpressionRendererRENDERER_MAP[expressions.UndefinedExpression] = DefinedExpressionRendererRENDERER_MAP[expressions.SaveExpression] = SaveExpressionRendererRENDERER_MAP[expressions.RestoreExpression] = RestoreExpressionRendererRENDERER_MAP[expressions.IteratorExpression] = IteratorExpressionRendererRENDERER_MAP[expressions.ConcurrentIteratorExpression] = ConcurrentIteratorExpressionRendererRENDERER_MAP[expressions.SleepExpression] = SleepExpressionRenderer#RENDERER_MAP[expressions.DefineExpression] = DefineExpressionRenderer