class GraphicsManager(Group):
previousState = None
def __init__(self, posSize,
isSidebearingsActive,
areGroupsShown,
areCollisionsShown,
isKerningDisplayActive,
areVerticalLettersDrawn,
isCorrectionActive,
isMetricsActive,
isColorsActive,
callback):
super(GraphicsManager, self).__init__(posSize)
self.isKerningDisplayActive = isKerningDisplayActive
self.areVerticalLettersDrawn = areVerticalLettersDrawn
self.areGroupsShown = areGroupsShown
self.areCollisionsShown = areCollisionsShown
self.isSidebearingsActive = isSidebearingsActive
self.isCorrectionActive = isCorrectionActive
self.isMetricsActive = isMetricsActive
self.isColorsActive = isColorsActive
self.callback = callback
self.ctrlWidth, self.ctrlHeight = posSize[2], posSize[3]
jumping_Y = 0
self.ctrlCaption = TextBox((0, jumping_Y, self.ctrlWidth, vanillaControlsSize['TextBoxRegularHeight']),
'Display options:')
jumping_Y = vanillaControlsSize['TextBoxRegularHeight'] + MARGIN_VER/2.
indent = 16
self.showKerningCheck = CheckBox((indent, jumping_Y, self.ctrlWidth-indent, vanillaControlsSize['CheckBoxRegularHeight']),
'show kerning',
value=self.isKerningDisplayActive,
callback=self.showKerningCheckCallback)
self.showKerningHiddenButton = Button((0,self.ctrlHeight+40,0,0),
'hidden kerning button',
callback=self.showKerningHiddenButtonCallback)
# self.showKerningHiddenButton.show(False)
self.showKerningHiddenButton.bind('k', ['command'])
jumping_Y += vanillaControlsSize['CheckBoxRegularHeight']
self.showGroupsCheck = CheckBox((indent, jumping_Y, self.ctrlWidth-indent, vanillaControlsSize['CheckBoxRegularHeight']),
'show groups',
value=self.areGroupsShown,
callback=self.showGroupsCheckCallback)
jumping_Y += vanillaControlsSize['CheckBoxRegularHeight']
self.showCollisionsCheck = CheckBox((indent, jumping_Y, self.ctrlWidth-indent, vanillaControlsSize['CheckBoxRegularHeight']),
'show pair collision',
value=self.areCollisionsShown,
callback=self.showCollisionsCheckCallback)
jumping_Y += vanillaControlsSize['CheckBoxRegularHeight']
self.showSidebearingsCheck = CheckBox((indent, jumping_Y, self.ctrlWidth-indent, vanillaControlsSize['CheckBoxRegularHeight']),
'show sidebearings',
value=self.isSidebearingsActive,
callback=self.showSidebearingsCheckCallback)
jumping_Y += vanillaControlsSize['CheckBoxRegularHeight']
self.showCorrectionCheck = CheckBox((indent, jumping_Y, self.ctrlWidth-indent, vanillaControlsSize['CheckBoxRegularHeight']),
'show corrections amount',
value=self.isCorrectionActive,
callback=self.showCorrectionCheckCallback)
jumping_Y += vanillaControlsSize['CheckBoxRegularHeight']
self.showColorsCheck = CheckBox((indent, jumping_Y, self.ctrlWidth-indent, vanillaControlsSize['CheckBoxRegularHeight']),
'show color bars',
value=self.isColorsActive,
callback=self.showColorsCheckCallback)
jumping_Y += vanillaControlsSize['CheckBoxRegularHeight']
self.showMetricsCheck = CheckBox((indent, jumping_Y, self.ctrlWidth-indent, vanillaControlsSize['CheckBoxRegularHeight']),
'show metrics',
value=self.isMetricsActive,
callback=self.showMetricsCheckCallback)
jumping_Y += vanillaControlsSize['CheckBoxRegularHeight']
self.verticalLettersCheck = CheckBox((indent, jumping_Y, self.ctrlWidth-indent, vanillaControlsSize['CheckBoxRegularHeight']),
'show vertical letters',
value=self.areGroupsShown,
callback=self.verticalLettersCheckCallback)
def set(self, isKerningDisplayActive,
areVerticalLettersDrawn,
areGroupsShown,
areCollisionsShown,
isSidebearingsActive,
isCorrectionActive,
isMetricsActive,
isColorsActive):
# update attributes
self.isKerningDisplayActive = isKerningDisplayActive
self.areVerticalLettersDrawn = areVerticalLettersDrawn
self.areGroupsShown = areGroupsShown
self.areCollisionsShown = areCollisionsShown
self.isSidebearingsActive = isSidebearingsActive
self.isCorrectionActive = isCorrectionActive
self.isMetricsActive = isMetricsActive
self.isColorsActive = isColorsActive
# aligning controls
self.showKerningCheck.set(self.isKerningDisplayActive)
self.showGroupsCheck.set(self.areGroupsShown)
self.showCollisionsCheck.set(self.areCollisionsShown)
self.showSidebearingsCheck.set(self.isSidebearingsActive)
self.showCorrectionCheck.set(self.isCorrectionActive)
self.showColorsCheck.set(self.isColorsActive)
self.showMetricsCheck.set(self.isMetricsActive)
self.verticalLettersCheck.set(self.areVerticalLettersDrawn)
def get(self):
return (self.isKerningDisplayActive,
self.areVerticalLettersDrawn,
self.areGroupsShown,
self.areCollisionsShown,
self.isSidebearingsActive,
self.isCorrectionActive,
self.isMetricsActive,
self.isColorsActive)
def switchControls(self, value):
self.showKerningCheck.enable(value)
self.showSidebearingsCheck.enable(value)
self.showGroupsCheck.enable(value)
self.showCorrectionCheck.enable(value)
self.showMetricsCheck.enable(value)
self.showColorsCheck.enable(value)
self.showCollisionsCheck.enable(value)
self.verticalLettersCheck.enable(value)
def showKerningCheckCallback(self, sender):
self.isKerningDisplayActive = bool(sender.get())
self.callback(self)
def showGroupsCheckCallback(self, sender):
self.areGroupsShown = bool(sender.get())
self.callback(self)
def verticalLettersCheckCallback(self, sender):
self.areVerticalLettersDrawn = bool(sender.get())
self.callback(self)
def showCollisionsCheckCallback(self, sender):
self.areCollisionsShown = bool(sender.get())
self.callback(self)
def showKerningHiddenButtonCallback(self, sender):
self.isKerningDisplayActive = not self.isKerningDisplayActive
self.showKerningCheck.set(self.isKerningDisplayActive)
self.callback(self)
def showSidebearingsCheckCallback(self, sender):
self.isSidebearingsActive = bool(sender.get())
self.callback(self)
def showCorrectionCheckCallback(self, sender):
self.isCorrectionActive = bool(sender.get())
self.callback(self)
def showMetricsCheckCallback(self, sender):
self.isMetricsActive = bool(sender.get())
self.callback(self)
def showColorsCheckCallback(self, sender):
self.isColorsActive = bool(sender.get())
self.callback(self)
class ParameterSliderTextInput(Group):
'''
Custom Vanilla object consisting mainly of a Slider & and text input linked together (through a parameter object)
'''
def __init__(self, parameter, posSize, title=None, callback=None):
super(ParameterSliderTextInput, self).__init__(posSize)
self.parameter = parameter
self.callback = callback
editTextPosSize = (-65, 0, 40, 22)
if title is None:
sliderPosSize = (5, 3, -80, 15)
elif title is not None:
title = title.capitalize()
sliderPosSize = (70, 3, -80, 15)
self.title = TextBox((0, 3, 65, 30), title, sizeStyle='small')
if parameter.dissociable:
editTextPosSize = (-65, 0, 40, 22)
self.checkBox = CheckBox((-22, 5, 22, 25),
u'∞',
callback=self.setFree,
value=True,
sizeStyle='mini')
self.slider = Slider(sliderPosSize,
minValue=parameter.limits[0],
maxValue=parameter.limits[1],
value=parameter.value,
callback=self.valueInput,
sizeStyle='small')
self.textInput = EditText(editTextPosSize,
str(parameter.value),
callback=self.valueInput,
continuous=False,
sizeStyle='small')
self.parameter.bind(self)
def get(self):
return self.parameter.get()
def enable(self, b):
self.slider.enable(b)
self.textInput.enable(b)
if hasattr(self, checkBox):
self.checkBox.enable(b)
def valueInput(self, sender):
value = sender.get()
parameter = self.parameter
if value == 'R':
parameter.reset()
parameter.update()
if self.callback is not None:
self.callback(self)
return
elif value != '*':
parameter.setInput(value, sender=sender)
parameter.update()
if self.callback is not None:
self.callback(self)
def update(self, sender):
value = self.parameter.get()
self.textInput.set(str(value))
if (value != '*'):
self.slider.set(value)
if hasattr(self, 'checkBox'):
free = self.parameter.hasMaster
self.checkBox.set(free)
def setFree(self, sender):
value = not bool(sender.get())
self.parameter.setFree(value)
class ParameterSliderTextInput(Group):
'''
Custom Vanilla object consisting mainly of a Slider & and text input linked together (through a parameter object)
'''
def __init__(self, parameter, posSize, title=None, callback=None):
super(ParameterSliderTextInput, self).__init__(posSize)
self.parameter = parameter
self.callback = callback
editTextPosSize = (-45, 0, 45, 22)
if title is None:
sliderPosSize = (5, 3, -80, 15)
elif title is not None:
if len(title) > 15:
title = '{0}.'.format(title[:16])
title = title.capitalize()
sliderPosSize = (120, 3, -55, 15)
self.title = TextBox((0, 3, 115, 30), title, sizeStyle='small')
if parameter.dissociable:
editTextPosSize = (-65, 0, 40, 22)
self.checkBox = CheckBox((-22, 5, 22, 25), u'∞', callback=self.setFree, value=True, sizeStyle='mini')
self.slider = Slider(sliderPosSize, minValue=parameter.limits[0], maxValue=parameter.limits[1], value=parameter.value, callback=self.valueInput, sizeStyle='small')
self.textInput = EditText(editTextPosSize, str(parameter.value), callback=self.valueInput, continuous=False, sizeStyle='small')
self.parameter.bind(self)
def get(self):
return self.parameter.get()
def enable(self, b):
self.slider.enable(b)
self.textInput.enable(b)
if hasattr(self, checkBox):
self.checkBox.enable(b)
def valueInput(self, sender):
value = sender.get()
parameter = self.parameter
if value == 'R':
parameter.reset()
parameter.update()
if self.callback is not None:
self.callback(self)
return
elif value != '*':
parameter.setInput(value, sender=sender)
parameter.update()
if self.callback is not None:
self.callback(self)
def update(self, sender):
value = self.parameter.get()
self.textInput.set(str(value))
if (value != '*'):
self.slider.set(value)
if hasattr(self, 'checkBox'):
free = self.parameter.hasMaster
self.checkBox.set(free)
def setFree(self, sender):
value = not bool(sender.get())
self.parameter.setFree(value)
class ParameterSliderTextInput(Group):
"""
Custom Vanilla object consisting mainly of a Slider & and text input linked together (through a parameter object)
"""
def __init__(self, parameter, posSize, title=None, callback=None):
super(ParameterSliderTextInput, self).__init__(posSize)
self.parameter = parameter
self.callback = callback
editTextPosSize = (-65, 0, 40, 22)
if title is None:
sliderPosSize = (5, 3, -80, 15)
elif title is not None:
title = title.capitalize()
sliderPosSize = (70, 3, -80, 15)
self.title = TextBox((0, 3, 65, 30), title, sizeStyle="small")
if parameter.dissociable:
editTextPosSize = (-65, 0, 40, 22)
self.checkBox = CheckBox((-22, 5, 22, 25), u"∞", callback=self.setFree, value=True, sizeStyle="mini")
self.slider = Slider(
sliderPosSize,
minValue=parameter.limits[0],
maxValue=parameter.limits[1],
value=parameter.value,
callback=self.valueInput,
sizeStyle="small",
)
self.textInput = EditText(
editTextPosSize, str(parameter.value), callback=self.valueInput, continuous=False, sizeStyle="small"
)
self.parameter.bind(self)
def get(self):
return self.parameter.get()
def enable(self, b):
self.slider.enable(b)
self.textInput.enable(b)
if hasattr(self, checkBox):
self.checkBox.enable(b)
def valueInput(self, sender):
value = sender.get()
parameter = self.parameter
if value == "R":
parameter.reset()
parameter.update()
if self.callback is not None:
self.callback(self)
return
elif value != "*":
parameter.setInput(value, sender=sender)
parameter.update()
if self.callback is not None:
self.callback(self)
def update(self, sender):
value = self.parameter.get()
self.textInput.set(str(value))
if value != "*":
self.slider.set(value)
if hasattr(self, "checkBox"):
free = self.parameter.hasMaster
self.checkBox.set(free)
def setFree(self, sender):
value = not bool(sender.get())
self.parameter.setFree(value)
class JoystickController(Group):
lastEvent = None
keyboardCorrection = 0
def __init__(self, posSize,
fontObj,
isSymmetricalEditingOn,
isSwappedEditingOn,
isVerticalAlignedEditingOn,
autoSave,
autoSaveSpan,
activePair,
callback):
super(JoystickController, self).__init__(posSize)
self.fontObj = fontObj
self.activePair = activePair
self.isSymmetricalEditingOn = isSymmetricalEditingOn
self.isSwappedEditingOn = isSwappedEditingOn
self.isVerticalAlignedEditingOn = isVerticalAlignedEditingOn
self.autoSave = autoSave
self.autoSaveSpan = autoSaveSpan
self.callback = callback
buttonSide = 36
self.ctrlWidth, self.ctrlHeight = posSize[2], posSize[3]
self.jumping_X = buttonSide/2.
self.jumping_Y = 0
self.minusMajorCtrl = SquareButton((self.jumping_X, self.jumping_Y, buttonSide, buttonSide),
"{:+d}".format(MAJOR_STEP),
sizeStyle='small',
callback=self.minusMajorCtrlCallback)
self.minusMajorCtrl.bind(*MINUS_MAJOR_SHORTCUT)
self.jumping_X += buttonSide
self.minusMinorCtrl = SquareButton((self.jumping_X, self.jumping_Y, buttonSide, buttonSide),
"{:+d}".format(MINOR_STEP),
sizeStyle='small',
callback=self.minusMinorCtrlCallback)
self.minusMinorCtrl.bind(*MINUS_MINOR_SHORTCUT)
self.jumping_X += buttonSide
self.plusMinorCtrl = SquareButton((self.jumping_X, self.jumping_Y, buttonSide, buttonSide),
"{:+d}".format(MINOR_STEP),
sizeStyle='small',
callback=self.plusMinorCtrlCallback)
self.plusMinorCtrl.bind(*PLUS_MINOR_SHORTCUT)
self.jumping_X += buttonSide
self.plusMajorCtrl = SquareButton((self.jumping_X, self.jumping_Y, buttonSide, buttonSide),
"{:+d}".format(MAJOR_STEP),
sizeStyle='small',
callback=self.plusMajorCtrlCallback)
self.plusMajorCtrl.bind(*PLUS_MAJOR_SHORTCUT)
self.jumping_X = buttonSide/2.
self.jumping_Y += buttonSide
self.lftSwitchCtrl = SquareButton((self.jumping_X, self.jumping_Y, buttonSide*2, buttonSide*.75),
"lft switch",
sizeStyle='small',
callback=self.lftSwitchCtrlCallback)
self.lftSwitchCtrl.bind(*LEFT_BROWSING_SHORTCUT)
self.jumping_X += buttonSide*2
self.rgtSwitchCtrl = SquareButton((self.jumping_X, self.jumping_Y, buttonSide*2, buttonSide*.75),
"rgt switch",
sizeStyle='small',
callback=self.rgtSwitchCtrlCallback)
self.rgtSwitchCtrl.bind(*RIGHT_BROWSING_SHORTCUT)
self.jumping_X = buttonSide/2.
self.jumping_Y += buttonSide
self.exceptionTrigger = SquareButton((self.jumping_X, self.jumping_Y, buttonSide*2, buttonSide*.75),
'exception',
sizeStyle='small',
callback=self.exceptionTriggerCallback)
self.exceptionTrigger.bind(*EXCEPTION_SHORTCUT)
self.jumping_X += buttonSide*2
self.undoButton = SquareButton((self.jumping_X, self.jumping_Y, buttonSide, buttonSide*.75),
'undo',
sizeStyle='small',
callback=self.undoButtonCallback)
self.undoButton.bind(*UNDO_SHORTCUT)
self.jumping_X += buttonSide
self.redoButton = SquareButton((self.jumping_X, self.jumping_Y, buttonSide, buttonSide*.75),
'redo',
sizeStyle='small',
callback=self.redoButtonCallback)
self.redoButton.bind(*REDO_SHORTCUT)
self.jumping_X = buttonSide/2.
self.jumping_Y += buttonSide*.75
self.previewCtrl = SquareButton((self.jumping_X, self.jumping_Y, buttonSide*2, buttonSide*.75),
"preview",
sizeStyle='small',
callback=self.previewCtrlCallback)
self.previewCtrl.bind(*PREVIEW_SHORTCUT)
self.jumping_X += buttonSide*2
self.solvedCtrl = SquareButton((self.jumping_X, self.jumping_Y, buttonSide*2, buttonSide*.75),
"solved",
sizeStyle='small',
callback=self.solvedCtrlCallback)
self.solvedCtrl.bind(*SOLVED_SHORTCUT)
self.jumping_X = buttonSide/2.
self.jumping_Y += buttonSide*.75+2
self.symmetricalModeCheck = CheckBox((self.jumping_X, self.jumping_Y, self.ctrlWidth, vanillaControlsSize['CheckBoxRegularHeight']),
'symmetrical editing',
value=self.isSwappedEditingOn,
callback=self.symmetricalModeCallback)
self.jumping_Y += buttonSide*.6
self.swappedModeCheck = CheckBox((self.jumping_X, self.jumping_Y, self.ctrlWidth, vanillaControlsSize['CheckBoxRegularHeight']),
'swapped editing',
value=self.isSwappedEditingOn,
callback=self.swappedModeCallback)
self.jumping_Y += buttonSide*.6
self.verticalAlignedModeCheck = CheckBox((self.jumping_X, self.jumping_Y, self.ctrlWidth, vanillaControlsSize['CheckBoxRegularHeight']),
'vertically aligned editing',
value=self.isVerticalAlignedEditingOn,
callback=self.verticalAlignedModeCheckCallback)
self.verticalAlignedModeCheck.bind(*VERTICAL_MODE_SHORTCUT)
self.hiddenSwappedEditingButton = Button((self.jumping_X, self.ctrlHeight+40, self.ctrlWidth, vanillaControlsSize['ButtonRegularHeight']),
'hiddenSymmetriyEditingButton',
callback=self.hiddenSwappedEditingButtonCallback)
self.hiddenSwappedEditingButton.bind(*FLIPPED_EDITING_SHORTCUT)
self.hiddenJumpToLineButton = Button((self.jumping_X, self.ctrlHeight+40, self.ctrlWidth, vanillaControlsSize['ButtonRegularHeight']),
'hiddenJumpToLineButton',
callback=self.hiddenJumpToLineButtonCallback)
self.hiddenJumpToLineButton.bind(*JUMP_TO_LINE_SHORTCUT)
self.jumping_X = buttonSide
self.jumping_Y += buttonSide
self.previousWordCtrl = SquareButton((self.jumping_X, self.jumping_Y, buttonSide, buttonSide),
u'↖',
callback=self.previousWordCtrlCallback)
self.previousWordCtrl.bind(*PREVIOUS_WORD_SHORTCUT)
self.jumping_X += buttonSide
self.cursorUpCtrl = SquareButton((self.jumping_X, self.jumping_Y, buttonSide, buttonSide),
u'↑',
callback=self.cursorUpCtrlCallback)
self.cursorUpCtrl.bind(*CURSOR_UP_SHORTCUT)
self.jumping_X += buttonSide*1.5
self.activePairEditCorrection = EditText((self.jumping_X, self.jumping_Y, 50, vanillaControlsSize['EditTextRegularHeight']),
text='{:d}'.format(0), # init value
continuous=False,
callback=self.activePairEditCorrectionCallback)
self.jumping_X = buttonSide
self.jumping_Y += buttonSide
self.cursorLeftCtrl = SquareButton((self.jumping_X, self.jumping_Y, buttonSide, buttonSide),
u"←",
callback=self.cursorLeftCtrlCallback)
self.cursorLeftCtrl.bind(*CURSOR_LEFT_SHORTCUT)
self.jumping_X += buttonSide*2
self.cursorRightCtrl = SquareButton((self.jumping_X, self.jumping_Y, buttonSide, buttonSide),
u'→',
callback=self.cursorRightCtrlCallback)
self.cursorRightCtrl.bind(*CURSOR_RIGHT_SHORTCUT)
self.jumping_X = buttonSide
self.jumping_Y += buttonSide
self.delPairCtrl = SquareButton((self.jumping_X-6, self.jumping_Y+6, buttonSide, buttonSide),
u'Del',
callback=self.delPairCtrlCallback)
self.delPairCtrl.bind(*DEL_PAIR_SHORTCUT)
self.jumping_X += buttonSide
self.cursorDownCtrl = SquareButton((self.jumping_X, self.jumping_Y, buttonSide, buttonSide),
u'↓',
callback=self.cursorDownCtrlCallback)
self.cursorDownCtrl.bind(*CURSOR_DOWN_SHORTCUT)
self.jumping_X += buttonSide
self.nextWordCtrl = SquareButton((self.jumping_X, self.jumping_Y, buttonSide, buttonSide),
u'↘',
callback=self.nextWordCtrlCallback)
self.nextWordCtrl.bind(*NEXT_WORD_SHORTCUT)
self.jumping_Y += buttonSide*1.3
self.jumping_X = buttonSide*.5
self.autoSaveCheck = CheckBox((self.jumping_X, self.jumping_Y, buttonSide*2.5, vanillaControlsSize['CheckBoxRegularHeight']),
'auto save',
callback=self.autoSaveCheckCallback)
self.jumping_X += buttonSide*2.5
self.autoSaveSpanPopUp = PopUpButton((self.jumping_X, self.jumping_Y, buttonSide*1.5, vanillaControlsSize['PopUpButtonRegularHeight']),
AUTO_SAVE_SPAN_OPTIONS,
callback=self.autoSaveSpanPopUpCallback)
self.autoSaveSpanPopUp.set(AUTO_SAVE_SPAN_OPTIONS.index("{:d}'".format(self.autoSaveSpan)))
# goes out
def getLastEvent(self):
return self.lastEvent
def getKeyboardCorrection(self):
return self.keyboardCorrection
def getAutoSaveState(self):
return self.autoSave, self.autoSaveSpan
# comes in
def setActivePair(self, activePair):
self.activePair = activePair
self.updateCorrectionValue()
def setSwappedEditing(self, value):
self.isSwappedEditingOn = value
self.swappedModeCheck.set(self.isSwappedEditingOn)
def setSymmetricalEditing(self, value):
self.isSymmetricalEditingOn = value
self.symmetricalModeCheck.set(self.isSymmetricalEditingOn)
def setFontObj(self, value):
self.fontObj = value
self.updateCorrectionValue()
def updateCorrectionValue(self):
correction, kerningReference, pairKind = getCorrection(self.activePair, self.fontObj)
try:
self.activePairEditCorrection.set('{:d}'.format(correction))
except ValueError:
self.activePairEditCorrection.set('')
# callbacks
def minusMajorCtrlCallback(self, sender):
self.lastEvent = 'minusMajor'
self.callback(self)
def minusMinorCtrlCallback(self, sender):
self.lastEvent = 'minusMinor'
self.callback(self)
def plusMinorCtrlCallback(self, sender):
self.lastEvent = 'plusMinor'
self.callback(self)
def plusMajorCtrlCallback(self, sender):
self.lastEvent = 'plusMajor'
self.callback(self)
def delPairCtrlCallback(self, sender):
self.lastEvent = 'deletePair'
self.callback(self)
def exceptionTriggerCallback(self, sender):
self.lastEvent = 'exceptionTrigger'
self.callback(self)
def undoButtonCallback(self, sender):
self.lastEvent = 'undo'
self.callback(self)
def redoButtonCallback(self, sender):
self.lastEvent = 'redo'
self.callback(self)
def previewCtrlCallback(self, sender):
self.lastEvent = 'preview'
self.callback(self)
def solvedCtrlCallback(self, sender):
self.lastEvent = 'solved'
self.callback(self)
def swappedModeCallback(self, sender):
self.lastEvent = 'swappedEditing'
self.isSwappedEditingOn = bool(sender.get())
self.callback(self)
def symmetricalModeCallback(self, sender):
self.lastEvent = 'symmetricalEditing'
self.isSymmetricalEditingOn = bool(sender.get())
self.callback(self)
def verticalAlignedModeCheckCallback(self, sender):
self.lastEvent = 'verticalAlignedEditing'
self.isVerticalAlignedEditingOn = bool(sender.get())
self.callback(self)
def hiddenSwappedEditingButtonCallback(self, sender):
self.lastEvent = 'swappedEditing'
self.isSwappedEditingOn = not self.isSwappedEditingOn
self.swappedModeCheck.set(self.isSwappedEditingOn)
self.callback(self)
def hiddenJumpToLineButtonCallback(self, sender):
self.lastEvent = 'jumpToLineTrigger'
self.callback(self)
def previousWordCtrlCallback(self, sender):
self.lastEvent = 'previousWord'
self.callback(self)
def cursorUpCtrlCallback(self, sender):
self.lastEvent = 'cursorUp'
self.callback(self)
def cursorLeftCtrlCallback(self, sender):
self.lastEvent = 'cursorLeft'
self.callback(self)
def cursorRightCtrlCallback(self, sender):
self.lastEvent = 'cursorRight'
self.callback(self)
def cursorDownCtrlCallback(self, sender):
self.lastEvent = 'cursorDown'
self.callback(self)
def nextWordCtrlCallback(self, sender):
self.lastEvent = 'nextWord'
self.callback(self)
def lftSwitchCtrlCallback(self, sender):
self.lastEvent = 'switchLftGlyph'
self.callback(self)
def rgtSwitchCtrlCallback(self, sender):
self.lastEvent = 'switchRgtGlyph'
self.callback(self)
def activePairEditCorrectionCallback(self, sender):
# removing the pair, if nothing is written
if sender.get() == '':
self.keyboardCorrection = None
self.callback(self)
return
# if numbers are there...
try:
self.lastEvent = 'keyboardEdit'
self.keyboardCorrection = int(sender.get())
self.callback(self)
except ValueError:
if sender.get() != '-':
self.activePairEditCorrection.set('{}'.format(self.keyboardCorrection))
print traceback.format_exc()
def autoSaveCheckCallback(self, sender):
self.lastEvent = 'autoSave'
self.autoSave = bool(sender.get())
self.callback(self)
def autoSaveSpanPopUpCallback(self, sender):
self.lastEvent = 'autoSave'
self.autoSaveSpan = INT_2_SPAN[AUTO_SAVE_SPAN_OPTIONS[sender.get()]]
self.callback(self)
class FontRow(Group):
lastDirection = None
isDisplayed = True
def __init__(self, posSize, index, aFont, isTop, isBottom,
directionCallback, displayedCallback):
super(FontRow, self).__init__(posSize)
self.directionCallback = directionCallback
self.displayedCallback = displayedCallback
self.index = index
self.ctrlFont = aFont
squareButtonSide = FONT_ROW_HEIGHT - 6
self.check = CheckBox(
(0, 0, 16, vanillaControlsSize['CheckBoxRegularHeight']),
'',
value=self.isDisplayed,
callback=self.checkCallback)
self.caption = TextBox(
(18, 2, 120, vanillaControlsSize['TextBoxRegularHeight']),
'{}'.format(self.ctrlFont.info.styleName))
self.buttonUp = SquareButton((-(squareButtonSide * 2 + MARGIN_COL), 0,
squareButtonSide, squareButtonSide),
u'↑',
callback=self.buttonUpCallback)
if isTop is True:
self.buttonUp.show(False)
self.buttonDw = SquareButton(
(-squareButtonSide, 0, squareButtonSide, squareButtonSide),
u'↓',
callback=self.buttonDwCallback)
if isBottom is True:
self.buttonDw.show(False)
def setFont(self, aFont):
self.ctrlFont = aFont
self.caption.set('{}'.format(self.ctrlFont.info.styleName))
def getDirection(self):
return self.lastDirection
def setIsDisplayed(self, isDisplayed):
self.isDisplayed = isDisplayed
self.check.set(self.isDisplayed)
def getIsDisplayed(self):
return self.isDisplayed
def getFont(self):
return self.ctrlFont
def checkCallback(self, sender):
self.isDisplayed = bool(sender.get())
self.displayedCallback(self)
def buttonUpCallback(self, sender):
self.lastDirection = 'up'
self.directionCallback(self)
def buttonDwCallback(self, sender):
self.lastDirection = 'down'
self.directionCallback(self)
