Writing python style guide

Human Interface Guidelines

When building extensions is advised to use the extension builder and follow the RoboFont extension spec.

An observer has to be subscribed to an specific event. When the event happens the observer will get a notification.

from mojo.events import addObserver

class myEventObserver:
    def __init__(self):
        addObserver(self, "myObserver", "mouseDown")

    def myObserver(self, info):
        print info #do something...

myEventObserver()

Real live example drawing a reference to the current glyph in the Glyph View using the unicode value of the glyph:

"""
An example script of adding an observers and do *something* 

It draws a simple unicode reference of an existing installed font.
"""

from mojo.events import addObserver
from mojo.drawingTools import *

class DrawReferenceGlyph(object):
    
    def __init__(self):
        addObserver(self, "drawReferenceGlyph", "draw")

    def drawReferenceGlyph(self, info):
        
        glyph = info["glyph"]
        
        r = 0
        g = 0
        b = 0
        a = .5
        
        if glyph is not None and glyph.unicode is not None:
            t = unichr(glyph.unicode)
            
            font("Georgia", 100)
            stroke(None)
            fill(r, g, b, a)
            text(t, (glyph.width + 10, 10))
            
            
DrawReferenceGlyph()

Observers

• addObserver(observer, method, event)
  Adds an observer for an event to the observer method. 
• removeObserver(observer, event)
  Removes the observer for an event.

Events

Any observer can subscriber to these events. The callback receives a dictionary object containing additional objects related to the send event.

All notification dictionaries contains the following keys:

glyph the current/edited/active glyph
tool the current tool
view the current glyph view

• applicationDidFinishLaunching
  Send when RoboFont did finish launching.
• applicationDidBecomeActive
  Send when RoboFont become the active application.
• applicationWillResignActive
  Send when RoboFont resigns being the active application.
• binaryFontWillOpen
  Send when a binary font will open.
  font  the font object
  source the fontTools source object
  format the format of the source font
• fontWillSave
  Send when a font will save.
  font the font object
  path the path where the font will be saved
• fontDidSave
  Send when a font is done saving.
  font the font object
  path the path where the font did save
• fontWillClose
  Send when a font will close.
  font the font object
• fontDidClose
  Send when a font did close.
  font the font object
• newFontWillOpen
  Send when a new font will open. 
  font the font object
• newFontDidOpen
  Send when a new font did open.
  font the font object
• fontWillOpen
  Send when a font will open.
  font the font object
• fontDidOpen
  Send when a font did open.
  font the font object
• fontWillAutoSave
  Send when a font will auto save.
  font the font object
  path the path where the font did autosave
• fontDidAutoSave
  Send when a font did auto save.
  font the font object
  path the path where the font did autosave
• fontDidChangeExternally
  Send when a font did change externally, outside RoboFont.
  font the font object
• fontWillGenerate
  Send when a font will generate.
  font the font object
  format the format of the generated font
  path the path where the binary font will save
• fontDidGenerate
  Send when a font did generate.
  font the font object
  format the format of the generated font
  path the path where the binary font will save
• currentGlyphChanged
  Send when the current glyph changed, this can be either in the glyph view or in the font overview.
• viewWillChangeGlyph
  Send when the glyph view will switch to an other glyph.
• viewDidChangeGlyph
  Send when the glyph view did switch to an other glyph.
• glyphWindowWillOpen
  Send when a glyph window will open.
  window the glyph window that will open
• glyphWindowDidOpen
  Send when a glyph window did open.
  window the glyph window that did open
• glyphWindowWillClose
  Send when a glyph window will close.
  window the glyph window that will close
• spaceCenterWillOpen
  Send when a space center will open.
  window the space center window that will open
• spaceCenterDidOpen
  Send when a space center did open.
  window the space center window that did open
• spaceCenterWillClose
  Send when a space center will close.
  window the space center window that will close
• transformChanged
  Send when a transformation is applied to a glyph.
  scale
  translate
  rotate
  skew
  repeatMatrix
• extensionDidGenerate
  Send when an extension did generate.
  path the path to the extension
• spaceCenterDraw
  Send when a space center draws a glyph, this can happen a lot so be care full.
  scale the drawing scale
  spaceCenter the space center 
  selected a bool if the glyph is selected in the space center
• spaceCenterKeyDown
  Send on a key down in a space center.
  event the NSEvent object
  spaceCenter the space center 
• spaceCenterKeyUp
  Send on a key up in space center.
  event the NSEvent object
  spaceCenter the space center 
• drawPreview
  Send when the glyph view draws a preview.
  scale
• drawBackground
  Send when the glyph view draws the background, before the actual glyph data.
  scale
• draw
  Send when the glyph view draw the glyph data.
  scale
• drawInactive
  Send when the glyph view draw when the glyph window is not the active one.
  scale
• mouseDown
  Send on mouse down in the glyph view.
  point the point coordinates of the mouse in the glyph coordinate system
  clickCount the click count
  offset offset of the zero zero point in the glyph view
  event the NSEvent object
• rightMouseDown
  Send on right mouse down in the glyph view.
  point the point coordinates of the mouse in the glyph coordinate system
  event the NSEvent object
• mouseDragged
  Send on a mouse drag in the glyph view.
  point the point coordinates of the mouse in the glyph coordinate system
  offset offset of the zero zero point in the glyph view
  delta delta of the drag form the first click
  event the NSEvent object
• rightMouseDragged
  Send on a right mouse drag in the glyph view.
  point the point coordinates of the mouse in the glyph coordinate system
  offset offset of the zero zero point in the glyph view
  event the NSEvent object
• mouseUp
  Send on a mouse up in the glyph view.
  point the point coordinates of the mouse in the glyph coordinate system
  offset offset of the zero zero point in the glyph view
  event the NSEvent object
• keyDown
  Send on a key down in the glyph view.
  event the NSEvent object
• keyUp
  Send on a key up in the glyph view.
  event the NSEvent object
• modifiersChanged
  Send when the modifier changed in the glyph view (command, alt, control and shift keys)
  event the NSEvent object
• toggleTransformMode
  Send when the glyph view toggles from or out the transform mode.
• acceptMenuEditCallbacks
  Send when a contextual menu is been build.
  item a menu item
• selectAll
  Send on select all in the glyph view.
• deselectAll
  Send on deselect all in the glyph view.
• selectAllAlternate
  Send on select all alternate in the glyph view.
• copy
  Send on copy in the glyph view.
• copyAsComponent
  Send on copy as component in the glyph view.
• cut
  Send on cut in the glyph view.
• delete
  Send on delete in the glyph view.
• paste
  Send on paste in the glyph view.

You can add custom tools to RoboFont, by subclassing the BaseEventTool class or an existing core tool. RoboFont core tools are BezierDrawingTool, EditingTool, MeasurementTool and SliceTool. They are available through the mojo.events module.

from mojo.events import BaseEventTool 
## or subclassing a core tool
from mojo.events import BezierDrawingTool, EditingTool, MeasurementTool, SliceTool

This is an easy example, with most event callback. You need the installTool to tell RoboFont you want to install in a new tool.
Custom tools can also be activated at start up through the preferences.

example:

from mojo.events import BaseEventTool, installTool
from AppKit import *

class MyEvent(BaseEventTool):

    def becomeActive(self):
        print "active"

    def becomeInactive(self):
        print "inactive"

    def mouseDown(self, point, clickCount):
        # getGLyph returns the current glyph as robofab object
        print "mouseDown", self.getGlyph(), clickCount

    def rightMouseDown(self, point, event):
        print "rightMouseDown"

    def mouseDragged(self, point, delta):
        print "mousedragged"

    def rightMouseDragged(self, point, delta):
        print "rightMouseDragged"

    def mouseUp(self, point):
        print "mouseup"

    def keyDown(self, event):
        # a dict of all modifiers, shift, command, alt, option
        print "keyDown", self.getModifiers() 

    def keyUp(self, event):
        print "keyUp"

    def modifiersChanged(self):
        print "modifiersChanged"

    def draw(self, scale):
        print "draw", self.isDragging()
        if self.isDragging():
            ## draw a red dot when dragging
            r = 50
            NSColor.redColor().set()
            x, y = self.currentPoint
            NSBezierPath.bezierPathWithOvalInRect_(((x-r, y-r), (r*2, r*2))).fill()

    def drawBackground(self, scale):
        print "drawBackground here"

    #def getDefaultCursor(self):
    #   this will be the cursor default is an arrow
    #   return aNSCursor
    #def getToolbarIcon(self):
    #   this is setting the icon in the toolbar default is an arrow
    #   return aNSImage

    def getToolbarTip(self):
        return "My Event Tool Bar Tip"

    #notifications

    def viewDidChangeGlyph(self):
        print "view changed glyph"

    def preferencesChanged(self):
        print "prefs changed"

installTool(MyEvent())

Tools Methods

• getGlyph()
  Returns the current glyph used by the tool 
• getNSView()
  Returns the current glyph view 
• getCurrentEvent()
  Returns the current NSEvent.
• refreshView()
  updates the current glyph view
• setCursor(cursor=None)
  Sets the cursor as current cursor (needs a NSCursor object), if None is given it will be return to default cursor of the tool
• isDraggin()
  Returns a bool if the tool is draggin
• zoomRect(offset=None)
  zoom to a given rect
• toggleTransformMode()
  Toggle the transform
• getDefaultCursor()
  returns the default cursor for the tool, this must be overwritten
• getToolbarIcon()
  returns the toolbar icon for the tool, this must be overwritten
• mouseDown(point, clickCount)
  send a mouse down notification to the tool, with the mouse point in the and the clickCount
• rightMouseDown(point, clickCount)
  send a right mouse down notification to the tool, with the mouse point in the and the clickCount
• modifyPoint(point)
  modify the point coordinates
  In the embedded tools this is used to modify the point when fe. on shiftDown
• mouseMoved(point)
  send a mouse moved notification to the tool, be careful and optimize the code cause the mouse moves all the time
• mouseDragged(point, delta)
  send a mouse dragged notification to the tool, the delta is the difference between the previous drag point
• rightMouseDragged(point, delta)
  send a right mouse dragged notification to the tool, the delta is the difference between the previous drag point 
• mouseUp(point)
  send a mouse up notification to the tool
• isDragging()
  returns a bools if the tool is in a dragging event
• keyDown(event)
  send a key down notification to the tool, possible to get the pressed characters by event.characters()
• keyUp(event)
  send a key up notification to the tool 
• modifiersChanged()
  send a modifiers changed notification to the tool, happens when shift, command, control, alt is changed
• getModifiers()
  returns a dictionary with all the modifiers keys as bools. True when pressed down, keys are: shiftDown, commandDown, optionDown, controlDown
• getArrowsKeys()
  returns a dictionary with all the arrows keys as bools. True when pressed down, keys are: up, down, left, right

Tools Menu methods

• acceptMenuEditCallbacks()
  Overwrite this if you want your tool to accept menu callbacks.
• selectAll()
  perform a select all in your tool, don't overwrite it if you don't want to do anything with it
• selecteAllAlternate()
  perform a select all in your tool with alt key down, don't overwrite it if you don't want to do anything with it
• deselectAll()
  perform a deselect all in your tool, don't overwrite it if you don't want to do anything with it
• copy()
• copyAsComponent()
• cut()
  
• delete()
• paste()
• additionContectualMenuItems()
  called when a contextual menu is created, it is required to return a list of tuples with a title string and a callback function
  example [("additional stuff", myObject.myAdditionMenuCallback), ]

Tools Draw Methods

• draw(scale)
  draw in the glyph
• drawBackground(scale)
  draw in the background of the glyph view
• drawPreview(scale)
  additional drawing in the glyph view while holding the glyph view preview key
• drawInactive(scale, glyph, view)
  additional drawing in the glyph view when the glyph view is not active, the glyph will not be the current glyph, same for the view
• drawBackgroundSelection(scale)
  draw in the background, should be related to a selection
• drawSelection(scale, glyph, view)
  draw the selection for a glyph in a view

Space Center

• spaceCenterDraw(glyph, scale, selected, spaceCenter)
  draw in the space center for given glyph
• spaceCenterKeyDown(glyph, event, spaceCenter)
  send a key down notification to the tool, possible to get the pressed characters by event.characters()
• spaceCenterKeyUp(glyph, event, spaceCenter)
  send a key up notification to the tool 

Tools Notifications Methods

• viewWillChangeGlyph()
  the glyph in the current view will change
• viewDidChangGlyph()
  the glyph in the current view did change
• currentGlyphChanged()
  the current glyph in the app changed
• preferencesChanged()
  the user defaults changed
• becomeInactive()
  the tool becomes inactive
• becomeActive()
  the tool becomes active
• didUndo()
  a undo notification when the undo is already performed
• glyphWindowWillOpen()
  a new glyph window will open
• glyphWindowDidOpen()
  a new glyph window did open
• glyphWindowWillClose()
  a glyph window will close
• spaceCenterWillOpen()
  a new Space Center will open
• spaceCenterDidOpen()
  a new Space Center did open
• spaceCenterWillClose()
  a Space Center will close
• fontWillOpen(font)
  a UFO will been opened
• fontDidOpen(font)
  a UFO did open 
• newFontWillOpen(font)
  a new UFO will been created
• newFontDidOpen(font)
  a new UFO is been created 
• binaryFontWillOpen(font, source, format)
  a binary font will open
  the source is the fontTools font object 
• fontWillClose(font)
  a UFO is been closed
• applicationDidFinishLauching() 
  the app is ready launching
• applicationDidBecomeActive()
  the app becomes active
• applicationWillResignActive()
  the app will resign being active
• fontBecameCurrent(font)
  a font becomes active
• fontResignCurrent(font) 
  a font resigns being active 
• fontWillAutoSave(font)
  font will auto save
• fontDidAutoSave(font)
  font did auto save
• fontWillSave(font, path)
  font will save
• fontDidSave(font, path)
  font did save
• fontWillGenerate(font, format, path)
  font will generate to a binary format
• fontDidGenerate(font, format, path) 
  font did generate to a binary format
• fontDidChangeExternally(font)
  An external change to the font has happend 

Tools Attributes

• allPointList
  A list of clicked and dragged points used by the tool
• mouseDownPoints
  A list of clicked points used by the tool
• shiftDown
  Bool if shift is down 
• commandDown
  Bool if command is down 
• optionDown
  Bool if option is down 
• controlDown
  Bool if control is down 
• spaceBarDown
  Bool if space is down 
• arrowKeysDown
  a dictionary of bools with keys: up, down, left, right
• currentPoint
  returns the last points from the allPointsList
• selection
  returns the current glyph selection object 

There are a number of tools embedded to help you to build plugins and superior scripts.

• python
• robofab
• defcon
• fontTools
• dialogKit
• vanilla
• defconAppKit
• woffTools
• compositor
• ufo2fdk

Base Objects

Allmost every class used has some additional attributes.

Methods

• addObserver(observer, methodName, notification)
  adds an observer to the object that notifies the methodName of the observer for a given notification
• removeObserver(observer, notification)
  removes the observer for a  given notification

Font Object

Create a new font object:

• RFont(path=None, showUI=True)
  ShowUI will toggle the creating of all interface objects around a font.

Methods

• document()
  returns the related NSDocument 
• renameGlyph(oldName, newName, renameComponents=True, renameGroups=True, renameKerning=True)
  Rename a glyph in the font.
  Optionally the glyph can be renamed in all component references, groups and kerning. 
• generate(path, format, decompose=False, checkOutlines=False, autohint=False, releaseMode=False, glyphOrder=None, progressBar=None)
  Generate a font binary to the given path with the given format ("otf", "ttf", "pfa") 
  Adding a progressBar object will show you the progress during compiling the font.
• removeOverlap()
  removes all overlaps in every glyphs
• extremePoints()
  adds extremes points for every glyph 
• testInstall()
  test instals the font, it returns the ID of the installed font on the os.
• removeLayer(layerName)
  removes a complete layer, to create a layer just ask any glyph.getLayer("myLayerName")
• addGuide((x, y), angle, name="")
  adds a guide at point x, y with angle and name
  returning the created guide 
• removeGuide(guide)
  gwill remove the guide from the font 
• update()
  tell the UI that a font has changed directly
• prepareUndo(undoTitle="")
  This marks to glyph to be ready that a action begins and it should be recorded to create an undo item when its done
• performUndo()
  creates the undo item
• setLayerDisplay(layerName, option, value)
  set display options for layers option: Fill, Stroke, Points, Coordinates

Attributes

Glyph Object

Methods

mojo is a module that host lots of useful helper scripts.

• mojo.compile
• mojo.extensions
• mojo.canvas
• mojo.UI
• mojo.tools
• mojo.roboFont
• mojo.glyphPreview
• mojo.events
• mojo.drawingTools

from mojo.compile import *

• FDKVersion
  Returns the version of the embedded FDK
• makeotf(outputPath, outlineSourcePath=None, featuresPath=None, glyphOrderPath=None, menuNamePath=None, fontInfoPath=None, releaseMode=False)
  FDK makeotf
• checkOutlines(fontPath, removeOverlap=True, correctContourDirection=True)
  FDK checkOutlines
• otf2pfa(sourcePath, destinationPath)
  Convert a otf to pfa using FDK. 
• otf2svg(sourcePath, destinationPath)
  Convert a otf to a svg font using FDK.
• autohint(fontPath)
  Autohint a postscript flavored font. 
• hasTTFAutoHint()
  Return a boolean if ttfautohint is installed. 
• ttfautohint(fontPath)
  Use ttf autohint if its locally installed to autohint a ttf file. 
• stemHist(fontPath, userCurves=None, blueZones=False)
  Use FDK stemhist on a binary font. See stemHist help for details.
• setUseEmbeddedFDK(value)
  Set a boolean if RoboFont should use the embedded FDK. 
• getUseEmbeddedFDK()
  Returns a boolean if RoboFont will use the embedded FDK.  
• executeCommand(command, shell=False)
  Execute commands in the terminal. Commands must be a list of arguments.
  Optionally execute in the shell instead of inside RoboFont

from mojo.extensions import *

Classes

• ExtensionBundle(name=None, path=None, libName="lib", htmlName="html", indexHTMLName="index.html", resourcesName="Resources")
  An extension bundle objects allowing access to different parts of an extension.
   
  initiate an ExtensionBundle object
  name: name of an extension (either name or path is required)
  path: path to an extension (either name or path is required) 
   
  version
  returns the version of the extension
  name
  returns the name of the extension
  developer
  returns the developer of the extension
  developerURL
  returns the developer URL of the extension
  requiresVersionMajor
  returns the required major version number of RoboFont
  requiresVersionMinor
  returns the required minor version number of RoboFont
  addToMenu
  returns a bool if the bundle should be added to the extension menu
  launchAtStartUp
  returns a bool if the bundle should be launched at start up
  mainScript
  returns the filename of the main script

  timeStamp
  returns the time stamp, stamped when the extension is build
   
  get(name, ext='*')
  returns the file within the extension, if its is an image it will return the NSImage object around that image.
  install()
  installs the extension
  deinstall()
  de-installs the extension 
  openHelp()
  Opens the help HTML in an HTMLHelpWindow
  validate()
  validates the extension
  validateErrors()
  returns a string of validation errors
  bundlePath()
  returns the path of the extension bundle
  libPath()
  returns the path of the lib folder inside the bundle
  HTMLPath()
  returns the path of the HTML folder inside the bundle
  resourcesPath()
  returns the path of the Resources folder inside the bundle
  infoDictionaryPath()
  returns the path of the info.plist inside the bundle
  mainScriptPath()
  returns the path of the main script
  hasHTML()
  returns a bool if the extension has HTML help
  HTMLIndexPath()
  returns the path of the index.html file
  bundleExists()
  returns if a bool if the extension bundle exists on disk  

  allExtensions()
  a class method returns all installed extensions
  Methods

• getExtensionDefault(key, fallback=None)
  returns the value for key from the extension user defaults
  if the key isn't used it returns the fallback
• setExtensionDefault(key, value)
  set the value for key in the extensions user defaults
• getExtensionDefaultColor(key, fallback=None)
  returns an NSColor object for key from the extension user defaults
• setExtensionDefaultColor(key, fallback=None)
  set an NSColor for key in the extensions user defaults
• registerExentionsDefaults(defaults)
  register a dict with keys and values as defaults in the extension user defaults 

from mojo.canvas import Canvas

A vanilla object that sends all user input events to a given delegate.

Canvas(posSize,
       delegate=None,
       canvasSize=(1000, 1000),
       acceptsMouseMoved=False,
       hasHorizontalScroller=True,
       hasVerticalScroller=True,
       autohidesScrollers=False,
       backgroundColor=None,
       drawsBackground=True)

Methods

All events a delegate could have that can be used:

• draw()
  Callback when the canvas get drawn.
• becomeFirstResponder(event)
  Callback when the canvas becomes the first responder, when it starts to receive user interaction callbacks.
• resignFirstResponder(event)
  Callback when the canvas resigns the first responder, when the canvas will not longer receive user interaction callbacks. 
• mouseDown(event)
  Callback when the user hit the canvas with the mouse. 
• mouseDragged(event)
  Callback when the user drag the mouse around in the canvas. 
• mouseUp(event)
  Callback when the user lifts up the mouse from the canvas. 
• mouseMoved(event)
  Callback when the user moves the mouse in de canvas. Be careful this is called frequently. (only when accepsMouseMoved is set True)
• rightMouseDown(event)
  Callback when the user clicks inside the canvas with the right mouse button. 
• rightMouseDragged(event)
  Callback when the users is dragging in the canvas with the right mouse button down.  
• rightMouseUp(event)
  Callback when the users lift up the right mouse button from the canvas. 
• keyDown(event)
  Callback when the users hits a key.
  The event object has a characters() method returns the pressed character key.
• keyUp(event)
  Callback when the users lift up the key. 
• flagChanged(event)
  Callback when the users changed a modifier flag:
  command  shift  control  alt

Example

from mojo.canvas import Canvas
from mojo.drawingTools import *
from vanilla import *

class ExampleWindow:

    def __init__(self):
        self.size = 50

        self.w = Window((400, 400), minSize=(200, 200))
        self.w.slider = Slider((10, 5, -10, 22),
                          value=self.size,
                          callback=self.sliderCallback)
        self.w.canvas = Canvas((0, 30, -0, -0), delegate=self)
        self.w.open()

    def sliderCallback(self, sender):
        self.size = sender.get()
        self.w.canvas.update()

    def draw(self):
        rect(10, 10, self.size, self.size)

ExampleWindow()

from mojo.UI import *

Classes

• AccordionView(posSize, descriptions, backgroundColor)
  A vanilla object hosting different kinds of other vanilla objects (like vanilla.List, vanilla.TextEditor, ....) in an accordion view.
   
  Initiate a AccordionView
  posSize: a tuple of four, setting the size
  descriptions: list of options for each item in the accordionView (see example) 
  backgroundColor: a NSColor object used as background color
   

  from mojo.UI import AccordionView
  from vanilla import *
  
  class MyInspector:
  
      def __init__(self):
  
          self.w = FloatingWindow((200, 600))
  
          self.firstItem = TextEditor((10, 10, -10, -10))
  
          self.secondItem = List((0, 0, -0, -0), ["a", "b", "c"])
  
          self.thirdItem = Tabs((10, 10, -10, -10), ["1", "2", "3"])
          
          self.fourthItem = Group((0, 0, -0, -0))
          
          self.fourthItem.checkBox = CheckBox((10, 10, 100, 22), "CheckBox")
          self.fourthItem.editText = EditText((10, 40, -10, 22))
          
  
          descriptions = [
                         dict(label="first item", view=self.firstItem, size=200, collapsed=False, canResize=False),
                         dict(label="second item", view=self.secondItem, minSize=100, size=140, collapsed=True, canResize=True),
                         dict(label="third item", view=self.thirdItem, minSize=100, size=140, collapsed=True, canResize=False),
                         dict(label="fourth item", view=self.fourthItem, size=140, collapsed=False, canResize=False)
                         ]
  
          self.w.accordionView = AccordionView((0, 0, -0, -0), descriptions)
  
          self.w.open()
  
  MyInspector()

• HTMLView(posSize)
  Initiate a HTMLView
  posSize: a tuple of four, setting the size
   
  setHTMLPath(url)
  Set the url in the HTMLView
  goBack()
  Go forward in the history of the HTMLView
  goForward()
  Go forward in the history of the HTMLView
  clearHistory()
  Clear the history of the HTMLView 
• HelpWindow(htmlPath, title="help", developer=None, developerURL=None)
  Initiate a HelpWindow
  htmlPath: html help path
  title: title of the help window
  developer: a string with the name of the developer, optionally
  developerURL: a URL link to the developer, optionally
   
  set(htmlPath)
  set a html path in the HTMLView of the HelpWindow 
   

  from mojo.UI import HelpWindow
  
  HelpWindow("http://robofont.com")

• SmartSet(smartSet=dict())
  Initiate a smart set object
  smartSet: a dictionary containing smart set data
   
  name
  Set or get the smart set name. 
  glyphNames
  Set or get the a list of glyph names used by the smart set. 
  query
  Set or get a search query.
• MultiLineView(posSize, pointSize=150, lineHeight=50, doubleClickCallbak=None, applyKerning=None, bordered=False, hasHorizontalScroller=False, hasVerticalScroller=True, displayOptions=None, selectionCallback=None, menuForEventCallback=None)
  A multi glyph line view vanilla object, this is the same objects that is used to build a Space Center.
  Initiate a multi line view object:
  posSize: a tuple of four, setting the size
  pointSize: the initial point size, optionally
  lineHeight: the initial lineHeight, , optionally
  doubleClickCallback: callback for a double click event
  applyKerning: enable kerning the view, optionally
  bordered: set a border around the view
  hasHorizontalScroller: set the horizontal scroller
  hasVerticalScroller: set the vertical scroller
  displayOptions: a dict with multi line view display options
  selectionCallback: callback when a glyph get selected
  menuForEventCallback: callback when a contextual menu will we used, required to return a NSMenu object

   
  get()
  Returns all glyphs in the line view
  set(glyphs)
  Sets a list of glyphs in the line view
  setFont(font)
  The glyph line view needs a font as fallback and for font metrics
  createNewLineGlyph()
  Returns a special glyph object that acts like a new line
  createEmptyGlyph(name)
  Returns a special glyph object that acts like an empty glyph (use this as fallback when a glyph is not in the font)
  setPointSize(pointSize)
  Sets the point size
  setLIneHeight(lineHeight)
  Sets the line height
  setApplyKerning(value)
  Sets if kerning is applied in the line view
  getDisplayStates()
  Returns a dict with all display options
  setDisplayStates(options)
  Sets a dict of line view display options
  setLeftToRight(value)
  Sets the reading direction of the glyph line view
   

  from mojo.UI import MultiLineView
  from vanilla import *
      
  class MyOwnSpaceCenter:
  
      def __init__(self, font):
  
          self.w = Window((600, 400), minSize=(300, 300))
  
          self.w.lineView = MultiLineView((0, 0, -0, -0), 
                                              pointSize=30, 
                                              selectionCallback=self.lineViewSelectionCallback)
          self.w.lineView.setFont(font)
  
          glyphs = []
          for glyphName in font.glyphOrder:
              glyphs.append(font[glyphName])
  
          self.w.lineView.set(glyphs)
  
          self.w.open()
      
      def lineViewSelectionCallback(self, sender):
          print sender.getSelectedGlyph()
  
  MyOwnSpaceCenter(CurrentFont())

Methods

• GlyphViewDisplaySettings(settings)
  Set display options for the current glyphview. Input as dict. These settings will be default for the glyphview. All options are: Fill, Stroke, Metrics, On Curve Points, Off Curve Points, Point Coordinates, Anchors, Curve Length, Blues, Family Blues, Rulers
• AllSpaceCenters()
  Get all open space centers
• CurrentSpaceCenter()
  methods:
  get()
  returns a list of glyph names in the space center
  getRaw()
  returns a string from the input of the space center
  set(glyphNames)
  sets the list of glyphNames in the space center
  setRaw(text)
  set a string in to the main input of the space center
  getTracking()
  returns the tracking used
  setTracking(value)
  set a tracking value between the glyphs
  getLeftToRight()
  returns the reading direction
  setLeftToRight(value)
  sets the reading direction
  getPointSize()
  returns the point size
  setPointSize(value)
  sets the points size
• SpaceCenterToPDF(path, spaceCenter=None)
  Saves the Space Center to a pdf with vector data, if a spaceCenter is not provided the CurrentSpaceCenter() will be used.
• AllGlyphWindows()
  Returns all open glyph windows.
• CurrentGlyphWindow()
  Returns the current glyph window.
• GlyphWindowToPDF(path, glyphWindow=None)
  Saves the Glyph Window to a pdf with vector data, if a Glyph Window is not provided the CurrentGlyphWindow() will be used.
• AllFontWindows()
  Returns all open font windows. 
• CurrentFontWindow()
  Returns the current font window. 
• OpenGlyphWindow(glyph=None, newWindow=False)
  Opens a new glyph window
  glyph: a given glyph object
  newWindow: open a new window, even if there is already a glyph window open
• OpenSpaceCenter(font, newWindow=False)
  Opens a new Space Center
  font: a given font object
  newWindow: open a new window, even if there is already a Space Center winow open
• OutputWindow()
  Returns the output window
  write(text)
  Write a string in the output window
  clear()
  Clears the output window
• SetCurrentGlyphByName(glyphName)
  Sets a glyph name in the current glyph editor
• SetCurrentLayerByName(layerName)
  Sets the current layer by a layerName in the current glyph editor
• UpdateCurrentGlyphView()
  Updates the current glyph editor
• SetCurrentGlyphByName(glyphName)
  Sets the current glyph by name
• SetCurrentLayerByName(layerName)
  Sets the current layer by layer name 
• addSmartSet(smartSet, index=-1)
  Add a smart set object. 
  Optionally set an index to insert the smart set object. 
• removeSmartSet(smartSetName)
  Remove a smart set. 
• getSmartSets()
  Get all current smart sets. 
• setSmartSets(smartSets)
  Set a list of smart sets. 
• setDefaultCharacterSet(characterSetName)
  Set the default character set by name as defined in the preferences. 
• getDefaultCharacterSet()
  Get the current default character set name. 
• addCharacterSet(characterSetName, glyphNames, useAsDefault=False)
  Add a character set with a name and a list of glyph names. 
• removeCharacterSet(characterSetName)
  Remove a character set by name. 
• getCharacterSets()
  Get all characeter sets as a dictionairy. 
• setCharacterSets(characterSets)
  Set a dictionary of character sets. 
• setMaxAmountOfVisibleTools(value)
  Set the maximum amount of visible tools in the toolbar.
  Must be in integer. 
• getMaxAmountOfVisibleTools()
  Get the maximum amount of visible tools in the toolbar. 
• setScriptingMenuNamingShortKey(data)
  Get the scripting menu names and shortkey dictionary. 
• setScriptingMenuNamingShortKeyForPath(path, preferredName, shortkey=None)
  Set the scripting menu names and shortkey dictionary. 
• exportPreferences(path)
  Export all user preferences to a path. 
• importPreferences(path)
  Import user preferences from a path. 

from mojo.tools import IntersectGlyphWithLine

• IntersectGlyphWithLine(glyph, ((sx, sy), (ex, ey)), canHaveComponent=False, addSideBearings=False)
  intersects a glyph with a given line. 
• union(glyph, subjectContours, clipContours, roundCoordinates=None)
  perform a union with subject contours and clip contours
  glyph: destination glyph
  subjectContours, clipContours: for union its not really important so you can mix both
  roundCoordinates: optionally round the result
• intersect(glyph, subjectContours, clipContours, roundCoordinates=None)
  perform a intersection with subject contours and clip contours
  glyph: destination glyph
  subjectContours: the subject contours
  clipContours: the clip contours that will intersect with the subject contours
  roundCoordinates: optionally round the result
• difference(glyph, subjectContours, clipContours, roundCoordinates=None)
  perform a difference with subject contours and clip contours
  glyph: destination glyph
  subjectContours: the subject contours
  clipContours: the clip contours that will difference with the subject contours
  roundCoordinates: optionally round the result
• intersection(glyph, subjectContours, clipContours, roundCoordinates=None)
  perform a intersection with subject contours and clip contours
  glyph: destination glyph
  subjectContours: the subject contours
  clipContours: the clip contours that will intersection with the subject contours
  roundCoordinates: optionally round the result
• xor(glyph, subjectContours, clipContours, roundCoordinates=None)
  perform a xor with subject contours and clip contours
  glyph: destination glyph
  subjectContours: the subject contours
  clipContours: the clip contours that will xor with the subject contours
  roundCoordinates: optionally round the result

Classes

• BooleanGlyph(glyph, roundCoordinates=None)
  A object that can be used to perform simple math operations and acts like a glyph object. 
  union ⇢ BooleanGlyph(glyph) | BooleanGlyph(glyph2)
  difference ⇢ BooleanGlyph(glyph) - BooleanGlyph(glyph2)
  intersection ⇢ BooleanGlyph(glyph) & BooleanGlyph(glyph2)
  xor ⇢ BooleanGlyph(glyph) ^ BooleanGlyph(glyph2)
   
  Initiate a BooleanGlyph object
  glyph: the source glyph
  roundCoordinates: optionally round the result
   
  draw(pen)
  draws the booleanGlyph in a pen
  drawPoints(pointPen)
  draws the booleanGlyph in a pointPen
  union(other)
  performs an union operation
  difference(other)
  performs a difference operation
  intersection(other)
  performs a intersection operation
  xor(other)
  performs a xor operation
   
  width
  returns the width of the booleanGlyph

from mojo.roboFont import *

Methods

• AllFonts()
  returns a list of all open font objects, the list as some additional methods
  getFontsByStyleName(styleName)
  returns all fonts with the given styleName
  getFontsByFamilyName(familyName)
  returns all fonts with the given familyName
  getFontsByFamilyNameStyleName(familyName, styleName)
  returns the font with the given familyName and styleName 
• CurrentFont()
  returns the current font, will be None if no font is opened
• CurrentGlyph()
  returns the current glyph
• NewFont(familyName=None, styleName=None, showUI=True)
  Creates a new font with the given familyName and styleName
  optionally you can create a new font without having a UI, this is much faster to do internal actions. 
• OpenFont(path, showUI=True)
  opens a UFO with a given path
  optionally you can create a new font without having a UI, this is much faster to do internal actions. 
• RFont(path=None, showUI=True)
  creates a new font with the given path
  optionally you can create a new font without having a UI, this is much faster to do internal actions.  
• RGlyph()
• RContour()
• RInfo()
• RAnchor()
• RGroups()
• RFeatures()
• RComponent()
• RKerning()
• OpenWindow(controller, *args, **kwargs)
  opens a window from the controller objects with args, and kwargs
  use this if you want RoboFont to deal with already opened versions of your window controller 
• CreateCursor(path, hotSpot=(4, 4))
  creates a cursor object for image path with the given hotSpot 

 Attributes

• version
  Returns the version of RoboFont 

from mojo.glyphPreview import GlyphPreview

A vanilla group subclass that previews a glyph.

• GlyphPreview(posSize, contourColor=None, componentColor=None, selectionColor=None)
  
  posSize: tuple of 4 (left, top, right, bottom), those numbers can be negative
  contourColor: a NSColor object used to draw the contours, optionally
  componentColor: a NSColor object used to draw the components, optionally
  selectionColor: a NSColor object used to draw the selection
   
  setGlyph(glyph)
  set a glyph in the preview
  setSelection(points)
  sets a list of points to display

from vanilla import Window
from mojo.glyphPreview import GlyphPreview
from mojo.events import addObserver, removeObserver
from mojo.roboFont import OpenWindow

class Preview:

    def __init__(self):
        ## create a window
        self.w = Window((400, 400), "Preview", minSize=(100, 100))

        ## add a GlyphPreview to the window
        self.w.preview = GlyphPreview((0, 0, -0, -0))

        ## set the currentGlyph
        self.setGlyph(CurrentGlyph())

        ## add an observer when the glyph changed in the glyph view
        addObserver(self, "_currentGlyphChanged", "currentGlyphChanged")
    
        ## bind a windows close callback to this object
        self.w.bind("close", self.windowClose)
        ## open the window
        self.w.open()

    def _currentGlyphChanged(self, info):
        ## notification callback when the glyph changed in the glyph view
        ## just set the new glyph in the glyph preview
        self.setGlyph(CurrentGlyph())

    def setGlyph(self, glyph):
        ## setting the glyph in the glyph Preview
        self.w.preview.setGlyph(glyph)

    def windowClose(self, sender):
        ## remove the observer if the window closes
        removeObserver(self, "_currentGlyphChanged")


## open the window with OpenWindow, so it can not be open twice
OpenWindow(Preview)

from mojo.events import *

Imports useful helpers when building extensions and scripts requiring app event callbacks.

When subclassing or building tools on top of other tools you can find some embedded tools here

• installTool(tool)
  install tool
• uninstallTool(tool)
  uninstall tool 
• addObserver(observer, method, event)
  Add an observer for a specified event, callbacks will be send to the method of the observer.
• removeObserver(observer, event)
  Removes an observer for a specific event.
• BaseEventObserver
  The base class of an observer. 
• BaseEventTool
  The base class of an Tool 
• EditingTool
  A subclass-able EditingTool 
• MeasurementTool
  A subclass-able MeasurementTool 
• SliceTool
  A subclass-able SliceTool 
• BezierDrawingTool
  A subclass-able BezierDrawingTool 

from mojo.drawingTools import *

Using similar tools to draw in Cocoa object like DrawBot. (see TinyDrawBot extension)

• save()
  save the current graphic state 
• restore()
  restore the current graphic state 
• rect(x, y, width, height)
  draws a rectangle 
• oval(x, y, width, height)
  draws an oval 
• newPath()
  creates a new path 
• moveTo((x, y))
  move to point
• lineTo((x, y))
  line to point
• curveTo((h1x, h1y), (h2x, h2y), (x, y))
  curve to point with bcps
• closePath()
  close the path
• drawPath()
  draws the path
• fill(r, g, b, a=1)
  Set the fill color as RGB value.
• stroke(r, g, b, a=1)
  Set the stroke color as RGB value.
• strokeWidth(value)
  Set the stroke width for a path.
• miterLimit(value)
  Set the miter limit for a path.
• lineJoin(join)
  Set the line join for a path, possible join arguments are: "bevel", "miter" or "round"
• dashLine(dash)
  dash is a list of of values 
• translate(x, y)
  Translate the art board pane to "x", "y" 
• rotate(angle)
  Rotate the art board by an angle.
• scale(x, y)
  Scale the art board by "x", "y", if "y" is not set the art board will be scaled proportionally.
• skew(a, b)
  Skew the art board by "a", "b", if "b" is not set the art board will be skew with "a" = "b"
• font(fontName, fontSize=None)
  Set the font by PostScript name.
  Optionally set the font size. 
• fontSize(fontSize)
  Set the font size.
• text(textString, (x, y))
  Draw a text on position "x", "y".
• image(filePath, (x, y), alpha=1)
  Draw an image on position "x", "y".
  Optionally set an alpha value.

Collecting some examples to start scripting. 

From some basic stuff to a real everyday usable script.

• Object browser
• Drawing and AddObserver Example
• Shapes Tool
• Simple move example

For some real life examples see:

• hTools2
• additional examples

A developer helper tool to find out what is inside an object, module, class and find out how to use it.

import vanilla
import mojo

"""
Example usage of the vanilla objectBrowser.
"""


class ObjectBrowserController():

        def __init__(self, inspectObject):

            if inspectObject is None:
                raise TypeError, "can not inspect None value"

            self.w = vanilla.Window((400, 400),
                                   "inspect %s" %inspectObject,
                                   minSize=(100, 100))
            self.w.b = vanilla.ObjectBrowser((0, 0, -0, -0),
                                   inspectObject)
            self.w.open()


#obj = vanilla
#obj = mojo
obj = CurrentFont()

ObjectBrowserController(obj)

from mojo.drawingTools import *
from mojo.events import addObserver

class DrawTest:
    def __init__(self):
        ## add an observer for the draw event
        addObserver(self, "drawSomething", "draw")

    def drawSomething(self, glyph, info):
        ## draw something the glyph view
        rect(100, 100, 100, 100)

DrawTest()

An example of subclassing the BaseEventTool (see custom tools)

This is used in the Shapes Tool Extensions.

from mojo.events import BaseEventTool, installTool
from AppKit import *
import os

from lib.tools.drawing import strokePixelPath

from dialogKit import ModalDialog, TextBox, EditText, PopUpButton
from vanilla import RadioGroup

from robofab.pens.reverseContourPointPen import ReverseContourPointPen

from mojo.extensions import ExtensionBundle


## collecting the image data for building cursors and toolbar icons

shapeBundle = ExtensionBundle("ShapeTool")
_cursorOval = CreateCursor(shapeBundle.get("cursorOval"), hotSpot=(6, 6))

_cursorRect = CreateCursor(shapeBundle.get("cursorRect"), hotSpot=(6, 6))

toolbarIcon = shapeBundle.get("toolbarIcon")


class GeometricShapesWindow(object):
    """
    The Modal window that allows numbers input to draw basic geometric shapes.
    """
    
    def __init__(self, glyph, callback, x, y):
        self.glyph = glyph
        self.callback = callback
        ## create the modal dialog (from dialogKit)
        self.w = ModalDialog((200, 150), 
                            "Shapes Tool", 
                            okCallback=self.okCallback, 
                            cancelCallback=self.cancelCallback)
        
        ## add some text boxes
        self.w.xText = TextBox((10, 13, 100, 22), "x")
        self.w.yText = TextBox((10, 43, 100, 22), "y")
        self.w.wText = TextBox((100, 13, 100, 22), "w")
        self.w.hText = TextBox((100, 43, 100, 22), "h")
        
        ## adding input boxes
        self.w.xInput = EditText((30, 10, 50, 22), "%i" %x)
        self.w.yInput = EditText((30, 40, 50, 22), "%i" %y)
        self.w.wInput = EditText((120, 10, 50, 22))
        self.w.hInput = EditText((120, 40, 50, 22))
        
        ## a radio shape choice group 
        ## (the RadioGroup isn't standaard in dialogKit, this is a vanilla object)
        self.shapes = ["rect", "oval"]
        self.w.shape = RadioGroup((10, 70, -10, 22), self.shapes, isVertical=False)
        self.w.shape.set(0)
        
        self.w.open()
        
    def okCallback(self, sender):
        ## draw the shape in the glyph
        ## get the shape from the radio group
        shape = self.shapes[self.w.shape.get()]
        ## try to get some integers from the input fields
        try:
            x = int(self.w.xInput.get())
            y = int(self.w.yInput.get())
            w = int(self.w.wInput.get())
            h = int(self.w.hInput.get())
        ## if this fails just do nothing and print a tiny traceback
        except:
            print "A number is required!" 
            return
        ## draw the shape with the callback given on init
        self.callback(shape, (x, y, w, h), self.glyph)
    
    def cancelCallback(self, sender):
        ## do nothing :)
        pass

def _roundPoint(x, y):
    return int(round(x)), int(round(y))
     
class DrawGeometricShapesTool(BaseEventTool):

    def setup(self):
        ## setup is called when the tool gets active
        ## use this to initialize some attributes
        self.minPoint = None
        self.maxPoint = None
        self.shape = "rect"
        self.origin = "corner"

    def getRect(self):
        ## return the rect between mouse down and mouse up
        x = self.minPoint.x
        y = self.minPoint.y
        w = self.maxPoint.x - self.minPoint.x
        h = self.maxPoint.y - self.minPoint.y

        ## handle the shift down and equalize width and height
        if self.shiftDown:
            sign = 1
            if abs(w) > abs(h):
                if h < 0:
                    sign = -1
                h = abs(w) * sign
            else:
                if w < 0:
                    sign = -1
                w = abs(h) * sign

        if self.origin == "center":
            ## if the orgin is centered substract the width and height
            x -= w
            y -= h
            w *= 2
            h *= 2

        ## optimize the retangle, so the width and height are always postive numbers
        if w < 0:
            w = abs(w)
            x -= w
        if h < 0:
            h = abs(h)
            y -= h
        
        return x, y, w, h
    
    def drawShapeWithRectInGlyph(self, shape, rect, glyph):
        ## draw the shape into the glyph
        ## tell the glyph something is going to happen (undo is going to be prepared)
        glyph.prepareUndo("Drawing Shapes")

        ## get the pen to draw with
        pen = glyph.getPointPen()
        if glyph.preferedSegmentType == "qcurve":
            pen = ReverseContourPointPen(pen)
        
        x, y, w, h = rect
        
        ## draw with the pen a rect in the glyph
        if shape == "rect":
            pen.beginPath()
            pen.addPoint(_roundPoint(x, y), "line")
            pen.addPoint(_roundPoint(x + w, y), "line")
            pen.addPoint(_roundPoint(x + w, y + h), "line")
            pen.addPoint(_roundPoint(x, y + h), "line")

            pen.endPath()
        
        ## draw with the pen an oval in the glyph
        elif shape == "oval":
            
            hw = w/2.
            hh = h/2.
            
            r = .55
            segmentType = glyph.preferedSegmentType
            if glyph.preferedSegmentType == "qcurve":
                r = .42
            
            pen.beginPath()
            pen.addPoint(_roundPoint(x + hw, y), segmentType)
            pen.addPoint(_roundPoint(x + hw + hw*r, y))
            pen.addPoint(_roundPoint(x + w, y + hh - hh*r))

            pen.addPoint(_roundPoint(x + w, y + hh), segmentType)
            pen.addPoint(_roundPoint(x + w, y + hh + hh*r))
            pen.addPoint(_roundPoint(x + hw + hw*r, y + h))

            pen.addPoint(_roundPoint(x + hw, y + h), segmentType)
            pen.addPoint(_roundPoint(x + hw - hw*r, y + h))
            pen.addPoint(_roundPoint(x, y + hh + hh*r))

            pen.addPoint(_roundPoint(x, y + hh), segmentType)
            pen.addPoint(_roundPoint(x, y + hh - hh*r))
            pen.addPoint(_roundPoint(x + hw - hw*r, y))

            pen.endPath()

        ## tell the glyph you are done with your actions so it can handle the undo properly
        glyph.performUndo()
    
    def mouseDown(self, point, clickCount):
        ## a mouse down, only save the mouse down point
        self.minPoint = point
        ## on double click pop up an modal dialog with inputs
        if clickCount == 2:
            ## create and open the modal dialog
            GeometricShapesWindow(self.getGlyph(), 
                            callback=self.drawShapeWithRectInGlyph, 
                            x=self.minPoint.x, 
                            y=self.minPoint.y)

    def mouseDragged(self, point, delta):
        ## record the draggin point
        self.maxPoint = point        

    def mouseUp(self, point):
        ## mouse up, if you have recorded the rect draw that into the glyph
        if self.minPoint and self.maxPoint:
            self.drawShapeWithRectInGlyph(self.shape, self.getRect(), self.getGlyph())
        ## reset the tool
        self.minPoint = None
        self.maxPoint = None
        
    def modifiersChanged(self):
        ## is been called when the modifiers changed (shift, alt, control, command)
        self.shape = "rect"
        self.origin = "corner"
        ## change the shape when option is down
        if self.optionDown:
            self.shape = "oval"
        ## change the origin when command is down
        if self.commandDown:
            self.origin = "center"
        ## refresh the current glyph view
        self.getNSView().refresh()
        
    def draw(self, scale):
        ## draw stuff in the current glyph view
        if self.isDragging() and self.minPoint and self.maxPoint:
            ## draw only during drag and when recorded some rect
            ## make the rect
            x, y, w, h = self.getRect()
            rect = NSMakeRect(x, y, w, h)
            ## set the color
            NSColor.redColor().set()
            
            if self.shape == "rect":
                ## create a rect path
                path = NSBezierPath.bezierPathWithRect_(rect)
                
            elif self.shape == "oval":
                ## create a oval path
                path = NSBezierPath.bezierPathWithOvalInRect_(rect)

            if self.origin == "center":
                ## draw a cross hair at the center point
                crossHairLength = 3 * scale
                ## get the center of the rectangle
                centerX = x + w * .5
                centerY = y + h * .5

                path.moveToPoint_((centerX, centerY - crossHairLength))
                path.lineToPoint_((centerX, centerY + crossHairLength))
                path.moveToPoint_((centerX - crossHairLength, centerY))
                path.lineToPoint_((centerX + crossHairLength, centerY))

            ## set the line width
            path.setLineWidth_(scale)
            ## draw without anti-alias
            strokePixelPath(path)

    def getDefaultCursor(self):
        ## returns the cursor
        if self.shape == "rect":
            return _cursorRect
        else:
            return _cursorOval
            
    def getToolbarIcon(self):
        ## return the toolbar icon
        return toolbarIcon

    def getToolbarTip(self):
        ## return the toolbar tool tip
        return "Shape Tool"

## install the tool!!
installTool(DrawGeometricShapesTool())

An extremely easy 'move-the-selected-glyph' window

from vanilla import *

class MoveGlyphWindow:
    def __init__(self, glyph):
        if glyph is None:
            print "There should be a glyph window selected!!"
            return
        self.glyph = glyph

        self.moveX = 0
        self.moveY = 0

        self.w = Window((200, 60), "Move %s" %self.glyph.name)

        self.w.hs = Slider((10, 10, -10, 22), value=0,
                                        maxValue=200,
                                        minValue=-200,
                                        callback=self.adjust)

        self.w.vs = Slider((10, 30, -10, 22), value=0,
                                        maxValue=200,
                                        minValue=-200,
                                        callback=self.adjust)

        self.w.open()

    def adjust(self, sender):
        hValue = self.w.hs.get()
        vValue = self.w.vs.get()

        x = self.moveX - hValue
        y = self.moveY - vValue

        self.moveX = hValue
        self.moveY = vValue

        self.glyph.move((x, y))

OpenWindow(MoveGlyphWindow, CurrentGlyph())