class BlankParagraphEditor (AbstractViewSchema.NodeAbstractView):
	def __init__(self, worksheet, blockEditor):
		super( BlankParagraphEditor, self ).__init__( worksheet, None )
		self._style = 'normal'
		paraAttrs = RichTextAttributes.fromValues({ 'style' : self._style }, None)
		self._editorModel = WSEditor.RichTextController.WorksheetRichTextController.instance.editorModelParagraph( None, [ '' ], paraAttrs )
		self._incr = IncrementalValueMonitor()
		self._blockEditor = blockEditor


	def getText(self):
		self._incr.onAccess()
		return ''

	def setContents(self, contents):
		self._editorModel.setModelContents( WSEditor.RichTextController.WorksheetRichTextController.instance, contents )
		if len( contents ) == 0:
			return
		elif len( contents ) == 1  and  contents[0] == '':
			return
		p = ParagraphEditor.newParagraph( contents, self._style )
		self._blockEditor.appendEditorNode( p )


	def getStyle(self):
		self._incr.onAccess()
		return self._style

	def setStyle(self, style):
		self._style = style
		self._incr.onChanged()


	def _refreshResults(self, module):
		pass
예제 #2
0
class InlinePythonCodeAbstractView(NodeAbstractView):
    STYLE_MINIMAL_RESULT = 0
    STYLE_RESULT = 1
    STYLE_CODE_AND_RESULT = 2
    STYLE_EDITABLE_CODE_AND_RESULT = 3

    _styleToName = {
        STYLE_MINIMAL_RESULT: 'minimal_result',
        STYLE_RESULT: 'result',
        STYLE_CODE_AND_RESULT: 'code_result',
        STYLE_EDITABLE_CODE_AND_RESULT: 'editable_code_result'
    }

    _nameToStyle = {
        'minimal_result': STYLE_MINIMAL_RESULT,
        'result': STYLE_RESULT,
        'code_result': STYLE_CODE_AND_RESULT,
        'editable_code_result': STYLE_EDITABLE_CODE_AND_RESULT
    }

    def __init__(self, worksheet, model):
        NodeAbstractView.__init__(self, worksheet, model)
        self._incr = IncrementalValueMonitor(self)
        self._result = None

    def getExpr(self):
        return self._model['expr']

    def getStyle(self):
        name = self._model['style']
        try:
            return self._nameToStyle[name]
        except KeyError:
            return self.STYLE_CODE_AND_RESULT

    def isCodeVisible(self):
        style = self.getStyle()
        return style == self.STYLE_CODE_AND_RESULT or style == self.STYLE_EDITABLE_CODE_AND_RESULT

    def isCodeEditable(self):
        style = self.getStyle()
        return style == self.STYLE_EDITABLE_CODE_AND_RESULT

    def isResultMinimal(self):
        style = self.getStyle()
        return style == self.STYLE_MINIMAL_RESULT

    def getResult(self):
        self._incr.onAccess()
        return self._result

    def _refreshResults(self, module):
        self._result = Execution.getResultOfEvaluationWithinModule(
            self.getExpr(), module)
        self._incr.onChanged()
예제 #3
0
class EmbeddedDisplay(object):
    def __init__(self):
        self._expr = EmbeddedPython2Expr()
        self._code = None
        self._values = []
        self._incr = IncrementalValueMonitor()
        self.__change_history__ = None

    def __getstate__(self):
        return {'expr': self._expr}

    def __setstate__(self, state):
        self._expr = state['expr']
        self._code = None
        self._values = []
        self._incr = IncrementalValueMonitor()
        self.__change_history__ = None

    def __get_trackable_contents__(self):
        return [self._expr]

    def __py_compile_visit__(self, codeGen):
        self._code = codeGen.compileForEvaluation(self._expr.model)

    def __py_eval__(self, _globals, _locals, codeGen):
        value = eval(self._code, _globals, _locals)
        self._values.append(value)
        self._incr.onChanged()
        return value

    def __py_replacement__(self):
        return deepcopy(self._expr.model['expr'])

    def __present__(self, fragment, inheritedState):
        def _embeddedDisplayMenu(element, menu):
            def _onClear(item):
                del self._values[:]
                self._incr.onChanged()

            menu.add(
                MenuItem.menuItemWithLabel('Clear collected values', _onClear))

            return False

        self._incr.onAccess()
        #exprPres = pyPerspective.applyTo( self._expr )
        exprPres = self._expr

        valuesPres = ObjectBox(
            'Values', Column([Paragraph([value]) for value in self._values]))

        contents = Column([exprPres, valuesPres])
        return ObjectBox(
            'Embedded display',
            contents).withContextMenuInteractor(_embeddedDisplayMenu)
class _TreeView (object):
	def __init__(self):
		self._incr = IncrementalValueMonitor()
		self.initialise()



	def __getstate__(self):
		return { None : None }


	def __setstate__(self, state):
		self._incr = IncrementalValueMonitor()
		self.initialise()



	def initialise(self):
		self._incr.onChanged()
		self._rootFrames = []
		self._currentFrame = None



	def begin(self):
		self._incr.onChanged()
		# Open a new frame
		prevFrame = self._currentFrame

		self._currentFrame = _Frame()
		if prevFrame is not None:
			prevFrame.childFrames.append( self._currentFrame )
		else:
			self._rootFrames.append( self._currentFrame )

		return prevFrame


	def end(self, state):
		prevFrame = state
		self._currentFrame = prevFrame


	def logValue(self, monitoredExpression, value):
		self._incr.onChanged()
		if self._currentFrame is not None:
			self._currentFrame.values.logValue( monitoredExpression, value )


	def __present__(self, fragment, inheritedState):
		self._incr.onAccess()
		valuesLive = LiveValue( Blank() )
		tree = Column( [ x._presentFrameSubtree( valuesLive )   for x in self._rootFrames ] )
		return Column( [ tree, Spacer( 0.0, 10.0 ), valuesLive ] )
class _TableView (object):
	def __init__(self):
		self._incr = IncrementalValueMonitor()
		self._schema = None
		self._tableEditor = None
		self._tableContent = None
		self._tableRow = None
		self._numTableRows = None


	def initialise(self, schema):
		self._schema = schema
		self._tableEditor = GenericTableEditor( [ v._name   for v in schema._monitoredExpressions ], True, True, False, False )
		self._tableContent = GenericTableModel( lambda: '', lambda x: x )
		self._tableRow = None
		self._numTableRows = None


	def __getstate__(self):
		return { None : None }


	def __setstate__(self, state):
		self._incr = IncrementalValueMonitor()
		self._schema = None
		self._tableEditor = None
		self._tableContent = None
		self._tableRow = None
		self._numTableRows = None



	def begin(self):
		state = self._tableRow
		self._numTableRows = self._numTableRows + 1   if self._numTableRows is not None   else   0
		self._tableRow = self._numTableRows
		return state

	def end(self, state):
		self._tableRow = state
		self._incr.onChanged()


	def logValue(self, monitoredExpression, value):
		index = self._schema._monitoredExpressionToindex[monitoredExpression]
		self._tableContent.set( index, self._tableRow, value )


	def __present__(self, fragment, inheritedState):
		self._incr.onAccess()
		return self._tableEditor.editTable( self._tableContent )   if self._tableEditor is not None   else   Blank()
class ConstantDefinition(object):
    def __init__(self):
        self._target = EmbeddedPython2Target()
        self._value = EmbeddedPython2Expr()
        self._incr = IncrementalValueMonitor()
        self.__change_history__ = None

    def __getstate__(self):
        return {'target': self._target, 'value': self._value}

    def __setstate__(self, state):
        self._target = state['target']
        self._value = state['value']
        self._incr = IncrementalValueMonitor()
        self.__change_history__ = None

    def __get_trackable_contents__(self):
        return [self.target, self.value]

    def __copy__(self):
        d = ConstantDefinition()
        d.target = self.target
        d.value = self.value
        return d

    def __deepcopy__(self, memo):
        d = ConstantDefinition()
        d.target = deepcopy(self.target, memo)
        d.value = deepcopy(self.value, memo)
        return d

    def _getTarget(self):
        self._incr.onAccess()
        return self._target

    def _setTarget(self, target):
        self._target = deepcopy(target)
        self._incr.onChanged()

    def _getValue(self):
        self._incr.onAccess()
        return self._value

    def _setValue(self, value):
        self._value = deepcopy(value)
        self._incr.onChanged()

    target = property(_getTarget, _setTarget)
    value = property(_getValue, _setValue)
예제 #7
0
class _TempBlankPara(elem.MRTElem):
    def __init__(self, projection_table, block):
        super(_TempBlankPara, self).__init__(projection_table, None)

        self._block = block
        self._style = 'normal'
        self._incr = IncrementalValueMonitor()
        para_attrs = RichTextAttributes.fromValues({'style': self._style},
                                                   None)
        self._editorModel = controller.MallardRichTextController.instance.editorModelParagraph(
            [], para_attrs)

    def setContents(self, contents):
        if len(contents) == 0:
            return
        elif len(contents) == 1 and contents[0] == '':
            return
        p = Para.new_p(self._projection_table, contents)
        self._block.append(p)

    def getContents(self):
        self._incr.onAccess()
        return []

    def setStyle(self, style):
        self._style = style
        self._incr.onChanged()

    _styleMap = {
        'normal': NormalText,
        'h1': Heading1,
        'h2': Heading2,
        'h3': Heading3,
        'h4': Heading4,
        'h5': Heading5,
        'h6': Heading6,
        'title': Title
    }

    def __present__(self, fragment, inheritedState):
        self._incr.onAccess()
        x = NormalText('')
        x = controller.MallardRichTextController.instance.editableParagraph(
            self, x)
        return x

    def __repr__(self):
        return '<blank_para'
class ConsoleBlock (object):
	def __init__(self, pythonModule, execResult):
		self._incr = IncrementalValueMonitor( self )

		self._pythonModule = pythonModule
		self._execResult = execResult



	def getPythonModule(self):
		self._incr.onAccess()
		return self._pythonModule

	def getExecResult(self):
		self._incr.onAccess()
		return self._execResult



	def __present__(self, fragment, inheritedState):
		pythonModule = self.getPythonModule()

		executionResult = self.getExecResult()

		caughtException = executionResult.getCaughtException()
		result = executionResult.getResult()
		streams = executionResult.getStreams()

		moduleView = StyleSheet.style( Primitive.editable( False ) ).applyTo( Python2.python2EditorPerspective.applyTo( pythonModule ) )
		caughtExceptionView = ApplyPerspective.defaultPerspective( caughtException )   if caughtException is not None   else None
		resultView = ApplyPerspective.defaultPerspective( result[0] )   if result is not None   else None

		code = _pythonModuleBorderStyle.applyTo( Border( moduleView.alignHExpand() ).alignHExpand() )
		outputContents = []
		for stream in streams:
			if stream.name == 'out':
				outputContents.append( execStdout( stream.richString, True ) )
			elif stream.name == 'err':
				outputContents.append( execStderr( stream.richString, True ) )
			else:
				raise ValueError, 'Unreckognised stream \'{0}\''.format( stream.name )
		if caughtExceptionView is not None:
			outputContents.append( execException( caughtExceptionView ) )
		if resultView is not None:
			outputContents.append( execResult( resultView ) )
		outputColumn = _blockOutputStyle.applyTo( Column( outputContents ).alignHExpand() )
		return _blockStyle.applyTo( Border( Column( [ code, outputColumn ] ) ) ).alignHExpand()
class LiterateExpression(object):
    def __init__(self, expr=None):
        if expr is None:
            expr = EmbeddedPython2Expr()
        self._expr = expr

        self._incr = IncrementalValueMonitor()
        self.__change_history__ = None

    def __getstate__(self):
        return {'expr': self._expr}

    def __setstate__(self, state):
        self._expr = state['expr']
        self._incr = IncrementalValueMonitor()
        self.__change_history__ = None

    def __get_trackable_contents__(self):
        return [self._expr]

    def __py_evalmodel__(self, codeGen):
        return self._expr.model

    def __py_replacement__(self):
        return deepcopy(self._expr.model['expr'])

    def _new_reference(self):
        return LiterateExpression(self._expr)

    def __present__(self, fragment, inheritedState):
        self._incr.onAccess()
        exprPres = self._expr

        header = Row([
            self._angleQuoteStyle(Label(u'\u00ab')),
            self._angleQuoteStyle(Label(u'\u00bb')),
            Spacer(9.0, 0.0)
        ]).withDragSource(_dragSource)

        return ObjectBorder(Row([header.alignVCentre(), exprPres]))

    _angleQuoteStyle = StyleSheet.style(
        Primitive.foreground(Color(0.15, 0.15, 0.45)),
        Primitive.fontBold(True), Primitive.fontSize(12))
예제 #10
0
class MRTAbstractText(elem.MRTElem):
    contents_query = None  # Abstract

    def __init__(self, projection_table, elem, contents=None):
        super(MRTAbstractText, self).__init__(projection_table, elem)
        self.contents_query.change_listener = self._on_changed
        self._editorModel = None
        self._incr = IncrementalValueMonitor()
        if contents is not None:
            self.setContents(contents)

    def _on_changed(self):
        self._editorModel.setModelContents(
            controller.MallardRichTextController.instance, self.contents_query)
        self._incr.onChanged()

    def setContents(self, contents):
        self.contents_query = contents

    def getContents(self):
        self._incr.onAccess()
        return self.contents_query[:]
class ConstantTable(object):
    def __init__(self):
        self._definitions_ = []
        self._incr = IncrementalValueMonitor()
        self.__change_history__ = None

    def __getstate__(self):
        return {'definitions': self._definitions_}

    def __setstate__(self, state):
        self._definitions_ = state['definitions']
        self._incr = IncrementalValueMonitor()
        self.__change_history__ = None

    def __get_trackable_contents__(self):
        return self._definitions.__get_trackable_contents__()

    def __len__(self):
        self._incr.onAccess()
        return len(self._definitions)

    def __iter__(self):
        self._incr.onAccess()
        return iter(self._definitions)

    def __getitem__(self, i):
        self._incr.onAccess()
        return self._definitions[i]

    def __setitem__(self, i, x):
        self._definitions[i] = x
        self._incr.onChanged()

    def __delitem__(self, i):
        del self._definitions[i]
        self._incr.onChanged()

    def append(self, x):
        self._definitions.append(x)
        self._incr.onChanged()

    def __py_execmodel__(self, codeGen):
        assigns = []
        for definition in self._definitions_:
            target = definition.target.model['target']
            value = definition.value.model['expr']
            assign = Py.AssignStmt(targets=[target], value=value)
            assigns.append(assign)
        return Py.PythonSuite(suite=assigns)

    __py_hide_expansion__ = True

    def __present__(self, fragment, inheritedState):
        return _tableEditor.editTable(self)

    @TrackedListProperty
    def _definitions(self):
        return self._definitions_
예제 #12
0
class Block(elem.MRTElem):
    contents_query = elem_query.children(['p', 'section',
                                          'note']).project_to_objects(
                                              mappings.block_contents_mapping)

    def __init__(self, projection_table, elem, contents=None):
        super(Block, self).__init__(projection_table, elem)
        self.contents_query.change_listener = self._on_changed
        self._editorModel = controller.MallardRichTextController.instance.editorModelBlock(
            [])
        self._incr = IncrementalValueMonitor()
        if contents is not None:
            self.setContents(contents)

    def node_init(self):
        self._editorModel.setModelContents(
            controller.MallardRichTextController.instance,
            list(self.contents_query))

    def _filterContents(self, xs):
        return [x for x in xs if not isinstance(x, para._TempBlankPara)]

    def _on_changed(self):
        self._editorModel.setModelContents(
            controller.MallardRichTextController.instance,
            list(self.contents_query))
        self._incr.onChanged()

    def setContents(self, contents):
        self.contents_query = self._filterContents(list(contents))

    def append(self, para):
        self.contents_query.append(para)

    def insertAfter(self, para, p):
        index = -1
        for (i, x) in enumerate(self.contents_query):
            if p is x:
                index = i
        self.contents_query.insert(index + 1, para)

    def removeParagraph(self, para):
        index = -1
        for (i, x) in enumerate(self.contents_query):
            if para is x:
                index = i
        if index != -1:
            del self.contents_query[index]
        else:
            raise ValueError, 'could not find para'

    def __present__(self, fragment, inheritedState):
        self._incr.onAccess()
        contents = self.contents_query
        xs = list(contents) if len(contents) > 0 else [
            para._TempBlankPara(self._projection_table, self)
        ]
        #xs = self._contents + [_TempBlankPara( self )]
        x = Body(xs)
        x = controller.MallardRichTextController.instance.editableBlock(
            self, x)
        return x
class LiterateSuite(object):
    def __init__(self, definition=None, expanded=True):
        if definition is None:
            definition = LiterateSuiteDefinition()
        self._definition = definition

        self._expanded = expanded

        self._incr = IncrementalValueMonitor()
        self.__change_history__ = None

    def __getstate__(self):
        return {'definition': self._definition, 'expanded': self._expanded}

    def __setstate__(self, state):
        self._definition = state.get('definition')
        self._expanded = state.get('expanded', True)
        if self._definition is None:
            self._definition = LiterateSuiteDefinition()
        self._incr = IncrementalValueMonitor()
        self.__change_history__ = None

    def __get_trackable_contents__(self):
        return [self._definition]

    def __py_execmodel__(self, codeGen):
        return self._definition._suite.model

    def __py_replacement__(self):
        return deepcopy(self._definition._suite.model['suite'])

    def _new_reference(self):
        return LiterateSuite(self._definition)

    def getName(self):
        return self._definition.getName()

    def setName(self, name):
        self._definition.setName(name)

    def isExpanded(self):
        return self._expanded

    def setExpanded(self, expanded):
        oldExpanded = self._expanded
        self._expanded = expanded
        self._incr.onChanged()
        if self.__change_history__ is not None:
            self.__change_history__.addChange(
                lambda: self.setExpanded(expanded),
                lambda: self.setExpanded(oldExpanded),
                'Literate suite set expanded')

    def __present__(self, fragment, inheritedState):
        def _literateExpressionMenu(element, menu):
            def _onToggleExpanded(item):
                self.setExpanded(not self._expanded)

            menuItemName = 'Start as contracted' if self._expanded else 'Start as expanded'
            menu.add(
                MenuItem.menuItemWithLabel(menuItemName, _onToggleExpanded))

            return False

        self._incr.onAccess()
        self._definition._incr.onAccess()
        suitePres = self._definition._suite

        nameLabel = self._nameStyle(Label(self._definition._name))
        liveName = LiveValue(nameLabel)

        class _NameEntryListener(TextEntry.TextEntryListener):
            def onAccept(listener, textEntry, text):
                self.setName(text)

            def onCancel(listener, textEntry, orignalText):
                liveName.setLiteralValue(nameLabel)

        def _onNameButton(button, event):
            nameEntry = TextEntry(self._definition._name, _NameEntryListener())
            nameEntry.grabCaretOnRealise()
            nameEntry = self._nameStyle(nameEntry)
            liveName.setLiteralValue(nameEntry)

        renameButton = self._nameButtonStyle(
            Button.buttonWithLabel('...', _onNameButton))

        header = Row([
            self._angleQuoteStyle(Label(u'\u00ab')), liveName,
            self._angleQuoteStyle(Label(u'\u00bb')),
            Spacer(10.0, 0.0), renameButton
        ]).withDragSource(_dragSource)

        dropDown = self._dropDownStyle(
            DropDownExpander(header, suitePres, self._expanded, None))

        return ObjectBorder(dropDown).withContextMenuInteractor(
            _literateExpressionMenu)

    _nameStyle = StyleSheet.style(
        Primitive.foreground(Color(0.15, 0.15, 0.45)), Primitive.fontSize(12))
    _nameButtonStyle = StyleSheet.style(Primitive.fontSize(10))
    _angleQuoteStyle = StyleSheet.style(
        Primitive.foreground(Color(0.15, 0.15, 0.45)),
        Primitive.fontBold(True), Primitive.fontSize(12))
    _dropDownStyle = StyleSheet.style(
        Controls.dropDownExpanderHeaderArrowSize(10.0),
        Controls.dropDownExpanderPadding(12.0))
예제 #14
0
class StandardInlineTest (AbstractInlineTest):
	def __init__(self, name='test'):
		super( StandardInlineTest, self ).__init__()
		self._name = TrackedLiveValue( name )
		self._suite = EmbeddedPython2Suite()
		self.__change_history__ = None

		self.__passes = None
		self.__failures = None

		self._incr = IncrementalValueMonitor()


	def __getstate__(self):
		state = super( StandardInlineTest, self ).__getstate__()
		state['name'] = self._name.getStaticValue()
		state['suite'] = self._suite
		return state

	def __setstate__(self, state):
		super( StandardInlineTest, self ).__setstate__( state )
		self._name = TrackedLiveValue( state['name'] )
		self._suite = state['suite']
		self.__change_history__ = None

		self.__passes = None
		self.__failures = None

		self._incr = IncrementalValueMonitor()


	def __get_trackable_contents__(self):
		return [ self._name, self._suite ]


	def reset(self):
		super( StandardInlineTest, self ).reset()
		self.__passes = None
		self.__failures = None
		self._incr.onChanged()



	def _runTestsOnInstance(self, instance):
		self.__passes = 0
		self.__failures = []

		for name in self._testClass.__dict__:
			if name.startswith( 'test' ):
				# Run this test method
				try:
					getattr( instance, name )()
				except Exception:
					caughtException = JythonException.getCurrentException()
					self.__failures.append( (name, caughtException) )
				else:
					self.__passes += 1

		self._incr.onChanged()



	@property
	def _desiredClassName(self):
		return 'Test_' + self._name.getValue()

	def _createTestClassBodyStmts(self, codeGen, testedBlock):
		return self._suite.model['suite']


	__embed_hide_frame__ = True

	def __present__(self, fragment, inheritedState):
		self._incr.onAccess()

		title = SectionHeading2( 'Unit tests' )

		nameEntry = _nameBorder.surround( EditableLabel( self._name, _notSet ).regexValidated( Tokens.identifierPattern, 'Please enter a valid identifier' ) )

		header = Row( [ title, Spacer( 25.0, 0.0 ), nameEntry ] )

		contents = [ header.padY( 0.0, 5.0 ), _standardCodeBorder.surround( self._suite ).padY( 3.0 ).alignHExpand() ]

		if self.__passes is not None  and  self.__failures is not None:
			resultsTitle = SectionHeading3( 'Test results:' )
			passes = _standardPassStyle( Label( '%d / %d test(s) passed' % ( self.__passes, self.__passes + len( self.__failures ) ) ) )
			failuresLabel = _standardFailStyle( Label( '%d test(s) failed:' % len( self.__failures ) ) )
			failures = [ Column( [ _standardFailedTestStyle( Label( name ) ), Pres.coerce( exception ).padX( 5.0, 0.0 ) ] ).padX( 5.0, 0.0 )   for name, exception in self.__failures ]
			results = _standardResultsBorder.surround( Column( [ resultsTitle, passes, failuresLabel ] + failures ) ).pad( 3.0, 3.0 )
			contents.append( results )


		return _standardInlineTestBorder.surround( Column( contents ) )
class IntEditorSpinEntry(Editor):
    def __init__(self, model=None, value=0):
        super(IntEditorSpinEntry, self).__init__(model, value)
        self._min = -1000000
        self._max = 1000000
        self._step = 1
        self._page = 10
        self._incr = IncrementalValueMonitor()

    def __getstate__(self):
        state = super(IntEditorSpinEntry, self).__getstate__()
        state['min'] = self._min
        state['max'] = self._max
        state['step'] = self._step
        state['page'] = self._page
        return state

    def __setstate__(self, state):
        super(IntEditorSpinEntry, self).__setstate__(state)
        self._min = state.get('min', -1000000)
        self._max = state.get('max', 1000000)
        self._step = state.get('step', 1)
        self._page = state.get('page', 10)
        self._incr = IncrementalValueMonitor()

    def _newModel(self, value):
        if not isinstance(value, int):
            value = 0
        return Model(value)

    def _createSettingsPres(self):
        def _listener(attrName):
            class _Listener(TextEntry.TextEntryListener):
                def onTextChanged(listener, textEntry):
                    if textEntry.isDisplayedTextValid():
                        setattr(self, attrName,
                                int(textEntry.getDisplayedText()))
                        self._incr.onChanged()

            return _Listener()

        min = [
            Label('Min'),
            TextEntry(str(self._min), _listener('_min')).regexValidated(
                Tokens.decimalIntegerPattern, 'Please enter an integer value')
        ]
        max = [
            Label('Max'),
            TextEntry(str(self._max), _listener('_max')).regexValidated(
                Tokens.decimalIntegerPattern, 'Please enter an integer value')
        ]
        step = [
            Label('Step'),
            TextEntry(str(self._step), _listener('_step')).regexValidated(
                Tokens.decimalIntegerPattern, 'Please enter an integer value')
        ]
        page = [
            Label('Page'),
            TextEntry(str(self._page), _listener('_page')).regexValidated(
                Tokens.decimalIntegerPattern, 'Please enter an integer value')
        ]
        return Table([min, max, step, page])

    def buildEditorPres(self, fragment, inheritedState):
        self._incr.onAccess()
        return IntSpinEntry(self._model.liveValue, self._min, self._max,
                            self._step, self._page)
예제 #16
0
class LiveList(object):
    __slots__ = ['__change_history__', '_items', '_incr', '__changeListener']

    def __init__(self, xs=None):
        self._items = []
        if xs is not None:
            self._items[:] = xs[:]
        self.__change_history__ = None
        self._incr = IncrementalValueMonitor()
        self.__changeListener = None

    @property
    def changeListener(self):
        return self.__changeListener

    @changeListener.setter
    def changeListener(self, x):
        self.__changeListener = x

    def __getstate__(self):
        self._incr.onAccess()
        return {'items': self._items}

    def __setstate__(self, state):
        self._items = state['items']
        self.__change_history__ = None
        self._incr = IncrementalValueMonitor()
        self.__changeListener = None

    def __copy__(self):
        self._incr.onAccess()
        t = type(self)
        return t(self._items)

    def __deepcopy__(self, memo):
        self._incr.onAccess()
        t = type(self)
        return t(deepcopy(self._items, memo))

    def __eq__(self, other):
        if isinstance(other, LiveList):
            other = other._items
        return self._items == other

    def __ne__(self, other):
        if isinstance(other, LiveList):
            other = other._items
        return self._items != other

    def __str__(self):
        return str(self._items)

    def __repr__(self):
        return 'LiveList( {0} )'.format(repr(self._items))

    def __get_trackable_contents__(self):
        return self._items

    def __clipboard_copy__(self, memo):
        self._incr.onAccess()
        t = type(self)
        return t([memo.copy(x) for x in self])

    def __iter__(self):
        self._incr.onAccess()
        return _LiveListIter(iter(self._items), self._incr)

    def __contains__(self, x):
        self._incr.onAccess()
        return x in self._items

    def __add__(self, xs):
        self._incr.onAccess()
        return self._items + xs

    def __mul__(self, x):
        self._incr.onAccess()
        return self._items * x

    def __rmul__(self, x):
        self._incr.onAccess()
        return x * self._items

    def __getitem__(self, index):
        self._incr.onAccess()
        return self._items[index]

    def __len__(self):
        self._incr.onAccess()
        return len(self._items)

    def index(self, x, i=None, j=None):
        self._incr.onAccess()
        if i is None:
            return self._items.index(x)
        elif j is None:
            return self._items.index(x, i)
        else:
            return self._items.index(x, i, j)

    def count(self, x):
        self._incr.onAccess()
        return self._items.count(x)

    def __setitem__(self, index, x):
        if isinstance(index, int) or isinstance(index, long):
            oldX = self._items[index]
            if self.__changeListener is not None:
                oldContents = self._items[:]
            self._items[index] = x
            onTrackedListSetItem(self.__change_history__, self, index, oldX, x,
                                 'Live list set item')
            if self.__changeListener is not None:
                self.__changeListener(oldContents, self._items[:])
        else:
            oldContents = self._items[:]
            self._items[index] = x
            newContents = self._items[:]
            onTrackedListSetContents(self.__change_history__, self,
                                     oldContents, newContents,
                                     'Live list set item')
            if self.__changeListener is not None:
                self.__changeListener(oldContents, newContents)
        self._incr.onChanged()

    def __delitem__(self, index):
        oldContents = self._items[:]
        del self._items[index]
        newContents = self._items[:]
        onTrackedListSetContents(self.__change_history__, self, oldContents,
                                 newContents, 'Live list del item')
        if self.__changeListener is not None:
            self.__changeListener(oldContents, newContents)
        self._incr.onChanged()

    def append(self, x):
        if self.__changeListener is not None:
            oldContents = self._items[:]
        self._items.append(x)
        onTrackedListAppend(self.__change_history__, self, x,
                            'Live list append')
        if self.__changeListener is not None:
            self.__changeListener(oldContents, self._items[:])
        self._incr.onChanged()

    def extend(self, xs):
        if self.__changeListener is not None:
            oldContents = self._items[:]
        self._items.extend(xs)
        onTrackedListExtend(self.__change_history__, self, xs,
                            'Live list extend')
        if self.__changeListener is not None:
            self.__changeListener(oldContents, self._items[:])
        self._incr.onChanged()

    def insert(self, i, x):
        if self.__changeListener is not None:
            oldContents = self._items[:]
        self._items.insert(i, x)
        onTrackedListInsert(self.__change_history__, self, i, x,
                            'Live list insert')
        if self.__changeListener is not None:
            self.__changeListener(oldContents, self._items[:])
        self._incr.onChanged()

    def pop(self):
        if self.__changeListener is not None:
            oldContents = self._items[:]
        x = self._items.pop()
        onTrackedListPop(self.__change_history__, self, x, 'Live list pop')
        if self.__changeListener is not None:
            self.__changeListener(oldContents, self._items[:])
        self._incr.onChanged()
        return x

    def remove(self, x):
        if self.__changeListener is not None:
            oldContents = self._items[:]
        i = self._items.index(x)
        xFromList = self._items[i]
        del self._items[i]
        onTrackedListRemove(self.__change_history__, self, i, xFromList,
                            'Live list remove')
        if self.__changeListener is not None:
            self.__changeListener(oldContents, self._items[:])
        self._incr.onChanged()

    def reverse(self):
        if self.__changeListener is not None:
            oldContents = self._items[:]
        self._items.reverse()
        onTrackedListReverse(self.__change_history__, self,
                             'Live list reverse')
        if self.__changeListener is not None:
            self.__changeListener(oldContents, self._items[:])
        self._incr.onChanged()

    def sort(self, cmp=None, key=None, reverse=None):
        oldContents = self._items[:]
        self._items.sort(cmp, key, reverse)
        newContents = self._items[:]
        onTrackedListSetContents(self.__change_history__, self, oldContents,
                                 newContents, 'Live list sort')
        if self.__changeListener is not None:
            self.__changeListener(oldContents, newContents)
        self._incr.onChanged()

    def _setContents(self, xs):
        oldContents = self._items[:]
        self._items[:] = xs
        onTrackedListSetContents(self.__change_history__, self, oldContents,
                                 xs, 'Live list set contents')
        if self.__changeListener is not None:
            self.__changeListener(oldContents, self._items[:])
        self._incr.onChanged()
예제 #17
0
class PythonCodeAbstractView(NodeAbstractView):
    STYLE_MINIMAL_RESULT = 0
    STYLE_RESULT = 1
    STYLE_CODE_AND_RESULT = 2
    STYLE_CODE = 3
    STYLE_EDITABLE_CODE_AND_RESULT = 4
    STYLE_EDITABLE_CODE = 5
    STYLE_ERRORS = 6
    STYLE_HIDDEN = 7

    _styleToName = {
        STYLE_MINIMAL_RESULT: 'minimal_result',
        STYLE_RESULT: 'result',
        STYLE_CODE_AND_RESULT: 'code_result',
        STYLE_CODE: 'code',
        STYLE_EDITABLE_CODE_AND_RESULT: 'editable_code_result',
        STYLE_EDITABLE_CODE: 'editable_code',
        STYLE_ERRORS: 'errors',
        STYLE_HIDDEN: 'hidden'
    }

    _nameToStyle = {
        'minimal_result': STYLE_MINIMAL_RESULT,
        'result': STYLE_RESULT,
        'code_result': STYLE_CODE_AND_RESULT,
        'code': STYLE_CODE,
        'editable_code_result': STYLE_EDITABLE_CODE_AND_RESULT,
        'editable_code': STYLE_EDITABLE_CODE,
        'errors': STYLE_ERRORS,
        'hidden': STYLE_HIDDEN
    }

    def __init__(self, worksheet, model):
        NodeAbstractView.__init__(self, worksheet, model)
        self._incr = IncrementalValueMonitor(self)
        self._result = None

    def getCode(self):
        return self._model['code']

    def getStyle(self):
        name = self._model['style']
        try:
            return self._nameToStyle[name]
        except KeyError:
            return self.STYLE_CODE_AND_RESULT

    def isCodeVisible(self):
        style = self.getStyle()
        return style == self.STYLE_CODE or style == self.STYLE_CODE_AND_RESULT or style == self.STYLE_EDITABLE_CODE or style == self.STYLE_EDITABLE_CODE_AND_RESULT

    def isCodeEditable(self):
        style = self.getStyle()
        return style == self.STYLE_EDITABLE_CODE or style == self.STYLE_EDITABLE_CODE_AND_RESULT

    def isResultVisible(self):
        style = self.getStyle()
        return style == self.STYLE_MINIMAL_RESULT or style == self.STYLE_RESULT or style == self.STYLE_CODE_AND_RESULT or style == self.STYLE_EDITABLE_CODE_AND_RESULT

    def isResultMinimal(self):
        style = self.getStyle()
        return style == self.STYLE_MINIMAL_RESULT

    def isMinimal(self):
        style = self.getStyle()
        return style == self.STYLE_MINIMAL_RESULT or style == self.STYLE_ERRORS

    def isVisible(self):
        style = self.getStyle()
        if style == self.STYLE_HIDDEN:
            return False
        elif style == self.STYLE_ERRORS:
            result = self.getResult()
            return result.hasErrors()
        else:
            return True

    def getResult(self):
        self._incr.onAccess()
        return self._result

    def _refreshResults(self, module):
        self._result = Execution.getResultOfExecutionWithinModule(
            self.getCode(), module, self.isResultVisible())
        self._incr.onChanged()
class MonitoredExpression (object):
	_currentSuite = None

	def __init__(self):
		self._name = 'value'
		self._expr = EmbeddedPython2Expr()
		self._suite = None
		self._code = None
		self._incr = IncrementalValueMonitor()
		self.__change_history__ = None


	def __getstate__(self):
		return { 'name' : self._name,  'expr' : self._expr }

	def __setstate__(self, state):
		self._name = state['name']
		self._expr = state['expr']
		self._suite = None
		self._code = None
		self._incr = IncrementalValueMonitor()
		self.__change_history__ = None


	def __get_trackable_contents__(self):
		return [ self._name, self._expr ]


	def __py_compile_visit__(self, codeGen):
		self._code = codeGen.compileForEvaluation( self._expr.model )
		self._suite = self._currentSuite
		if self._suite is not None:
			self._suite._registerMonitoredExpression( self )


	def __py_eval__(self, _globals, _locals, codeGen):
		value = eval( self._code, _globals, _locals )
		if self._suite is not None:
			self._suite._logValue( self, value )
		return value

	def __py_replacement__(self):
		return deepcopy( self._expr.model['expr'] )


	def __present__(self, fragment, inheritedState):
		self._incr.onAccess()

		def _setName(editableLabel, text):
			self._name = text
			self._incr.onChanged()


		namePres = EditableLabel( self._name, self._nameNotSetStyle( Label( '<not set>' ) ), _setName ).regexValidated( Pattern.compile( '[a-zA-Z_][a-zA-Z0-9_]*' ), 'Please enter a valid identifier' )

		exprPres = self._expr

		contents = Row( [ namePres, Label( ': ' ), exprPres ] )
		return ObjectBox( 'Monitored exp.', contents )

	_nameNotSetStyle = StyleSheet.style( Primitive.foreground( Color( 0.5, 0.0, 0.0 ) ), Primitive.fontItalic( True ) )
class EvalFieldInstance(FieldInstance):
    """
	A field that contains a value, which can alternatively have an expression that generates the required value
	"""
    def __init__(self, field, object_instance, wrapped_source_value):
        super(EvalFieldInstance, self).__init__(field, object_instance,
                                                wrapped_source_value)

        self.__change_history__ = None

        if wrapped_source_value is not None:
            source_value = wrapped_source_value[0]
            if isinstance(source_value, _EvalFieldState):
                constantValue = source_value.constantValue
                expr = source_value.expr
            else:
                constantValue = source_value
                expr = None
        else:
            constantValue = field._getDefaultValue()
            expr = None

        self._live = TrackedLiveValue(constantValue)
        self._expr = expr
        self.__incr = IncrementalValueMonitor()

    def isConstant(self):
        return self._expr is None

    @property
    def constantValue(self):
        return self._live.getValue()

    @constantValue.setter
    def constantValue(self, x):
        self._live.setLiteralValue(x)

    @property
    def constantValueLive(self):
        return self._live

    @property
    def expr(self):
        return self._expr

    @expr.setter
    def expr(self, exp):
        oldExpr = self._expr
        self._expr = exp

        if self.__change_history__ is not None:
            if oldExpr is not None:
                self.__change_history__.stopTracking(oldExpr)

            def setExpression():
                self.expr = exp

            def revertExpression():
                self.expr = oldExpr

            self.__change_history__.addChange(setExpression, revertExpression,
                                              'Set expression')
            if exp is not None:
                self.__change_history__.track(exp)

        self.__incr.onChanged()

    def _addTrackableContentsTo(self, contents):
        contents.append(self)

    def __field_getstate__(self):
        return _EvalFieldState(self._live.getValue(), self._expr)

    def __field_getstate_for_clipboard_copy__(self, memo):
        return _EvalFieldState(memo.copy(self._live.getValue()),
                               memo.copy(self._expr))

    def getValueForEditor(self):
        return self._live.getValue()

    def __py_evalmodel__(self, codeGen):
        self.__incr.onAccess()
        if self._expr is None:
            return self.__fixedvalue_py_evalmodel__(self._live.getValue(),
                                                    codeGen)
        else:
            return self._expr.model

    def __fixedvalue_py_evalmodel__(self, value, codeGen):
        return Py.coerceToModel(value)

    def __get_trackable_contents__(self):
        if self._expr is not None:
            return [self._live, self._expr]
        else:
            return [self._live]

    def editUI(self, controlFactoryFn):
        self.__incr.onAccess()
        valueControl = controlFactoryFn(self._live)

        if self._expr is None:

            def _onAdd(button, event):
                self.expr = EmbeddedPython2Expr()

            addButton = Button(self._addButtonContents, _onAdd).alignHPack()

            return Row([valueControl, Spacer(10.0, 0.0), addButton])
        else:

            def _onRemove(button, event):
                self.expr = None

            removeButton = Button(self._removeButtonContents,
                                  _onRemove).alignHPack()

            return Column([
                valueControl,
                Row([
                    removeButton,
                    Spacer(10.0, 0.0),
                    exprBorder.surround(self._expr)
                ])
            ])

    _addStyle = StyleSheet.style(Primitive.foreground(Color(0.0, 0.5, 0.0)),
                                 Primitive.fontBold(True),
                                 Primitive.fontSize(11))
    _removeStyle = StyleSheet.style(Primitive.foreground(Color(0.5, 0.0, 0.0)),
                                    Primitive.fontBold(True),
                                    Primitive.fontSize(11))
    _fStyle = StyleSheet.style(Primitive.foreground(Color(0.0, 0.25, 0.5)),
                               Primitive.fontItalic(True),
                               Primitive.fontSize(11))
    _parenStyle = StyleSheet.style(Primitive.foreground(Color(0.3, 0.3, 0.3)),
                                   Primitive.fontSize(11))

    _addButtonContents = Row([
        _addStyle(Label('+ ')),
        _fStyle(Label('f')),
        _parenStyle(Label('()'))
    ])
    _removeButtonContents = Row([
        _removeStyle(Label('- ')),
        _fStyle(Label('f')),
        _parenStyle(Label('()'))
    ])
class TraceVisualisation (object):
	def __init__(self):
		self._suite = EmbeddedPython2Suite()
		self._code = None
		self._incr = IncrementalValueMonitor()
		self.__change_history__ = None

		self._tableSchema = None
		self._tableView = _TableView()

		self._treeView = _TreeView()


	def __getstate__(self):
		return { 'suite' : self._suite, 'tableView' : self._tableView, 'treeView' : self._treeView }

	def __setstate__(self, state):
		self._suite = state['suite']
		self._tableView = state.get( 'tableView', _TableView() )
		self._treeView = state.get( 'treeView', _TreeView() )
		self._code = None
		self._incr = IncrementalValueMonitor()
		self.__change_history__ = None

		self._tableSchema = None


	def __get_trackable_contents__(self):
		return [ self._suite ]


	def _initTableSchema(self):
		self._tableSchema = _TableSchema()

	def _initTableView(self):
		self._tableView.initialise( self._tableSchema )
		self._incr.onChanged()


	def _initTreeView(self):
		self._treeView.initialise()
		self._incr.onChanged()


	def _registerMonitoredExpression(self, monitoredExpression):
		self._tableSchema.registerMonitoredExpression( monitoredExpression )



	def _logValue(self, monitoredExpression, value):
		self._tableView.logValue( monitoredExpression, value )
		self._treeView.logValue( monitoredExpression, value )


	def _clear(self):
		self._initTableView()
		self._initTreeView()


	def __py_compile_visit__(self, codeGen):
		self._initTableSchema()

		prevSuite = MonitoredExpression._currentSuite
		MonitoredExpression._currentSuite = self

		self._code = codeGen.compileForExecution( self._suite.model )

		MonitoredExpression._currentSuite = prevSuite

		self._initTableView()
		self._initTreeView()


	def __py_exec__(self, _globals, _locals, codeGen):
		tableState = self._tableView.begin()
		treeState = self._treeView.begin()

		exec self._code in _globals, _locals

		self._treeView.end( treeState )
		self._tableView.end( tableState )


	def __py_replacement__(self):
		return deepcopy( self._suite.model['suite'] )


	def __present__(self, fragment, inheritedState):
		def _embeddedDisplayMenu(element, menu):
			def _onClear(item):
				self._clear()

			menu.add( MenuItem.menuItemWithLabel( 'Clear collected values', _onClear ) )

			return False



		self._incr.onAccess()
		suitePres = self._suite

		valuesPres = TabbedBox( [ [ Label( 'Tree' ), self._treeView ],  [ Label( 'Table' ), self._tableView ] ], None )

		contents = Column( [ suitePres, valuesPres ] )
		return ObjectBox( 'Trace visualisation', contents ).withContextMenuInteractor( _embeddedDisplayMenu ).withCommands( _mxCommands )
예제 #21
0
class Console (object):
	class Output (object):
		def __init__(self):
			self._builder = None

		def write(self, text):
			if not ( isinstance( text, str )  or  isinstance( text, unicode ) ):
				raise TypeError, 'argument 1 must be string, not %s' % type( text )
			if self._builder is None:
				self._builder = StringBuilder()
			self._builder.append( text )

		def getText(self):
			if self._builder is not None:
				return self._builder.toString()
			else:
				return None



	def __init__(self, name, showBanner=True):
		self._incr = IncrementalValueMonitor( self )

		self._blocks = []
		self._currentPythonModule = Python2.py25NewModuleAsRoot()
		self._before = []
		self._after = []
		self._module = imp.new_module( name )
		self._showBanner = showBanner
		LoadBuiltins.loadBuiltins( self._module )


	def getBlocks(self):
		self._incr.onAccess()
		return copy( self._blocks )

	def getCurrentPythonModule(self):
		self._incr.onAccess()
		return self._currentPythonModule


	def _commit(self, module, execResult):
		self._blocks.append( ConsoleBlock( module, execResult ) )
		for a in self._after:
			if not Python2.isEmptyTopLevel(a):
				self._before.append( a )
		if not Python2.isEmptyTopLevel(module):
			self._before.append( deepcopy( module ) )
		self._after = []
		self._currentPythonModule = Python2.py25NewModuleAsRoot()
		self._incr.onChanged()

	def backwards(self):
		if len( self._before ) > 0:
			self._after.insert( 0, self._currentPythonModule )
			self._currentPythonModule = self._before.pop()
			self._incr.onChanged()

	def forwards(self):
		if len( self._after ) > 0:
			self._before.append( self._currentPythonModule )
			self._currentPythonModule = self._after[0]
			del self._after[0]
			self._incr.onChanged()


	def assignVariable(self, name, value):
		setattr( self._module, name, value )
		self._blocks.append( ConsoleVarAssignment( name, value ) )
		self._incr.onChanged()



	def execute(self, bEvaluate=True):
		module = self.getCurrentPythonModule()
		if not Python2.isEmptyTopLevel(module):
			execResult = Execution.getResultOfExecutionWithinModule( module, self._module, bEvaluate )
			self._commit( module, execResult )

	def executeModule(self, module, bEvaluate=True):
		if not Python2.isEmptyTopLevel(module):
			execResult = Execution.getResultOfExecutionWithinModule( module, self._module, bEvaluate )
			self._commit( module, execResult )




	def __present__(self, fragment, inheritedState):
		blocks = self.getBlocks()
		currentModule = Python2.python2EditorPerspective.applyTo( self.getCurrentPythonModule() )

		def _onDrop(element, pos, data, action):
			class _VarNameEntryListener (TextEntry.TextEntryListener):
				def onAccept(listenerSelf, entry, text):
					self.assignVariable( text, data.getModel() )
					_finish( entry )

				def onCancel(listenerSelf, entry, text):
					_finish( entry )

			def _finish(entry):
				caret.moveTo( marker )
				dropPromptLive.setLiteralValue( Blank() )

			dropPrompt = _dropPrompt( _VarNameEntryListener() )
			rootElement = element.getRootElement()
			caret = rootElement.getCaret()
			marker = caret.getMarker().copy()
			dropPromptLive.setLiteralValue( dropPrompt )
			rootElement.grabFocus()

			return True



		# Header
		if self._showBanner:
			bannerVersionText = [ _bannerTextStyle.applyTo( NormalText( v ) )   for v in sys.version.split( '\n' ) ]
			helpText1 = Row( [ _bannerHelpKeyTextStyle.applyTo( Label( 'Ctrl+Enter' ) ),
					   _bannerHelpTextStyle.applyTo( Label( ' - execute and evaluate, ' ) ),
					   _bannerHelpKeyTextStyle.applyTo( Label( 'Ctrl+Shift+Enter' ) ),
					   _bannerHelpTextStyle.applyTo( Label( ' - execute only' ) ) ] )
			helpText2 = Row( [ _bannerHelpKeyTextStyle.applyTo( Label( 'Alt+Up' ) ),
					   _bannerHelpTextStyle.applyTo( Label( ' - previous, ' ) ),
					   _bannerHelpKeyTextStyle.applyTo( Label( 'Alt+Down' ) ),
					   _bannerHelpTextStyle.applyTo( Label( ' - next' ) ) ] )
			bannerText = Column( bannerVersionText + [ helpText1, helpText2 ] ).alignHPack()

			banner = _bannerBorder.surround( bannerText )
		else:
			banner = None


		dropDest = ObjectDndHandler.DropDest( FragmentData, _onDrop )

		def _onExecute(element):
			self.execute( True )

		def _onExecuteNoEval(element):
			self.execute( False )

		def _onHistoryPrev(element):
			self.backwards()

		def _onHistoryNext(element):
			self.forwards()

		currentModule = Span( [ currentModule ] )
		currentModule = currentModule.withShortcut( _executeShortcut, _onExecute )
		currentModule = currentModule.withShortcut( _executeNoEvalShortcut, _onExecuteNoEval )
		currentModule = currentModule.withShortcut( _historyPreviousShortcut, _onHistoryPrev )
		currentModule = currentModule.withShortcut( _historyNextShortcut, _onHistoryNext )

		m = _pythonModuleBorderStyle.applyTo( Border( currentModule.alignHExpand() ) ).alignHExpand()
		m = m.withDropDest( dropDest )
		def _ensureCurrentModuleVisible(element, ctx, style):
			element.ensureVisible()
		m = m.withCustomElementAction( _ensureCurrentModuleVisible )

		dropPromptLive = LiveValue( Span( [] ) )
		dropPromptView = dropPromptLive

		consoleColumnContents = [ banner.alignVRefY() ]   if self._showBanner   else []
		if len( blocks ) > 0:
			blockList = _consoleBlockListStyle.applyTo( Column( blocks ) ).alignHExpand()
			consoleColumnContents += [ blockList.alignVRefY(), dropPromptView.alignVRefY(), m.alignVRefY() ]
		else:
			consoleColumnContents += [ dropPromptView.alignVRefY(), m.alignVRefY() ]
		return _consoleStyle.applyTo( Column( consoleColumnContents ) ).alignHExpand().alignVTop()
예제 #22
0
class PathsConfigurationPage (ConfigurationPage):
	def __init__(self):
		super( PathsConfigurationPage, self ).__init__()
		self._pluginPaths = []
		self._libraryPaths = []
		self._incr = IncrementalValueMonitor()
	
	
	def __getstate__(self):
		state = super( PathsConfigurationPage, self ).__getstate__()
		state['pluginPaths'] = self._pluginPaths
		state['libraryPaths'] = self._libraryPaths
		return state
	
	def __setstate__(self, state):
		super( PathsConfigurationPage, self ).__setstate__( state )
		self._pluginPaths = state['pluginPaths']
		try:
			self._libraryPaths = state['libraryPaths']
		except KeyError:
			self._libraryPaths = state['pluginRootPaths']
		self._incr = IncrementalValueMonitor()
	
		
		
	@property
	def pluginPaths(self):
		return self._pluginPaths
	
	@property
	def libraryPaths(self):
		return self._libraryPaths


	
	def getSubjectTitle(self):
		return '[CFG] Paths'
	
	def getTitleText(self):
		return 'Paths Configuration'
	
	def getLinkText(self):
		return 'Paths'
	
	
	def presentPathList(self, pathList):
		def pathItem(index):
			def _onDelete(menuItem):
				del pathList[index]
				self._incr.onChanged()

			def buildContextMenu(element, menu):
				menu.add( MenuItem.menuItemWithLabel( 'Delete', _onDelete ) )
				return True

			return _itemHoverHighlightStyle.applyTo( Label( pathList[index] ) ).withContextMenuInteractor( buildContextMenu )


		def _onNew(hyperlink, event):
			component = hyperlink.getElement().getRootElement().getComponent()
			openDialog = JFileChooser()
			openDialog.setFileSelectionMode( JFileChooser.DIRECTORIES_ONLY )
			response = openDialog.showDialog( component, 'Choose path' )
			if response == JFileChooser.APPROVE_OPTION:
				sf = openDialog.getSelectedFile()
				if sf is not None:
					filename = sf.getPath()
					if filename is not None  and  os.path.isdir( filename ):
						pathList.append( filename )
						self._incr.onChanged()
		
		newLink = Hyperlink( 'NEW', _onNew )
		controls = newLink.pad( 10.0, 5.0 )

		pathPres = Column( [ pathItem( i )   for i in xrange( len( pathList ) ) ] )
		return Column( [ controls, pathPres.padX( 5.0 ) ] )
	
	
	def pathsSection(self, title, pathList):
		pathsPres = self.presentPathList( pathList )
		return Section( SectionHeading2( title ), pathsPres )

	

	def __present_contents__(self, fragment, inheritedState):
		self._incr.onAccess()
		pluginPathsPres = self.pathsSection( 'Plugin paths', self._pluginPaths )
		pluginRootPathsPres = self.pathsSection( 'Library paths', self._libraryPaths )
		return Body( [ pluginPathsPres, pluginRootPathsPres ] )
class GraphVizConfigurationPage(ConfigurationPage):
    def __init__(self):
        super(GraphVizConfigurationPage, self).__init__()
        self._graphVizDir = None
        self._config = None
        self._incr = IncrementalValueMonitor()

    def initPage(self, config):
        super(GraphVizConfigurationPage, self).initPage(config)
        GraphVizConfiguration.setConfigurationPageSubject(self.subject())

    def __getstate__(self):
        state = super(GraphVizConfigurationPage, self).__getstate__()
        state['graphVizDir'] = self._graphVizDir
        return state

    def __setstate__(self, state):
        super(GraphVizConfigurationPage, self).__setstate__(state)
        self._graphVizDir = state['graphVizDir']
        self._config = None
        self._incr = IncrementalValueMonitor()

        self._refreshConfig()

    def _checkedToolPath(self, name):
        path = os.path.join(self._graphVizDir, name + _exeExtension)
        if os.path.exists(path):
            return path
        else:
            return None

    def _setGraphVizDir(self, dir):
        self._graphVizDir = dir
        self._refreshConfig()
        self._incr.onChanged()

    def __isConfigured(self):
        if self._graphVizDir is not None and os.path.isdir(self._graphVizDir):
            dotPath = self._checkedToolPath('dot')
            neatoPath = self._checkedToolPath('neato')
            twopiPath = self._checkedToolPath('twopi')
            circoPath = self._checkedToolPath('circo')
            fdpPath = self._checkedToolPath('fdp')
            sfdpPath = self._checkedToolPath('sfdp')
            osagePath = self._checkedToolPath('osage')
            return dotPath is not None and neatoPath is not None and twopiPath is not None and circoPath is not None and fdpPath is not None and sfdpPath is not None and osagePath is not None
        return False

    def _refreshConfig(self):
        if self._graphVizDir is not None and os.path.isdir(self._graphVizDir):
            dotPath = self._checkedToolPath('dot')
            neatoPath = self._checkedToolPath('neato')
            twopiPath = self._checkedToolPath('twopi')
            circoPath = self._checkedToolPath('circo')
            fdpPath = self._checkedToolPath('fdp')
            sfdpPath = self._checkedToolPath('sfdp')
            osagePath = self._checkedToolPath('osage')
            self._config = GraphVizConfiguration(dotPath, neatoPath, twopiPath,
                                                 circoPath, fdpPath, sfdpPath,
                                                 osagePath)
            GraphVizConfiguration.setInstance(self._config)
        else:
            self._config = None
            GraphVizConfiguration.setInstance(None)
        self._incr.onChanged()

    def getSubjectTitle(self):
        return '[CFG] GraphViz'

    def getTitleText(self):
        return 'GraphViz Configuration'

    def getLinkText(self):
        return 'GraphViz'

    def _presentDir(self):
        def _onSet(hyperlink, event):
            component = hyperlink.getElement().getRootElement().getComponent()
            openDialog = JFileChooser()
            openDialog.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)
            response = openDialog.showDialog(component, 'Choose path')
            if response == JFileChooser.APPROVE_OPTION:
                sf = openDialog.getSelectedFile()
                if sf is not None:
                    filename = sf.getPath()
                    if filename is not None and os.path.isdir(filename):
                        self._graphVizDir = filename
                        self._refreshConfig()
                        self._incr.onChanged()

        dirLabel = Label(
            self._graphVizDir
        ) if self._graphVizDir is not None else self._notSetStyle.applyTo(
            Label('<Not set>'))

        setLink = Hyperlink('CHANGE', _onSet)
        return self._dirBorderStyle.applyTo(
            Border(Row([dirLabel, Spacer(25.0, 0.0), setLink])))

    def _toolLabel(self, name):
        return self._configTableToolNameStyle.applyTo(Label(name))

    def _presentConfig(self):
        if self._config is not None:
            rows = []
            rows.append([SectionHeading3('Tool'), SectionHeading3('Path')])
            rows.append(
                [self._toolLabel('dot'),
                 Label(self._config.getDotPath())])
            rows.append(
                [self._toolLabel('neato'),
                 Label(self._config.getNeatoPath())])
            rows.append(
                [self._toolLabel('twopi'),
                 Label(self._config.getTwopiPath())])
            rows.append(
                [self._toolLabel('circo'),
                 Label(self._config.getCircoPath())])
            rows.append(
                [self._toolLabel('fdp'),
                 Label(self._config.getFdpPath())])
            rows.append(
                [self._toolLabel('sfdp'),
                 Label(self._config.getSfdpPath())])
            rows.append(
                [self._toolLabel('osage'),
                 Label(self._config.getOsagePath())])
            return self._configTableStyle.applyTo(Table(rows)).pad(15.0, 5.0)

    def __present_contents__(self, fragment, inheritedState):
        self._incr.onAccess()

        dirPres = self._presentDir()
        note = NotesText([
            'Note: please choose the location of the GraphViz ',
            EmphSpan('bin'), ' directory.'
        ])
        columnContents = [note, dirPres]
        if self._config is not None:
            columnContents.append(self._presentConfig())
        pathContents = Column(columnContents)
        pathSection = Section(SectionHeading2('GraphViz path'), pathContents)

        downloadText = ''
        if self.__isConfigured():
            downloadText = 'GraphViz appears to be installed on this machine and configured. If it does not work correctly, you may need to install it. You can download it from the '
        else:
            downloadText = 'If GraphViz is not installed on this machine, please install it. You can download it from the '

        downloadLink = Hyperlink('GraphViz homepage',
                                 URI('http://www.graphviz.org/'))
        download = NormalText([downloadText, downloadLink, '.'])
        downloadSec = Section(
            SectionHeading2('GraphViz download/installation'), download)

        return Body([pathSection, downloadSec])

    _dirBorderStyle = StyleSheet.style(
        Primitive.border(
            SolidBorder(1.0, 3.0, 10.0, 10.0, Color(1.0, 0.85, 0.0),
                        Color(1.0, 1.0, 0.85))))
    _notSetStyle = StyleSheet.style(Primitive.fontItalic(True))
    _configTableStyle = StyleSheet.style(Primitive.tableColumnSpacing(10.0))
    _configTableToolNameStyle = StyleSheet.style(
        Primitive.foreground(Color(0.25, 0.0, 0.5)))
예제 #24
0
class ElemAttrs(object):
    """
	XML element attributes

	Implements the Python dictionary interface

	Live object; incremental monitor tracks accesses and changes
	"""
    def __init__(self, attrs=None):
        if attrs is None:
            attrs = {}
        self.__attrs = attrs
        self.__incr = IncrementalValueMonitor()

    def __eq__(self, other):
        if isinstance(other, ElemAttrs):
            return self.__attrs == other.__attrs
        else:
            return NotImplemented

    def __ne__(self, other):
        if isinstance(other, ElemAttrs):
            return self.__attrs != other.__attrs
        else:
            return NotImplemented

    def attrs_dict(self):
        x = {}
        x.update(self.__attrs)
        return x

    def __len__(self):
        self.__incr.onAccess()
        return len(self.__attrs)

    def __getitem__(self, key):
        self.__incr.onAccess()
        return self.__attrs[key]

    def __setitem__(self, key, value):
        self.__incr.onChanged()
        self.__attrs[key] = value

    def __delitem__(self, key):
        self.__incr.onChanged()
        del self.__attrs[key]

    def __contains__(self, key):
        self.__incr.onAccess()
        return key in self.__attrs

    def __iter__(self):
        self.__incr.onAccess()
        for k in self.__attrs.keys():
            self.__incr.onAccess()
            yield k

    def clear(self):
        self.__incr.onChanged()
        self.__attrs.clear()

    def copy(self):
        self.__incr.onAccess()
        return self.__attrs.copy()

    def get(self, key, default=None):
        self.__incr.onAccess()
        return self.__attrs.get(key, default)

    def has_key(self, key):
        self.__incr.onAccess()
        return self.__attrs.has_key(key)

    def keys(self):
        self.__incr.onAccess()
        return self.__attrs.keys()

    def update(self, values):
        self.__incr.onChanged()
        self.__attrs.update(values)

    def __pair(self, kv):
        key, value = kv
        eq = self._punc_style.applyTo(Label('='))
        return Span([
            self._name_style(Label(key)), eq,
            self._value_style(Label(value))
        ])

    def __present__(self, fragment, inh):
        space = Label(' ')
        br = LineBreak()

        items = self.__attrs.items()

        contents = [self.__pair(items[0])]
        for x in items[1:]:
            contents.extend([space, br, self.__pair(x)])
        return Span(contents)

    _punc_style = StyleSheet.style(Primitive.foreground(Color(0.7, 0.7, 0.7)))
    _name_style = StyleSheet.style(Primitive.foreground(Color(0.0, 0.7, 0.3)))
    _value_style = StyleSheet.style(Primitive.foreground(Color(0.7, 0.3, 0.0)))