Esempio n. 1
0
 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)
Esempio n. 2
0
class Label(Group):
    def __init__(self, posSize, attachCallback, labelName=None):
        super(Label, self).__init__(posSize)
        self.labelName = labelName
        self.attachCallback = attachCallback

        self.edit = EditText((0, 0, NET_WIDTH * .7,
                              vanillaControlsSize['EditTextRegularHeight']),
                             text=self.labelName,
                             continuous=True,
                             callback=self.editCallback)

        self.button = SquareButton(
            (NET_WIDTH * .72, 0, NET_WIDTH * .28,
             vanillaControlsSize['EditTextRegularHeight']),
            'attach!',
            callback=self.buttonCallback)

    def get(self):
        return self.labelName

    def setLabelName(self, labelName):
        self.labelName = labelName
        self.edit.set(self.labelName)

    def editCallback(self, sender):
        self.labelName = sender.get()

    def buttonCallback(self, sender):
        self.attachCallback(self)
Esempio n. 3
0
    def __init__(self, posSize, callback):
        super(WordListController, self).__init__(posSize)
        x, y, self.ctrlWidth, self.ctrlHeight = posSize
        self.callback = callback

        # handling kerning words
        self.kerningWordsDB = loadKerningTexts(STANDARD_KERNING_TEXT_FOLDER)
        self.kerningTextBaseNames = self.kerningWordsDB.keys()
        self.activeKerningTextBaseName = self.kerningTextBaseNames[0]
        # this is the list used for data manipulation
        self.wordsWorkingList = self.kerningWordsDB[self.activeKerningTextBaseName]
        # this list instead is used for data visualization in the ctrl
        self._makeWordsDisplayList(self.activeKerningTextBaseName)
        self.activeWord = self.wordsWorkingList[0]['word']
        self.wordFilter = ''

        jumping_Y = 0
        self.kerningVocabularyPopUp = PopUpButton((0, jumping_Y, self.ctrlWidth*.6, vanillaControlsSize['PopUpButtonRegularHeight']),
                                                  self.kerningTextBaseNames,
                                                  callback=self.kerningVocabularyPopUpCallback)

        self.openTextsFolderButton = SquareButton((self.ctrlWidth*.62, jumping_Y, self.ctrlWidth*.38, vanillaControlsSize['PopUpButtonRegularHeight']+1),
                                                  'Load texts...',
                                                  sizeStyle='small',
                                                  callback=self.openTextsFolderButtonCallback)

        wordsColumnDescriptors = [
            {'title': '#', 'width': 30, 'editable': False},
            {'title': 'word', 'width': self.ctrlWidth-80, 'editable': False},
            {'title': 'done?', 'width': 35, 'cell': CheckBoxListCell(), 'editable': False}]

        jumping_Y += self.openTextsFolderButton.getPosSize()[3] + MARGIN_VER
        self.wordsListCtrl = List((0, jumping_Y, self.ctrlWidth, 170),
                                  self.wordsDisplayList,
                                  enableDelete=False,
                                  allowsMultipleSelection=False,
                                  columnDescriptions=wordsColumnDescriptors,
                                  selectionCallback=self.wordsListCtrlSelectionCallback,
                                  doubleClickCallback=self.wordsListCtrlDoubleClickCallback)

        jumping_Y += self.wordsListCtrl.getPosSize()[3] + MARGIN_VER
        self.wordsFilterCtrl = EditText((-70, jumping_Y-1, 70, vanillaControlsSize['EditTextRegularHeight']),
                                        placeholder='filter...',
                                        callback=self.wordsFilterCtrlCallback)

        self.wordsDone = len([row['done?'] for row in self.wordsWorkingList if row['done?'] != 0])
        self.infoCaption = TextBox((0, jumping_Y+2, self.ctrlWidth-self.wordsFilterCtrl.getPosSize()[2], vanillaControlsSize['TextBoxRegularHeight']),
                                   'done: {:d}/{:d}'.format(self.wordsDone, len(self.wordsWorkingList)))

        jumping_Y += self.wordsFilterCtrl.getPosSize()[3] + MARGIN_VER
        self.loadStatus = SquareButton((0, jumping_Y, 90, vanillaControlsSize['ButtonRegularHeight']+2),
                                       'Load status',
                                       callback=self.loadStatusCallback)

        self.saveButton = SquareButton((-90, jumping_Y, 90, vanillaControlsSize['ButtonRegularHeight']+2),
                                       'Save status',
                                       callback=self.saveButtonCallback)
 def __init__(self, parameter, posSize, text='', callback=None, continuous=False, showRelativeValue=False):
     super(ParameterTextInput, self).__init__(posSize)
     self.parameter = parameter
     rel = self._relValue()
     self.callback = callback
     self.textInput = EditText((0, 0, -40, -0), text=text, callback=self._valueInput, continuous=continuous)
     self.relInfo = TextBox((-35, 5, -0, -0), rel, alignment='left', sizeStyle='small')
     self.showRelativeValue(showRelativeValue)
     self.vanillaInputs = [self.textInput]
     self.parameter.bind(self)
Esempio n. 5
0
    def __init__(self, position, label, placeholder=""):
        super(TextField, self).__init__(
            (position[0], position[1], position[2], 22))

        self.label = TextBox((0, 3, self.indent - 10, 22),
                             "{0}:".format(label),
                             alignment="right")

        self.text = EditText((self.indent, 0, 500 - 40 - self.indent, 22),
                             placeholder=placeholder)
Esempio n. 6
0
    def __init__(self):
        self.font = Glyphs.font  # Returns the current that is open in GlyphsApp
        self.currentGlyphName = 'H'
        self.glyph = self.font[self.currentGlyphName].layers[0]
        lsb = int(round(self.glyph.LSB))
        rsb = int(round(self.glyph.RSB))

        pad = 10
        leading = 32
        y = pad
        w = 300
        h = 400
        buttonWidth = 100
        buttonHeight = 48

        self.w = Window((100, 100, w, h), 'DemoWindowTool')
        self.w.doDraw = CheckBox((pad, y, 100, 24),
                                 'Draw',
                                 callback=self.doDrawCallback)

        y += leading
        self.w.leftMarginLabel = TextBox((pad, y, -pad, 24), 'Left margin')
        y += leading / 2
        self.w.leftMarginSlider = Slider(
            (pad, y, -pad - 60, 24),
            minValue=MIN_LSB,
            maxValue=MAX_LSB,
            value=lsb,
            tickMarkCount=10,
            callback=self.leftMarginSliderCallback)
        self.w.leftMarginBox = EditText((-pad - 60 + pad, y, -pad, 24),
                                        callback=self.leftMarginBoxCallback)
        self.w.leftMarginBox.set(str(lsb))

        y += leading
        self.w.rightMarginLabel = TextBox((pad, y, -pad, 24), 'Right margin')
        y += leading / 2
        self.w.rightMarginSlider = Slider(
            (pad, y, -pad - 60, 24),
            minValue=MIN_RSB,
            maxValue=MAX_RSB,
            value=rsb,
            tickMarkCount=10,
            callback=self.rightMarginSliderCallback)
        self.w.rightMarginBox = EditText((-pad - 60 + pad, y, -pad, 24),
                                         callback=self.rightMarginBoxCallback)
        self.w.rightMarginBox.set(str(rsb))

        y = self.w.saveFont = Button((-buttonWidth - pad, -buttonHeight - pad,
                                      buttonWidth, buttonHeight),
                                     'Save',
                                     callback=self.saveFontCallback)

        self.w.open()
Esempio n. 7
0
 def __init__(self, posSize, text, minValue, maxValue, value, callback):
     Group.__init__(self, posSize)
     self.text = TextBox((0, 0, -0, 20), text)
     self.slider = Slider((2, 20, -60, 17),
                          minValue=minValue,
                          maxValue=maxValue,
                          value=value,
                          sizeStyle="small",
                          callback=self.sliderChanged)
     self.edit = EditText((-40, 15, -0, 22),
                          text=str(value),
                          placeholder=str(value),
                          callback=self.editChanged)
     self.callback = callback
Esempio n. 8
0
 def show_subscriber_sheet(self, sender):
     self.window.sheet = Sheet((250, 107), self.window)
     self.window.sheet.name = EditText((15, 15, -15, 22),
                                       "",
                                       placeholder="Name")
     self.window.sheet.email_address = EditText((15, 43, -15, 22),
                                                "",
                                                placeholder="Email Address")
     self.window.sheet.cancel_button = Button((-190, 70, 80, 22),
                                              'Cancel',
                                              callback=self.close_sheet)
     self.window.sheet.create_button = Button(
         (-95, 70, 80, 22), 'Add', callback=self.create_subscriber)
     self.window.sheet.setDefaultButton(self.window.sheet.create_button)
     self.window.sheet.open()
Esempio n. 9
0
    def __init__(self, posSize, index, callback):
        super(LabelCtrl, self).__init__(posSize)
        self.callback = callback
        self.index = index

        self.jumpingX = 0
        self.attachButton = SquareButton((self.jumpingX, 0, self.attachButtonWidth, vanillaControlsSize['EditTextRegularHeight']),
                                         'Attach',
                                         sizeStyle='small',
                                         callback=self.attachButtonCallback)

        self.jumpingX += MARGIN_COL + self.attachButtonWidth
        self.labelNameEdit = EditText((self.jumpingX, 0, self.labelNameEditWidth, vanillaControlsSize['EditTextRegularHeight']),
                                      callback=self.labelNameEditCallback)

        self.jumpingX += MARGIN_COL + self.labelNameEditWidth
        self.plusButton = SquareButton((self.jumpingX, 0, self.plusButtonWidth, vanillaControlsSize['EditTextRegularHeight']),
                                       '+',
                                       sizeStyle='small',
                                       callback=self.plusButtonCallback)

        self.jumpingX += MARGIN_COL + self.lessButtonWidth
        self.lessButton = SquareButton((self.jumpingX, 0, self.lessButtonWidth, vanillaControlsSize['EditTextRegularHeight']),
                                       '-',
                                       sizeStyle='small',
                                       callback=self.lessButtonCallback)
Esempio n. 10
0
    def __init__(self, posSize, attachCallback, labelName=None):
        super(Label, self).__init__(posSize)
        self.labelName = labelName
        self.attachCallback = attachCallback

        self.edit = EditText((0, 0, NET_WIDTH * .7,
                              vanillaControlsSize['EditTextRegularHeight']),
                             text=self.labelName,
                             continuous=True,
                             callback=self.editCallback)

        self.button = SquareButton(
            (NET_WIDTH * .72, 0, NET_WIDTH * .28,
             vanillaControlsSize['EditTextRegularHeight']),
            'attach!',
            callback=self.buttonCallback)
Esempio n. 11
0
	def __init__( self ):
		# Window 'self.w':
		w  = 300
		h = 300
		windowWidthResize  = 200 # user can resize width by this value
		windowHeightResize = 500   # user can resize height by this value
		self.w = vanilla.FloatingWindow(
			(w, h ), # default window size
			"Dimensions", # window title
			minSize = ( w, h-100 ), # minimum size (for resizing)
			maxSize = ( w + windowWidthResize, h + windowHeightResize ), # maximum size (for resizing)
			autosaveName = "com.typetr.Dimensions.mainwindow" # stores last window position and size
		)
		M = 10
		y = 30
		# UI elements we'll use later
		self.w.tabWidth = EditText( (M, y, w/4-M-M, 20), "650", sizeStyle='small' )
		self.w.tabWidthLabel = TextBox( (w/4, y+4, w/2, 20), "Tab width", sizeStyle='small' )
		
		y += 30
		# Checkbox to flag if any drawing should be done by this tools
		self.w.doDraw = CheckBox((M, y, -M, 24), "Fix errors", value=False, sizeStyle='regular' )
					   
		# Open window and focus on it:
		self.w.bind('close', self.windowCloseCallback) # Make bind in case the window is closed
		self.w.open()
		self.w.makeKey()
		
		# Establish callbacks that we need for this tool
		Glyphs.addCallback( self.drawforeground, DRAWFOREGROUND )
		Glyphs.addCallback( self.drawbackground, DRAWBACKGROUND )
Esempio n. 12
0
    def __init__(self, callback):
        super(JumpToLineWindow, self).__init__()
        self.callback = callback

        # init the window
        self.w = FloatingWindow((WINDOW_WIDTH, 0), 'Jump to line')

        # edit text caption
        jumpingY = MARGIN_TOP
        self.w.caption = TextBox((MARGIN_LFT, jumpingY + 3, NET_WIDTH * .6,
                                  vanillaControlsSize['TextBoxRegularHeight']),
                                 'Jump to line:')

        self.w.lineEdit = EditText(
            (MARGIN_LFT + NET_WIDTH * .6, jumpingY, -MARGIN_RGT,
             vanillaControlsSize['EditTextRegularHeight']),
            continuous=False)

        jumpingY += vanillaControlsSize['EditTextRegularHeight'] + MARGIN_INT
        self.w.cancelButton = Button(
            (-(BUTTON_WIDTH * 2 + MARGIN_INT + MARGIN_RGT), jumpingY,
             BUTTON_WIDTH, vanillaControlsSize['ButtonRegularHeight']),
            'Cancel',
            callback=self.cancelButtonCallback)

        self.w.okButton = Button(
            (-(BUTTON_WIDTH + MARGIN_RGT), jumpingY, BUTTON_WIDTH,
             vanillaControlsSize['ButtonRegularHeight']),
            'Ok',
            callback=self.okButtonCallback)

        jumpingY += vanillaControlsSize['ButtonRegularHeight'] + MARGIN_BTM
        self.setUpBaseWindowBehavior()
        self.w.resize(WINDOW_WIDTH, jumpingY)
 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:
         if "point" in title:
             title = title.lstrip("point")
             title = "p. " + title
         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.parameter.bind(self.checkBox)
     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)
     self.parameter.bind(self.slider)
     self.parameter.bind(self.textInput)
Esempio n. 14
0
    def __init__(self):
        self.searchResults = []
        self.selectedChars = ""

        self.w = FloatingWindow((300, 400), "Unicode Picker", minSize=(250, 300),
                                autosaveName="UnicodePicker")
        y = 15
        self.w.searchField = EditText((20, y, -20, 25),
                                      placeholder="Search Unicode name or value",
                                      callback=self.searchTextChanged_)

        y += 40
        columnDescriptions = [
            dict(title="char", width=40,
                 cell=makeTextCell(align="center", font=AppKit.NSFont.systemFontOfSize_(14))),
            dict(title="unicode", width=60, cell=makeTextCell(align="right")),
            dict(title="name"),
        ]
        self.w.unicodeList = List((0, y, 0, -100), [], columnDescriptions=columnDescriptions,
                                  rowHeight=18,
                                  selectionCallback=self.listSelectionChanged_,
                                  doubleClickCallback=self.listDoubleClickCallback_)

        y = -95
        self.w.unicodeText = TextBox((20, y, -10, 55), "")
        self.w.unicodeText._nsObject.cell().setFont_(AppKit.NSFont.systemFontOfSize_(36))
        self.w.unicodeText._nsObject.cell().setLineBreakMode_(AppKit.NSLineBreakByTruncatingMiddle)
        y += 55
        self.w.copyButton = Button((20, y, 120, 25), "Copy", callback=self.copy_)
        self.w.copyButton.enable(False)

        self.w.open()
        self.w._window.setWindowController_(self)
        self.w._window.setBecomesKeyOnlyIfNeeded_(False)
        self.w._window.makeKeyWindow()
Esempio n. 15
0
 def __init__(self):
     self.w = Window((550, 140), "Replace named Layer")
     self.w.editText = EditText((10, 15, -10, 22), placeholder="Layer Name", text='{170}')
     self.w.correct_path_direction = CheckBox((10, 50, -10, 18), "Correct Path Direction", value=True, sizeStyle='small')
     self.w.sync_metrics = CheckBox((210, 50, -10, 18), "Sync Metrics", value=True, sizeStyle='small')
     self.w.add_if_missing = CheckBox((10, 70, -10, 18), "Add layer if missing", value=True, sizeStyle='small')
     self.w.copybutton = Button((10, 100, -10, 17), "Replace layer", callback=self.buttonCallback)
     self.w.open()
Esempio n. 16
0
    def __init__(self):
        '''Initialize the dialog.'''
        x = y = padding = 10
        buttonHeight = 20
        windowWidth = 400

        rows = 4.5

        self.w = FloatingWindow(
            (windowWidth, buttonHeight * rows + padding * (rows)),
            "Glyph Fax Machine")

        self.fonts = {}

        # self.w.textBox = TextBox((x, y, -padding, buttonHeight), "Glyphs to Copy")

        # y += buttonHeight

        self.w.editText = EditText(
            (x, y, -padding, buttonHeight * 2 + padding),
            placeholder="Space-separated list of glyphs to copy")

        y += buttonHeight * 2 + padding * 2

        # self.w.overwriteGlyphsCheckBox = CheckBox((x, y, -padding, buttonHeight), "Overwrite Glyphs", value=False, callback=self.overwriteGlyphsOptions)

        # y += buttonHeight + padding

        self.w.overwriteNormalWidthGlyphsCheckBox = CheckBox(
            (x, y, -padding, buttonHeight),
            "Overwrite 600w Glyphs",
            value=False,
            sizeStyle="small")
        # self.w.overwriteNormalWidthGlyphsCheckBox.show(False)

        self.w.overwriteAdjustedWidthGlyphsCheckBox = CheckBox(
            (windowWidth * 0.4, y, -padding, buttonHeight),
            "Overwrite non-600w Glyphs",
            value=False,
            sizeStyle="small")
        # self.w.overwriteAdjustedWidthGlyphsCheckBox.show(False)
        self.w.colorWell = ColorWell(
            (windowWidth * 0.85, y, -padding, buttonHeight),
            color=NSColor.orangeColor())

        y += buttonHeight + padding

        self.w.sans2mono = Button(
            (x, y, windowWidth / 3 - padding / 2, buttonHeight),
            "Sans → Mono",
            callback=self.sans2monoCallback)

        self.w.mono2sans = Button(
            (windowWidth / 3 + padding, y, -padding, buttonHeight),
            "Mono → Sans",
            callback=self.mono2SansCallback)

        self.w.open()
Esempio n. 17
0
    def __init__(self, position, label, placeholder=""):
        super(TextField, self).__init__((position[0], position[1], position[2], 22))

        self.label = TextBox((0, 3, self.indent - 10, 22),
                             "{0}:".format(label),
                             alignment="right")

        self.text = EditText((self.indent, 0, 500 - 40 - self.indent, 22),
                             placeholder=placeholder)
Esempio n. 18
0
    def __init__(self,
                 posSize,
                 sender=None,
                 blenderMode=None,
                 key=None,
                 value=None,
                 idx=0):
        super().__init__(posSize)
        self._setupView(self.nsViewClass, posSize)
        self.sender, self.key, self.value, self.idx = sender, key, value, idx

        if self.idx > 0:
            self.separator = HorizontalLine((0, 0, -0, 1))

        self.help = HelpButton((0, 10, 21, 20), callback=self._helpCallback)
        try:
            docstring[self.key]
        except:
            self.help.enable(False)

        description = TextBox((60, 10, -0, 20), str(self.key))

        if isinstance(value, dict):
            self.description = description
            # TODO: Recursive evaluation of nested dicts
            pass

        elif isinstance(self.value, str) or (isinstance(value, int)
                                             and not isinstance(value, bool)):
            self.description = description
            self.edit = EditText((10, 40, -0, 20),
                                 text=self.value,
                                 callback=self._dummyCallback)
            self.resize(self.getPosSize()[2], 80)

        elif isinstance(self.value, bool):
            self.check = CheckBox((60, 10, -0, 20),
                                  key,
                                  callback=self._dummyCallback,
                                  value=self.value)
            self.resize(self.getPosSize()[2], 40)

        elif isinstance(self.value, list):
            values = self.getValues(self.value)

            self.description = description
            self.list = List((10, 40, -0, 80),
                             items=self.value,
                             columnDescriptions=None,
                             showColumnTitles=False,
                             allowsEmptySelection=False,
                             allowsMultipleSelection=False,
                             autohidesScrollers=True,
                             drawFocusRing=False)
            self.list._nsObject.setBorderType_(NSNoBorder)
            self.resize(self.getPosSize()[2], 120)
Esempio n. 19
0
    def __init__(self, posSize, index, isVertical, isHorizontal, step,
                 gridColor, callback):
        Group.__init__(self, posSize)

        # from arguments to attributes
        self.ctrlX, self.ctrlY, self.ctrlWidth, self.ctrlHeight = posSize
        self.index = index
        self.isVertical = isVertical
        self.isHorizontal = isHorizontal
        self.step = step
        self.gridColor = gridColor
        self.callback = callback

        # ctrls
        jumpin_X = 12
        self.indexText = TextBox(
            (jumpin_X, 0, 16, vanillaControlsSize['TextBoxRegularHeight']),
            '{:d})'.format(index))
        jumpin_X += self.indexText.getPosSize()[2]

        self.stepCtrl = EditText(
            (jumpin_X, 0, 38, vanillaControlsSize['EditTextRegularHeight']),
            callback=self.stepCtrlCallback)
        jumpin_X += self.stepCtrl.getPosSize()[2] + 16

        self.isHorizontalCheck = CheckBox(
            (jumpin_X, 0, 32, vanillaControlsSize['CheckBoxRegularHeight']),
            "H",
            value=self.isHorizontal,
            callback=self.isHorizontalCheckCallback)
        jumpin_X += self.isHorizontalCheck.getPosSize()[2] + 2

        self.isVerticalCheck = CheckBox(
            (jumpin_X, 0, 32, vanillaControlsSize['CheckBoxRegularHeight']),
            "V",
            value=self.isVertical,
            callback=self.isVerticalCheckCallback)
        jumpin_X += self.isVerticalCheck.getPosSize()[2] + 10

        self.whichColorWell = ColorWell(
            (jumpin_X, 0, 46, self.ctrlHeight),
            color=NSColor.colorWithCalibratedRed_green_blue_alpha_(*gridColor),
            callback=self.whichColorWellCallback)
Esempio n. 20
0
class TextField(Group):

    indent = 90

    def __init__(self, position, label, placeholder=""):
        super(TextField, self).__init__((position[0], position[1], position[2], 22))

        self.label = TextBox((0, 3, self.indent - 10, 22),
                             "{0}:".format(label),
                             alignment="right")

        self.text = EditText((self.indent, 0, 500 - 40 - self.indent, 22),
                             placeholder=placeholder)

    def set(self, *args):
        return self.text.set(*args)

    def get(self):
        return self.text.get()
Esempio n. 21
0
    def __init__(self, font, success_window):
        self.font = font
        self.success_window = success_window

        self.window.family_name_label = TextBox((15, 15, -15, 22),
                                                'Family Name',
                                                sizeStyle='small')
        self.window.family_name = EditText((15, 40, -15, 22),
                                           font.info.familyName)

        self.window.designer_name_label = TextBox((15, 81, -15, 22),
                                                  'Designer',
                                                  sizeStyle='small')
        self.window.designer_name = EditText((15, 106, -15, 22),
                                             font.info.openTypeNameDesigner)

        self.window.create_button = Button((175, -38, 110, 22),
                                           'Add Font',
                                           callback=self.create)
Esempio n. 22
0
    def __init__(self):
        self.transferList = NAME_2_GLYPHLIST[GLYPHLISTS_OPTIONS[0]]
        self.target = TARGET_OPTIONS[0]

        self.w = FloatingWindow((0, 0, PLUGIN_WIDTH, 400), PLUGIN_TITLE)
        jumpingY = MARGIN_VER

        # target fonts
        self.w.targetFontsPopUp = PopUpButton(
            (MARGIN_HOR, jumpingY, NET_WIDTH,
             vanillaControlsSize['PopUpButtonRegularHeight']),
            TARGET_OPTIONS,
            callback=self.targetFontsPopUpCallback)
        jumpingY += vanillaControlsSize['PopUpButtonRegularHeight'] + MARGIN_VER

        # transfer lists pop up
        self.w.glyphListPopUp = PopUpButton(
            (MARGIN_HOR, jumpingY, NET_WIDTH,
             vanillaControlsSize['PopUpButtonRegularHeight']),
            GLYPHLISTS_OPTIONS,
            callback=self.glyphListPopUpCallback)
        jumpingY += vanillaControlsSize['PopUpButtonRegularHeight'] + MARGIN_VER

        # offset caption
        self.w.offsetCaption = TextBox(
            (MARGIN_HOR, jumpingY + 2, NET_WIDTH * .22,
             vanillaControlsSize['TextBoxRegularHeight']), 'Offset:')

        # offset edit text
        self.w.offsetEdit = EditText(
            (MARGIN_HOR + NET_WIDTH * .25, jumpingY, NET_WIDTH * .35,
             vanillaControlsSize['EditTextRegularHeight']),
            continuous=False,
            callback=self.offsetEditCallback)
        self.w.offsetEdit.set('%d' % self.verticalOffset)
        jumpingY += vanillaControlsSize['EditTextRegularHeight'] + MARGIN_VER

        # clean button
        self.w.cleanButton = Button(
            (MARGIN_HOR, jumpingY, NET_WIDTH * .45,
             vanillaControlsSize['ButtonRegularHeight']),
            'Clean',
            callback=self.cleanButtonCallback)

        # run button
        self.w.runButton = Button(
            (MARGIN_HOR + NET_WIDTH * .55, jumpingY, NET_WIDTH * .45,
             vanillaControlsSize['ButtonRegularHeight']),
            'Run!',
            callback=self.runButtonCallback)
        jumpingY += vanillaControlsSize['ButtonRegularHeight'] + MARGIN_VER

        self.w.setPosSize((0, 0, PLUGIN_WIDTH, jumpingY))
        self.w.open()
Esempio n. 23
0
 def enterAlternateNumber_(self, sender):
     self.popover = Popover((140, 80))
     self.popover.open(parentView=self, preferredEdge='right')
     self.popover.label = TextBox((20, 10, -20, 20), "Enter an Alt nr.:")
     if self.state:
         value = str(int(self.state))
     else:
         value = ""
     self.popover.altNumber = EditText((20, 35, -20, 25), value, continuous=False,
                                       callback=self.textEnteredCallback_)
     self.window().makeFirstResponder_(self.popover.altNumber._nsObject)
Esempio n. 24
0
class TextField(Group):

    indent = 90

    def __init__(self, position, label, placeholder=""):
        super(TextField, self).__init__(
            (position[0], position[1], position[2], 22))

        self.label = TextBox((0, 3, self.indent - 10, 22),
                             "{0}:".format(label),
                             alignment="right")

        self.text = EditText((self.indent, 0, 500 - 40 - self.indent, 22),
                             placeholder=placeholder)

    def set(self, *args):
        return self.text.set(*args)

    def get(self):
        return self.text.get()
Esempio n. 25
0
 def __init__(self, success_window):
     self.success_window = success_window
     
     self.window.introduction = TextBox((15, 15, -15, 22), 'Sign in with your Ghostlines account.', sizeStyle='small')
     self.window.email_label = TextBox((15, 44, -15, 22), 'Email:', sizeStyle='small')
     self.window.email_field = EditText((15, 61, -15, 22))
     self.window.password_label = TextBox((15, 101, -15, 22), 'Password:'******'small')
     self.window.password_field = SecureEditText((15, 119, -15, 22))
     self.window.need_account_button = Button((15, -35, 110, 17), 'Need Account?', callback=self.make_account, sizeStyle="small")
     self.window.sign_in_button = Button((175, -38, 110, 22), 'Sign In', callback=self.sign_in)
     self.window.setDefaultButton(self.window.sign_in_button)
Esempio n. 26
0
    def __init__(self):
        self.fontTarget = FONT_TARGET_OPTIONS[0]
        self.glyphTarget = GLYPH_TARGET_OPTIONS[0]
        self.gridSize = 4

        self.w = FloatingWindow((0, 0, PLUGIN_WIDTH, 400), PLUGIN_TITLE)
        jumpingY = MARGIN_VER

        # font target
        self.w.fontTargetPopUp = PopUpButton(
            (MARGIN_HOR, jumpingY, NET_WIDTH,
             vanillaControlsSize['PopUpButtonRegularHeight']),
            FONT_TARGET_OPTIONS,
            callback=self.fontTargetPopUpCallback)
        jumpingY += vanillaControlsSize['PopUpButtonRegularHeight'] + MARGIN_VER

        # glyph target
        self.w.glyphTargetPopUp = PopUpButton(
            (MARGIN_HOR, jumpingY, NET_WIDTH,
             vanillaControlsSize['PopUpButtonRegularHeight']),
            GLYPH_TARGET_OPTIONS,
            callback=self.glyphTargetPopUpCallback)
        jumpingY += vanillaControlsSize['PopUpButtonRegularHeight'] + MARGIN_VER

        # grid size captions
        self.w.gridSizeCaption = TextBox(
            (MARGIN_HOR, jumpingY + 2, NET_WIDTH * .32,
             vanillaControlsSize['TextBoxRegularHeight']), 'Grid Size:')

        # grid size edit
        self.w.gridSizeEdit = EditText(
            (MARGIN_HOR + NET_WIDTH * .32, jumpingY, NET_WIDTH * .3,
             vanillaControlsSize['EditTextRegularHeight']),
            text='{:d}'.format(self.gridSize),
            callback=self.gridSizeEditCallback)
        jumpingY += vanillaControlsSize['EditTextRegularHeight'] + MARGIN_VER

        self.w.moveBcpHandlesCheck = CheckBox(
            (MARGIN_HOR, jumpingY, NET_WIDTH,
             vanillaControlsSize['CheckBoxRegularHeight']),
            'move bcp handles',
            value=self.bcpHandlesFit,
            callback=self.moveBcpHandlesCheckCallback)
        jumpingY += vanillaControlsSize['CheckBoxRegularHeight'] + MARGIN_VER

        # fit button
        self.w.fitButton = Button((MARGIN_HOR, jumpingY, NET_WIDTH,
                                   vanillaControlsSize['ButtonRegularHeight']),
                                  'Fit!',
                                  callback=self.fitButtonCallback)
        jumpingY += vanillaControlsSize['ButtonRegularHeight'] + MARGIN_VER

        self.w.setPosSize((0, 0, PLUGIN_WIDTH, jumpingY))
        self.w.open()
Esempio n. 27
0
    def __init__(self):
        self.glyph = None  # Typical RoboFont function
        self.updating = False

        pad = 10
        leading = 32
        y = pad
        w = 500
        h = 500
        c1 = 150
        c2 = 200
        bh = 24  # Button height
        leading = bh + pad / 2

        self.w = Window((100, 100, w, h), 'Final tool window', minSize=(w, h))
        self.w.fontList = List((pad, pad, c2, -w / 2), [],
                               doubleClickCallback=self.openFontCallback,
                               selectionCallback=self.update)

        y = pad
        self.w.fixTabWidths = Button((-c1 - pad, y, c1, bh),
                                     'Fix tab widths',
                                     callback=self.fixTabWidthsCallback)
        self.w.fixTabWidths.enable(False)

        y += leading
        self.w.fixNegativeWidths = Button(
            (-c1 - pad, y, c1, bh),
            'Fix negative widths',
            callback=self.fixNegativeWidthsCallback)
        self.w.fixNegativeWidths.enable(False)

        y += leading
        self.w.fixMissingComponentsWidths = Button(
            (-c1 - pad, y, c1, bh),
            'Fix missing components',
            callback=self.fixMissingComponentCallback)
        self.w.fixMissingComponentsWidths.enable(False)

        self.w.selectFolder = Button((-c1 - pad, -pad - bh, c1, bh),
                                     'Select fonts',
                                     callback=self.selectFontFolder)

        self.w.canvas = Canvas((pad, -w / 2 - pad, -pad, -w / 4),
                               delegate=self)

        self.w.report = EditText((pad, -w / 4 + pad, -pad, -pad),
                                 readOnly=False)

        self.w.bind('close', self.windowCloseCallback)
        self.w.open()

        self.dirPath = self.selectFontFolder()
 def add_recipient(self, sender):
     self.window.sheet = Sheet((250, 89), self.window)
     self.window.sheet.recipient = EditText((15, 15, -15, 22),
                                            "",
                                            placeholder="Email Address")
     self.window.sheet.cancel_button = Button((-190, 52, 80, 22),
                                              'Cancel',
                                              callback=self.close_sheet)
     self.window.sheet.create_button = Button(
         (-95, 52, 80, 22), 'Add', callback=self.create_recipient)
     self.window.sheet.setDefaultButton(self.window.sheet.create_button)
     self.window.sheet.open()
class SliderGroup(Group):
    def __init__(self, posSize, minValue, maxValue, value, callback):
        Group.__init__(self, posSize)
        self.slider = Slider(
            (2, 3, -55, 17),
            minValue=minValue,
            maxValue=maxValue,
            value=value,
            sizeStyle="regular",
            callback=self.sliderChanged)
        self.edit = EditText(
            (-40, 0, -0, 22),
            text=str(value),
            placeholder=str(value),
            callback=self.editChanged)
        self.callback = callback

    def sliderChanged(self, sender):
        self.edit.set(str(int(self.slider.get())))
        self.callback(sender)

    def editChanged(self, sender):
        try:
            value = int(float(self.edit.get()))
        except ValueError:
            value = int(self.edit.getPlaceholder())
            self.edit.set(value)
        self.slider.set(value)
        self.callback(sender)
Esempio n. 30
0
    def __init__(self, posSize, callbackAttrs, placeCallback, deleteCallback):
        super(AnchorsCtrls, self).__init__(posSize)
        self.callbackAttrs = callbackAttrs
        self.placeCallback = placeCallback
        self.deleteCallback = deleteCallback

        x, y, width, height = posSize

        jumpinY = 0
        self.heightCaption = TextBox(
            (32, jumpinY, width / 2.,
             vanillaControlsSize['TextBoxRegularHeight']), 'Height:')
        self.heightEdit = EditText(
            (width / 2., jumpinY, width / 2.,
             vanillaControlsSize['EditTextRegularHeight']),
            continuous=False,
            callback=self.heightEditCallback)

        jumpinY += self.heightEdit.getPosSize()[3] + MARGIN_ROW
        self.nameCaption = TextBox(
            (32, jumpinY, width / 2.,
             vanillaControlsSize['TextBoxRegularHeight']), 'Anchor:')
        self.nameCombo = ComboBox(
            (width / 2., jumpinY, width / 2.,
             vanillaControlsSize['ComboBoxRegularHeight']),
            ['top', '_top', 'bottom', '_bottom'],
            callback=self.nameComboCallback)

        jumpinY += self.nameCombo.getPosSize()[3] + MARGIN_ROW * 2
        self.placeButton = Button((0, jumpinY, width * .45,
                                   vanillaControlsSize['ButtonRegularHeight']),
                                  'Place',
                                  callback=self.placeButtonCallback)

        self.deleteButton = Button(
            (width * .55, jumpinY, width * .45,
             vanillaControlsSize['ButtonRegularHeight']),
            'Delete',
            callback=self.deleteButtonCallback)
Esempio n. 31
0
    def __init__(self):
        self.valuesPrefsKey = prefsKey + ".delta." + basename(
            Glyphs.font.filepath)
        # UI metrics
        spacing = 8
        height = 22
        # calculate window height
        minWinSize = (220,
                      120 + (len(Glyphs.font.masters) * (height + spacing)))
        # create UI window
        self.w = FloatingWindow(minWinSize,
                                "Adjust sidebearings",
                                minSize=minWinSize,
                                maxSize=(500, 500),
                                autosaveName=prefsKey + ".win")
        # layout UI controls
        y = 16
        self.w.label = TextBox((16, y, -16, height),
                               "Sidebearing delta adjustment:")
        y += height + spacing

        inputWidth = 64
        for master in Glyphs.font.masters:
            setattr(self.w, "deltaLabel%s" % master.id,
                    TextBox((16, y, -16 - inputWidth, height), master.name))
            setattr(self.w, "deltaInput%s" % master.id,
                    EditText((-16 - inputWidth, y, -16, height), "16"))
            # print("self.w.deltaInputs[master.id]", getattr(self.w, "deltaInput%s" % master.id))
            y += height + spacing

        self.w.submitButton = Button((16, -16 - height, -16, height),
                                     "Adjust all sidebearings",
                                     callback=self.onSubmit)
        # finalize UI
        self.w.setDefaultButton(self.w.submitButton)
        self.loadPreferences()
        self.w.bind("close", self.savePreferences)

        # make sure window is large enough to show all masters
        x, y, w, h = self.w.getPosSize()
        if w < minWinSize[0] and h < minWinSize[1]:
            self.w.setPosSize((x, y, minWinSize[0], minWinSize[1]),
                              animate=False)
        elif w < minWinSize[0]:
            self.w.setPosSize((x, y, minWinSize[0], h), animate=False)
        elif h < minWinSize[1]:
            self.w.setPosSize((x, y, w, minWinSize[1]), animate=False)

        self.w.open()
        self.w.makeKey()
Esempio n. 32
0
class SliderGroup(Group):
    def __init__(self, posSize, text, minValue, maxValue, value, callback):
        Group.__init__(self, posSize)
        self.text = TextBox((0, 0, -0, 20), text)
        self.slider = Slider((2, 20, -60, 17),
                             minValue=minValue,
                             maxValue=maxValue,
                             value=value,
                             sizeStyle="small",
                             callback=self.sliderChanged)
        self.edit = EditText((-40, 15, -0, 22),
                             text=str(value),
                             placeholder=str(value),
                             callback=self.editChanged)
        self.callback = callback

    def sliderChanged(self, sender):
        self.edit.set(str(int(self.slider.get())))
        self.callback(sender)

    def editChanged(self, sender):
        try:
            value = int(float(self.edit.get()))
        except ValueError:
            value = int(self.edit.getPlaceholder())
            self.edit.set(value)
        self.slider.set(value)

    def enable(self):
        self.text.enable(True)
        self.slider.enable(True)
        self.edit.enable(True)

    def disable(self):
        self.text.enable(False)
        self.slider.enable(False)
        self.edit.enable(False)
Esempio n. 33
0
 def __init__(self,
              posSize,
              label,
              minValue,
              value,
              maxValue,
              continuous=True,
              callback=None):
     super().__init__(posSize)
     self._callback = callback
     self.label = TextBox((0, 0, 0, 20), label)
     self.slider = Slider((0, 18, -60, 20),
                          value=minValue,
                          minValue=minValue,
                          maxValue=maxValue,
                          continuous=continuous,
                          callback=self._sliderCallback)
     self.editField = EditText((-50, 16, 0, 24),
                               "",
                               continuous=False,
                               callback=self._editFieldCallback)
     self.editField._nsObject.setAlignment_(AppKit.NSRightTextAlignment)
     self._setSliderFromValue(value)
     self._setEditFieldFromValue(value)
 def __init__(self, posSize, minValue, maxValue, value, callback):
     Group.__init__(self, posSize)
     self.slider = Slider(
         (2, 3, -55, 17),
         minValue=minValue,
         maxValue=maxValue,
         value=value,
         sizeStyle="regular",
         callback=self.sliderChanged)
     self.edit = EditText(
         (-40, 0, -0, 22),
         text=str(value),
         placeholder=str(value),
         callback=self.editChanged)
     self.callback = callback
Esempio n. 35
0
    def __init__(self):
        self.font_order = []
        self.position = "left"
        
        L = 0  # left
        T = 0  # top
        W = 200 # width
        H = 300  # height
        p = 10 # padding
        buttonHeight = 20

        title = "☎️ Hotline Glyph"
        self.w = Window((W, H), title, minSize=(W/3, H/3))

        self.w.fileList = List(
            (L, T, -0, -(p * 3 + buttonHeight * 2)),
            self.font_order,
            columnDescriptions=[
                {"title": "✓", "width":20},
                {"title": "File name"},
                ], # files
            showColumnTitles=False,
            allowsMultipleSelection=True,
            enableDelete=True,
            otherApplicationDropSettings = dict(
                type=NSFilenamesPboardType,
                operation=NSDragOperationCopy,
                callback=self.dropCallback),
            dragSettings=dict(type="RangeType", 
                                callback=self.font_list_drag_callback),
            selfDropSettings=dict(type="RangeType", 
                                operation=NSDragOperationMove, 
                                callback=self.font_list_drop_callback)
            )

        self.w.editText = EditText((p, -(p * 2 + buttonHeight * 2), -p, buttonHeight))

        self.w.draw = CheckBox((p, -(p + buttonHeight), -p, buttonHeight), 'show', value=True, callback=self.updateViewCallback)

        self.w.toLeftbutton = SquareButton((-p*6, -(p + buttonHeight), p*2, buttonHeight), "←", sizeStyle='small', callback=self.toLeft)
        self.w.toRightbutton = SquareButton((-p*3, -(p + buttonHeight), p*2, buttonHeight), "➝", sizeStyle='small', callback=self.toRight)

        addObserver(self, "drawPreviewRef", "drawBackground")
        addObserver(self, "drawRef", "drawPreview")

        self.setUpBaseWindowBehavior() # Needed for the windowCloseCallback

        self.w.open()
 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)
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:
            if "point" in title:
                title = title.lstrip("point")
                title = "p. " + title
            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.parameter.bind(self.checkBox)
        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)
        self.parameter.bind(self.slider)
        self.parameter.bind(self.textInput)

    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 setFree(self, sender):
        value = 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 ParameterTextInput(Group):

    def __init__(self, parameter, posSize, text='', callback=None, continuous=False, showRelativeValue=False):
        super(ParameterTextInput, self).__init__(posSize)
        self.parameter = parameter
        rel = self._relValue()
        self.callback = callback
        self.textInput = EditText((0, 0, -40, -0), text=text, callback=self._valueInput, continuous=continuous)
        self.relInfo = TextBox((-35, 5, -0, -0), rel, alignment='left', sizeStyle='small')
        self.showRelativeValue(showRelativeValue)
        self.vanillaInputs = [self.textInput]
        self.parameter.bind(self)

    def get(self):
        return self.parameter.get()

    def enable(self, value):
        for item in self.vanillaInputs:
            item.enable(value)

    def _valueInput(self, sender):
        value = sender.get()
        parameter = self.parameter
        if value == 'R' and parameter.hasMaster:
            parameter.reset()
            parameter.update()
            if self.callback is not None:
                self.callback(parameter)
            return
        elif value != '*':
            parameter.setInput(value, sender=sender)
            parameter.update()
            if self.callback is not None:
                self.callback(parameter)
        rel = self._relValue()
        self.relInfo.set(rel)

    def showRelativeValue(self, b):
        self.relInfo.show(b)

    def setFree(self, sender):
        value = bool(sender.get())
        self.parameter.setFree(value)

    def update(self, sender):
        value = self.parameter.get()
        self.textInput.set(str(value))
        self._updateRelValue()

    def _updateRelValue(self):
        rel = self._relValue()
        self.relInfo.set(rel)

    def _relValue(self):
        parameter = self.parameter
        rel = '-'
        if parameter.hasMaster:
            if parameter.mode == 'ratio':
                rel = '%s' % (parameter.getRatio())
            elif parameter.mode == 'offset':
                offsetValue = int(parameter.getOffset())
                sign = '+' if offsetValue >= 0 else ''
                rel = '%s%s' % (sign, offsetValue)
        return rel