def style_button(text, on_click, *style_values): sty = StyleSheet.instance.withValues(Primitive.fontFace(Primitive.monospacedFontName), *style_values) return Button(sty.applyTo(Label(text)), on_click)
def assertNotEqual(self, first, second): if not ( first != second ): raise AssertionError, Row( [ _testValueBorder.surround( first ), _comparisonStyle( Label( 'not !=' ) ), _testValueBorder.surround( second ) ] )
def _dropPrompt(varNameTextEntryListener): textEntry = TextEntry( 'var', varNameTextEntryListener ).regexValidated( _varNameRegex, 'Please enter a valid identifier' ) prompt = Label( 'Place object into a variable named: ' ) textEntry.grabCaretOnRealise() textEntry.selectAllOnRealise() return _dropPromptStyle.applyTo( Border( Paragraph( [ prompt.alignVCentre(), textEntry.alignVCentre() ] ).alignHPack() ) )
def ProjectRoot(self, fragment, inheritedState, project):
# Save and Save As
def _onSave(control, buttonEvent):
if document.hasFilename():
document.save()
else:
def handleSaveDocumentAsFn(filename):
document.saveAs(filename)
DocumentManagement.promptSaveDocumentAs(
world,
control.getElement().getRootElement().getComponent(),
handleSaveDocumentAsFn)
def _onSaveAs(control, buttonEvent):
def handleSaveDocumentAsFn(filename):
document.saveAs(filename)
DocumentManagement.promptSaveDocumentAs(
world,
control.getElement().getRootElement().getComponent(),
handleSaveDocumentAsFn, document.getFilename())
def _onReload(control, buttonEvent):
if document.hasFilename():
document.save()
document.reload()
project.reset()
else:
def handleSaveDocumentAsFn(filename):
document.saveAs(filename)
document.reload()
project.reset()
DocumentManagement.promptSaveDocumentAs(
world,
control.getElement().getRootElement().getComponent(),
handleSaveDocumentAsFn)
def _onExport(control, event):
component = control.getElement().getRootElement().getComponent()
openDialog = JFileChooser()
openDialog.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)
response = openDialog.showDialog(component, 'Export')
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):
response = JOptionPane.showOptionDialog(
component,
'Existing content will be overwritten. Proceed?',
'Overwrite existing content',
JOptionPane.YES_NO_OPTION,
JOptionPane.WARNING_MESSAGE, None,
['Overwrite', 'Cancel'], 'Cancel')
if response == JFileChooser.APPROVE_OPTION:
exc = None
try:
project.export(filename)
except:
exc = JythonException.getCurrentException()
if exc is not None:
BubblePopup.popupInBubbleAdjacentTo(
DefaultPerspective.instance(exc),
control.getElement(), Anchor.BOTTOM, True,
True)
# Python package name
class _PythonPackageNameListener(EditableLabel.EditableLabelListener):
def onTextChanged(self, editableLabel, text):
if text != '':
project.pythonPackageName = text
else:
project.pythonPackageName = None
# Project index
def _addPackage(menuItem):
project.append(ProjectPackage('NewPackage'))
def _addPage(page):
project.append(page)
def _projectIndexContextMenuFactory(element, menu):
menu.add(MenuItem.menuItemWithLabel('New package', _addPackage))
newPageMenu = PageData.newPageMenu(_addPage)
importPageMenu = PageData.importPageMenu(
element.getRootElement().getComponent(), _addPage)
menu.add(
MenuItem.menuItemWithLabel(
'New page', newPageMenu,
MenuItem.SubmenuPopupDirection.RIGHT))
menu.add(
MenuItem.menuItemWithLabel(
'Import page', importPageMenu,
MenuItem.SubmenuPopupDirection.RIGHT))
return True
# Get some initial variables
document = fragment.subject.document
world = fragment.subject.world
# Title
title = TitleBar(document.getDocumentName())
# Controls for 'save' and 'save as'
saveExportHeader = SectionHeading1('Save/export')
saveButton = Button.buttonWithLabel('Save', _onSave)
saveAsButton = Button.buttonWithLabel('Save as', _onSaveAs)
reloadButton = Button.buttonWithLabel('Save and reload', _onReload)
reloadButton = AttachTooltip(
reloadButton,
'Saves and reloads the project from scratch\nCauses all embedded objects to be re-created.'
)
exportButton = Button.buttonWithLabel('Export', _onExport)
exportButton = AttachTooltip(
exportButton,
'Exports project contents to text files where possible.')
saveBox = Row([
saveButton.padX(10.0),
Spacer(30.0, 0.0),
saveAsButton.padX(10.0),
Spacer(30.0, 0.0),
reloadButton.padX(10.0),
Spacer(50.0, 0.0),
exportButton.padX(10.0)
]).alignHLeft()
saveExportSection = Section(saveExportHeader, saveBox)
#
# Project Section
#
# Python package name
notSet = _pythonPackageNameNotSetStyle.applyTo(Label('<not set>'))
pythonPackageNameLabel = EditableLabel(
project.pythonPackageName, notSet,
_PythonPackageNameListener()).regexValidated(
_pythonPackageNameRegex,
'Please enter a valid dotted identifier')
pythonPackageNameLabel = AttachTooltip( pythonPackageNameLabel, 'The root python package name is the name under which the contents of the project can be imported using import statements within the project.\n' + \
'If this is not set, pages from this project cannot be imported.', False )
pythonPackageNameRow = Form.Section(
'Root Python package name',
'Pages will not be importable unless this is set',
pythonPackageNameLabel)
# Clear imported modules
def _onReset(button, event):
project.reset()
modules = document.unloadAllImportedModules()
heading = SectionHeading2('Unloaded modules:')
modules = Column([Label(module) for module in modules])
report = Section(heading, modules)
BubblePopup.popupInBubbleAdjacentTo(report, button.getElement(),
Anchor.BOTTOM, True, True)
resetButton = Button.buttonWithLabel('Reset', _onReset)
resetButton = AttachTooltip(
resetButton,
'Unloads all modules that were imported from this project from the Python module cache. This way they can be re-imported, allowing modifications to take effect.'
)
resetRow = Form.Section('Reset', 'Unload project modules', resetButton)
projectSection = Form('Project', [pythonPackageNameRow, resetRow])
# Project index
indexHeader = SectionHeading1('Index')
nameElement = _projectIndexNameStyle.applyTo(Label('Project root'))
nameBox = _itemHoverHighlightStyle.applyTo(nameElement.alignVCentre())
nameBox = nameBox.withContextMenuInteractor(
_projectIndexContextMenuFactory)
nameBox = _ProjectTreeController.instance.item(project, nameBox)
nameBox = AttachTooltip( nameBox, 'Right click to access context menu, from which new pages and packages can be created.\n' + \
'A page called index at the root will appear instead of the project page. A page called __startup__ will be executed at start time.', False )
itemsBox = Column(project[:]).alignHExpand()
itemsBox = _ProjectTreeController.instance.editableList(
project, itemsBox)
contentsView = Column([
nameBox.alignHExpand(),
itemsBox.padX(_packageContentsIndentation, 0.0).alignHExpand()
])
indexSection = Section(indexHeader, contentsView)
def _onBuildJar(button, event):
_buildProjectJar(button.element, document)
buildJarButton = Button.buttonWithLabel('Build JAR', _onBuildJar)
jarRow = Form.Section('Build executable app',
'Export the project as an executable JAR',
buildJarButton)
packagingSection = Form('Packaging', [jarRow])
indexTip = TipBox([
NormalText([
StrongSpan('Index: '),
'Larch projects act like Python programs. Packages act as directories/packages and pages act as Python source files. Pages can import code from one another as if they are modules.'
]),
NormalText([
'New pages and packages can be created by right clicking on the entries in the index or on ',
EmphSpan('Project root'),
' (they will highlight as you hover over them).'
]),
NormalText([
StrongSpan('Front and startup pages: '),
'If a page is set as the front page it will appear instead of the project page. In these cases, the project page can still be reached using the links in the location bar at the top of the window.'
]),
'If a page is set as the startup page, code within it will be executed before all other pages. This can be used for registering editor extensions.',
'To set a page as the front page or the startup page, right-click on it to show its context menu and choose the appropriate option.'
], 'larchcore.worksheet.worksheeteditor')
# The page
head = Head([title])
body = Body([
saveExportSection, projectSection, indexSection, packagingSection,
indexTip
]).alignHPack()
return StyleSheet.style(Primitive.editable(False)).applyTo(
Page([head, body]))
from BritefuryJ.Editor.List import EditableListController
from Britefury.Util.LiveList import LiveList
from LarchCore.Languages.Python2 import Schema as Py
from LarchTools.PythonTools.GUIEditor.DataModel import ChildField, ChildListField
from LarchTools.PythonTools.GUIEditor.Component import GUIComponent
from LarchTools.PythonTools.GUIEditor.ComponentPalette import PaletteComponentDrag
#
#Sequential components:
_emptyStyle = StyleSheet.style(Primitive.fontItalic(True),
Primitive.fontSize(10),
Primitive.foreground(Color(0.4, 0.4, 0.4)))
emptyLabel = _emptyStyle(Label('<empty>'))
class GUIBranchComponent(GUIComponent):
def removeChild(self, child):
raise NotImplementedError, 'abstract'
def getNextSiblingOf(self, child):
raise NotImplementedError, 'abstract'
class GUIUnaryBranchComponent(GUIBranchComponent):
child = ChildField()
def removeChild(self, child):
assert child is self.child.node
def _testValue(self, kind, data, excType=None): self._actual.setLiteralValue( ( kind, data ) ) expected = self._expected.getStaticValue() if expected is not None: expectedKind, expectedData = expected if kind == expectedKind: if expectedKind == 'exception': if excType == expectedData: self.__result.setLiteralValue( _resultPass ) else: title = _resultFailStyle( Label( 'FAIL' ) ) heading = Label( 'Expected exception of type %s, got:' % expectedData.__name__ ) res = Column( [ title, heading, data ] ) self.__result.setLiteralValue( res ) elif expectedKind == 'value': if data == expectedData: self.__result.setLiteralValue( _resultPass ) else: title = _resultFailStyle( Label( 'FAIL' ) ) heading1 = Label( 'Expected:' ) heading2 = Label( 'Got:' ) res = Column( [ title, heading1, expectedData, heading2, data ] ) self.__result.setLiteralValue( res ) else: raise TypeError, 'unknown expected result kind %s' % expectedKind else: resContents = [ _resultFailStyle( Label( 'FAIL' ) ) ] if expectedKind == 'exception': resContents.append( Label( 'Expected exception of type %s:' % expectedData.__name__ ) ) elif expectedKind == 'value': resContents.append( Label( 'Expected:' ) ) resContents.append( expectedData ) else: raise TypeError, 'unknown expected result kind %s' % expectedKind if kind == 'exception': resContents.append( Label( 'Got exception:' ) ) resContents.append( data ) elif kind == 'value': resContents.append( Label( 'Expected:' ) ) resContents.append( data ) else: raise TypeError, 'unknown result kind %s' % kind self.__result.setLiteralValue( Column( resContents ) ) else: def _onFix(button, event): if kind == 'exception': self._expected.setLiteralValue( ( kind, excType ) ) elif kind == 'value': self._expected.setLiteralValue( ( kind, data ) ) else: raise TypeError, 'unknown result kind %s' % kind self.__result.setLiteralValue( _resultNone ) fixButton = Button.buttonWithLabel( 'Set expected result', _onFix ) title = Label( 'No expected result, received:' ) self.__result.setLiteralValue( Column( [ title, Pres.coerce( data ).pad( 5.0, 0.0, 5.0, 5.0 ), fixButton ] ).alignHPack().alignVTop() )
def apply_cmd_style(p):
prompt = _cmd_prompt_style.applyTo(Label('$ '))
return _cmd_style.applyTo(RichSpan([prompt, p]))
def assertGreater(self, first, second): if not ( first > second ): raise AssertionError, Row( [ _testValueBorder.surround( first ), _comparisonStyle( Label( 'not >' ) ), _testValueBorder.surround( second ) ] )
Color(0.9, 0.9, 0.9))
_fragContentHighlighter = ElementHighlighter(
FilledOutlinePainter(Color(0.0, 1.0, 0.0, 0.1), Color(0.0, 0.5, 0.0, 0.5)))
_objectKindStyleJava = StyleSheet.style(
Primitive.fontSize(10), Primitive.foreground(Color(0.0, 0.0, 0.5)))
_objectKindStylePython = StyleSheet.style(
Primitive.fontSize(10), Primitive.foreground(Color(0.0, 0.5, 0.0)))
_objectKindStyleDocModel = StyleSheet.style(
Primitive.fontSize(10), Primitive.foreground(Color(0.5, 0.5, 0.5)))
_consoleStyle = StyleSheet.style(Primitive.editable(True),
Primitive.selectable(True))
_inspectorStyle = StyleSheet.style(Primitive.editable(False),
Primitive.selectable(False))
_objectKindJava = _objectKindStyleJava(Label('Java'))
_objectKindPython = _objectKindStylePython(Label('Python'))
_objectKindDocModel = _objectKindStyleDocModel(Label('DocModel'))
_objectKindMap = {
TypeUtils.ObjectKind.JAVA: _objectKindJava,
TypeUtils.ObjectKind.PYTHON: _objectKindPython,
TypeUtils.ObjectKind.DOCMODEL: _objectKindDocModel,
}
class _FragmentSelectorEntryInteractor(HoverElementInteractor,
PushElementInteractor):
def __init__(self, selectorEntry, fragmentElement):
self._selectorEntry = selectorEntry
self._fragmentElement = fragmentElement
def assertNotIn(self, first, second): if not ( first not in second ): raise AssertionError, Row( [ _testValueBorder.surround( first ), _comparisonStyle( Label( 'in' ) ), _testValueBorder.surround( second ) ] )
def assertNotIsInstance(self, first, second): if isinstance( first, second ): raise AssertionError, Row( [ _testValueBorder.surround( first ), _comparisonStyle( Label( 'is instance of' ) ), _testValueBorder.surround( second ) ] )
def assertIsNot(self, first, second): if not ( first is not second ): raise AssertionError, Row( [ _testValueBorder.surround( first ), _comparisonStyle( Label( 'is' ) ), _testValueBorder.surround( second ) ] )
def assertFalse(self, first): if first: raise AssertionError, Row( [ _comparisonStyle( Label( 'Not False' ) ) ] )
def assertTrue(self, first): if not first: raise AssertionError, Row( [ _comparisonStyle( Label( 'Not True' ) ) ] )
def _toolLabel(self, name):
return self._configTableToolNameStyle.applyTo(Label(name))
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('()'))
])
from BritefuryJ.StyleSheet import StyleSheet from Britefury.Util.LiveList import LiveList from Britefury.Util.UniqueNameTable import UniqueNameTable from BritefuryJ.Util.Jython import JythonException from LarchCore.Languages.Python2.PythonCommands import EmbeddedStatementAtCaretAction, chainActions from LarchCore.Languages.Python2.Embedded import EmbeddedPython2Suite from LarchCore.Languages.Python2 import Schema from LarchTools.PythonTools.InlineTest.InlineTest import AbstractInlineTest, inlineTestCommandSet _resultFailStyle = StyleSheet.style( Primitive.foreground( Color( 0.5, 0.4, 0.0 ) ) ) _resultPass = StyleSheet.style( Primitive.foreground( Color( 0.0, 0.5, 0.0 ) ) ).applyTo( Label( 'PASS' ) ) _resultNone = StyleSheet.style( Primitive.foreground( Color( 0.4, 0.4, 0.4 ) ) ).applyTo( Label( 'NONE' ) ) class AbstractInlineTestTableRow (object): def __init__(self): self.__testTable = None self.__result = LiveValue( _resultNone ) self.__testMethodName = None # Form: either ( 'value', value ) or ( 'exception', exceptionType ) or None self._expected = TrackedLiveValue( None ) self._actual = TrackedLiveValue( None ) self.__change_history__ = None
def _editUIFormSections(self):
text = Form.SmallSection(
'Text', None,
self.text.editUI(
lambda live: TextEntry.textEntryCommitOnChange(live)))
superSections = super(GUILabel, self)._editUIFormSections()
return [text] + superSections
def __component_py_evalmodel__(self, codeGen):
label = codeGen.embeddedValue(Label)
return Py.Call(target=label,
args=[self.text.__py_evalmodel__(codeGen)])
_labelItem = paletteItem(Label('Label'), lambda: GUILabel(text='Label'))
class GUIStaticText(GUILeafComponent):
componentName = 'Static text'
text = TypedEvalField(str, 'Label')
def _presentLeafContents(self, fragment, inheritedState):
return StaticText(self.text.getValueForEditor())
def _editUIFormSections(self):
text = Form.SmallSection(
'Text', None,
self.text.editUI(
lambda live: TextEntry.textEntryCommitOnChange(live)))
def error_message(message):
return _error_border.surround(_error_style(Label(message)))
def _presentLeafContents(self, fragment, inheritedState):
return Label(self.text.getValueForEditor())
def label(): return _liveLabelStyle(Label(str(live.getValue())))
_pythonModuleBorderStyle = StyleSheet.style( Primitive.border( SolidBorder( 1.5, 5.0, 10.0, 10.0, Color( 0.65, 0.65, 0.65 ), Color.WHITE ) ) )
_dropPromptStyle = StyleSheet.style( Primitive.border( SolidBorder( 1.0, 3.0, 10.0, 10.0, Color( 0.0, 0.8, 0.0 ), None ) ) )
_varAssignVarNameStyle = StyleSheet.style( Primitive.fontItalic( True ), Primitive.foreground( Color( 0.0, 0.0, 0.5 ) ) )
_varAssignTypeNameStyle = StyleSheet.style( Primitive.foreground( Color( 0.3, 0.0, 0.3 ) ) )
_varAssignJavaKindStyle = StyleSheet.style( Primitive.foreground( Color( 0.0, 0.0, 0.4 ) ), Primitive.fontItalic( True ) )
_varAssignPythonKindStyle = StyleSheet.style( Primitive.foreground( Color( 0.0, 0.4, 0.0 ) ), Primitive.fontItalic( True ) )
_varAssignDocModelKindStyle = StyleSheet.style( Primitive.foreground( Color( 0.4, 0.4, 0.4 ) ), Primitive.fontItalic( True ) )
_varAssignMsgStyle = StyleSheet.style( Primitive.foreground( Color( 0.0, 0.125, 0.0 ) ) )
_consoleBlockListStyle = StyleSheet.style( Primitive.columnSpacing( 5.0 ) )
_consoleStyle = StyleSheet.style( Primitive.columnSpacing( 9.0 ) )
_objectKindJava = _varAssignJavaKindStyle( Label( 'Java object' ) )
_objectKindPython = _varAssignPythonKindStyle( Label( 'Python object' ) )
_objectKindDocModel = _varAssignDocModelKindStyle( Label( 'DocModel object' ) )
_objectKindMap = {
TypeUtils.ObjectKind.JAVA : _objectKindJava,
TypeUtils.ObjectKind.PYTHON : _objectKindPython,
TypeUtils.ObjectKind.DOCMODEL : _objectKindDocModel,
}
_varNameRegex = Pattern.compile( '[a-zA-Z_][a-zA-Z0-9_]*' )
def Page(self, fragment, inheritedState, page):
root = page.rootNode
if root is None:
raise RuntimeError, 'No root node'
isFrontPage = root.frontPage is page
isStartupPage = root.startupPage is page
class _RenameListener(TextEntry.TextEntryListener):
def onAccept(self, textEntry, text):
page.name = text
def onCancel(self, textEntry, originalText):
nameLive.setLiteralValue(nameBox)
def _onRename(menuItem):
textEntry = TextEntry(page.name, _RenameListener()).regexValidated(
_nameRegex, 'Please enter a valid identifier')
textEntry.grabCaretOnRealise()
nameLive.setLiteralValue(textEntry)
def _onDelete(menuItem):
if page.parent is not None:
page.parent.remove(page)
def _onClearFrontPage(menuItem):
root.frontPage = None
def _onSetAsFrontPage(menuItem):
root.frontPage = page
def _onClearStartupPage(menuItem):
root.startupPage = None
def _onSetAsStartupPage(menuItem):
root.startupPage = page
def _pageContextMenuFactory(element, menu):
menu.add(MenuItem.menuItemWithLabel('Rename', _onRename))
menu.add(HSeparator())
menu.add(MenuItem.menuItemWithLabel('Delete', _onDelete))
menu.add(HSeparator())
if isFrontPage:
menu.add(
MenuItem.menuItemWithLabel('Clear front page',
_onClearFrontPage))
else:
menu.add(
MenuItem.menuItemWithLabel('Set as front page',
_onSetAsFrontPage))
if isStartupPage:
menu.add(
MenuItem.menuItemWithLabel('Clear startup page',
_onClearStartupPage))
else:
menu.add(
MenuItem.menuItemWithLabel('Set as startup page',
_onSetAsStartupPage))
return True
pageSubject = fragment.subject._pageSubject(page)
link = Hyperlink(page.name, pageSubject)
link = link.withContextMenuInteractor(_pageContextMenuFactory)
nameBox = _itemHoverHighlightStyle.applyTo(Row([link]))
nameBox = _ProjectTreeController.instance.item(page, nameBox)
nameBox = nameBox.withDragSource(_linkDragSource)
nameBox = AttachTooltip(
nameBox,
'Click to enter page.\nRight click to access context menu.', False)
nameLive = LiveValue(nameBox)
if isFrontPage or isStartupPage:
notes = []
if isFrontPage:
notes.append(
_frontPageNoteBorder.surround(
_frontPageNoteStyle.applyTo(Label('Front page'))))
if isStartupPage:
notes.append(
_startupPageNoteBorder.surround(
_startupPageNoteStyle.applyTo(Label('Startup page'))))
notesPres = _notesRowStyle.applyTo(Row(notes))
pagePres = Row([nameLive, notesPres.padX(_notesGap, 0.0)])
else:
pagePres = nameLive
return pagePres
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()
displayedText = self.displayedText.value
return _evalLabelStyle.applyTo(Label('=<' + displayedText + '>'))
def _editUIFormSections(self):
expr = Form.SmallSection('Expression', None, self.expr.editUI())
displayedText = Form.SmallSection(
'Displayed text', None,
TextEntry.textEntryCommitOnChange(self.displayedText.live))
superSections = super(GUIEval, self)._editUIFormSections()
return [expr, displayedText] + superSections
def __component_py_evalmodel__(self, codeGen):
return self.expr.expr.model
_evalItem = paletteItem(_evalItemStyleF(Label('Eval')), lambda: GUIEval())
class GUILiveEval(GUIEval):
componentName = 'Live Eval'
def _presentLeafContents(self, fragment, inheritedState):
displayedText = self.displayedText.value
if displayedText != '':
return _liveEvalLabelStyle.applyTo(
Label('=<' + displayedText + '>...'))
else:
return self.expr.editUI()
def __component_py_evalmodel__(self, codeGen):
liveFun = codeGen.embeddedValue(LiveFunction)
from BritefuryJ.Parser.Utils import Tokens from BritefuryJ.StyleSheet import StyleSheet from Britefury.Util.UniqueNameTable import UniqueNameTable from BritefuryJ.Util.Jython import JythonException from LarchCore.Languages.Python2.PythonCommands import pythonCommandSet, EmbeddedStatementAtCaretAction, WrapSelectedStatementRangeInEmbeddedObjectAction, chainActions from LarchCore.Languages.Python2.Embedded import EmbeddedPython2Suite from LarchCore.Languages.Python2 import Schema _nameBorder = SolidBorder( 1.0, 2.0, 5.0, 5.0, Color( 0.6, 0.6, 0.6 ), Color( 0.95, 0.95, 0.95 ) ) _notSet = StyleSheet.style( Primitive.fontItalic( True ) )( Label( 'not set' ) ) _testValueBorder = SolidBorder( 1.5, 2.5, 4.0, 4.0, Color( 0.75, 0.0, 0.0 ), None ) _comparisonStyle = StyleSheet.style( Primitive.fontBold( True ), Primitive.foreground( Color( 0.75, 0.0, 0.0 ) ) ) class TestCase (object): def assertEqual(self, first, second): if not ( first == second ): raise AssertionError, Row( [ _testValueBorder.surround( first ), _comparisonStyle( Label( 'not ==' ) ), _testValueBorder.surround( second ) ] )