def appendMethodToDrawingMethods(sender, method, drawingMethods):
if sender.get() == 1:
if method not in drawingMethods:
drawingMethods.append(method)
UpdateCurrentGlyphView()
else:
if method in drawingMethods:
drawingMethods.remove(method)
UpdateCurrentGlyphView()
def font(self, value):
self._font = value
self.cfont = ColorFont(self._font)
self.glyph = None
self.glyphPreview = None
self.width = 0
self.palette_index = 0 # currently active palette
self.currentPaletteChanged = False
self.currentGlyphChanged = False
self.layer_glyphs = []
self.layer_colors = []
self.layer_glyphs_glyph_window = []
self.layer_colors_glyph_window = []
if self._font is not None:
self.metrics = (
self._font.info.descender,
self._font.info.xHeight,
self._font.info.capHeight,
self._font.info.ascender,
self._font.info.unitsPerEm,
)
else:
self.metrics = (-200, 500, 700, 800, 1000)
self.scale = 180 / (self.metrics[3] - self.metrics[0])
# load color data from rfont
if self._font:
self.cfont.read_from_rfont()
self._update_ui()
UpdateCurrentGlyphView()
def _ui_update_palette(self, palette_index):
# load a different palette from the color font and show it in UI
# save the currently selected color index
selectedColorIndex = self.w.colorpalette.getSelection()
self.palette_index = palette_index
if self.palette_index < len(self.cfont.palettes):
colorpalette = self.cfont.palettes[self.palette_index]
else:
colorpalette = {}
int_keys = [int(k) for k in colorpalette.keys()]
newColorpalette = [{
"Index": k,
"Color": self.getNSColor(colorpalette[k])
} for k in sorted(int_keys)]
newColorpalette.append({"Index": 0xffff, "Color": self.color})
self.w.colorpalette.set(newColorpalette)
self.w.colorpalette.setSelection(selectedColorIndex)
self.w.paletteswitch.set(self.palette_index)
self._cache_color_info()
self._cache_color_info_glyph_window()
self.currentPaletteChanged = False
self.w.preview.update()
UpdateCurrentGlyphView()
def windowCloseCallback(self, sender):
removeObserver(self, "draw")
removeObserver(self, "drawInactive")
removeObserver(self, "currentGlyphChanged")
setExtensionDefault("%s.%s" % (extensionID, "tension"), self.w.HobbySlider.get())
super(metapolator, self).windowCloseCallback(sender)
UpdateCurrentGlyphView()
def drawRef(self, info):
save()
fillColor = NSColor.colorWithCalibratedRed_green_blue_alpha_(0.0, 0.0, 0.0, 1.0)
fillColor.set()
self. _drawGlyph(info["glyph"], scale=info["scale"])
UpdateCurrentGlyphView()
restore()
def drawPreviewRef(self, info):
save()
fillColor = NSColor.colorWithCalibratedRed_green_blue_alpha_(0.0, 0.0, 0.0, 0.05)
fillColor.set()
self. _drawGlyph(info["glyph"], scale=1, stroke=False)
UpdateCurrentGlyphView()
restore()
def font_list_drop_callback(self, sender, dropInfo):
for i in self.font_order:
if i not in self.w.fileList.get():
self.font_order.remove(i)
isProposal = dropInfo["isProposal"]
if not isProposal:
# get the indexes
from_index = int(dropInfo["data"][0])
to_index = dropInfo["rowIndex"]
if to_index != from_index:
# get the selected object and remove it from the list
item = self.font_order.pop(from_index)
# fix indexes if the object is moved down the list
if from_index < to_index:
to_index -= 1
# Insert the item at the required index
self.font_order.insert(to_index, item)
# update the vanila list
sender.set(self.font_order)
UpdateCurrentGlyphView()
return True
def colOnlyCallback(self, sender):
self.colOnlyCheck = sender.get()
self.rowOnlyCheck = 0
self.w.rowOnlyCheck.set(0)
UpdateCurrentGlyphView()
def uncheckGlyphStatus(self, sender):
self.w.clearGlyphStatusButton.enable(False)
self.w.showGlyphStatusButton.enable(True)
self.errors = {}
self.removeObservers()
self.drawing = False
UpdateCurrentGlyphView()
def windowCloseCallback(self, sender):
if self.drawing:
self.removeObservers()
if roboFontVersion > "1.5.1":
_unregisterFactory()
UpdateCurrentGlyphView()
super(RedArrowUI, self).windowCloseCallback(sender)
def mySliderCallback(self, sender):
if self.glyph is not None:
self.glyph.width = sender.get() # same as self.w.mySlider
self.updating = True
self.glyph.changed()
UpdateCurrentGlyphView()
self.updating = False
def colorStrokeEdit(self, sender):
color = sender.get()
if isinstance(color, tuple):
self.colorStroke = sender.get()
else:
self.colorStroke = nsColor2RGB(sender.get())
UpdateCurrentGlyphView()
def txtYCallback(self, sender):
self.offsetY = 0
if sender.get() is not None:
if isfloat(sender.get()):
self.offsetY = float(sender.get())
# self.saveCurrentGlyphSettingsAsGlobal()
UpdateCurrentGlyphView()
def _distributeSpacing(self, index, title):
glyph = CurrentGlyph()
if glyph is None:
return
rects, selectedContours, selectedBPoints = getSelectionData(glyph)
if len(rects) < 3:
return
widths = []
heights = []
edgeRect = None
for rect in rects:
xMin, yMin, xMax, yMax = rect
widths.append(xMax - xMin)
heights.append(yMax - yMin)
if edgeRect is None:
edgeRect = rect
else:
edgeRect = unionRect(edgeRect, rect)
objectWidth = sum(widths)
objectHeight = sum(heights)
xMin, yMin, xMax, yMax = edgeRect
overallWidth = xMax - xMin
overallHeight = yMax - yMin
availableXSpace = overallWidth - objectWidth
availableYSpace = overallHeight - objectHeight
xSpace = availableXSpace / (len(rects) - 1)
ySpace = availableYSpace / (len(rects) - 1)
spaceBetweenObjects = (xSpace, ySpace)[index]
ordered = [(bPoint.anchor[index], (bPoint.anchor[0], bPoint.anchor[1],
bPoint.anchor[0], bPoint.anchor[1]),
bPoint) for bPoint in selectedBPoints]
ordered += [(contour.bounds[index], contour.bounds, contour)
for contour in selectedContours]
ordered.sort()
glyph.prepareUndo(title)
prevEdge = None
for pos, bounds, obj in ordered[:-1]:
xMin, yMin, xMax, yMax = bounds
width = xMax - xMin
height = yMax - yMin
size = (width, height)[index]
if prevEdge is None:
newPos = (xMin, yMin)[index]
else:
newPos = prevEdge + spaceBetweenObjects
d = newPos - pos
print(d)
if d != 0:
if index == 0:
obj.moveBy((d, 0))
else:
obj.moveBy((0, d))
prevEdge = newPos + size
for bPoint in selectedBPoints:
bPoint.round()
for contour in selectedContours:
contour.round()
glyph.changed()
glyph.performUndo()
UpdateCurrentGlyphView()
def __init__(self):
self.w = FloatingWindow((350, 110), "Angle Checker")
y = 10
self.w.desiredAngleText = TextBox((10, y, 140, 22), "Desired Angle:", alignment="right")
self.w.desiredAngle = SliderEditIntStepper((160, y, -10, 22), 15.5, callback=self.changedCallback, minValue=0, maxValue=180)
y += 30
self.w.toleranceText = TextBox((10, y, 140, 22), "Tolerance +/-:", alignment="right")
self.w.tolerance = SliderEditIntStepper((160, y, -10, 22), 1, callback=self.changedCallback, minValue=0, maxValue=15)
y += 30
self.w.rangeToCheckText = TextBox((10, y, 140, 22), "Range to check +/-:", alignment="right")
self.w.rangeToCheck = SliderEditIntStepper((160, y, -10, 22), 12, callback=self.changedCallback, minValue=0, maxValue=45)
# self.setUpBaseWindowBehavior()
self.w.open()
self.w.bind("close", self.windowCloseCallback)
addObserver(self, "myDrawCallback", "draw")
addObserver(self, "myDrawCallback", "drawInactive")
# addObserver(self, "myDrawCallback", "spaceCenterDraw")
addObserver(self, "myDrawCallback", "viewDidChangeGlyph")
UpdateCurrentGlyphView()
self.g = CurrentGlyph()
def _roundCurrentGlyph(self):
if self.sourceLayerName == self.targetLayerName:
self.showMessage(
'ERROR',
u'source layer name and target layer name should be different')
return None
currentGlyph = CurrentGlyph()
if currentGlyph is not None:
self.rounderLogger.info(
'start: _roundCurrentGlyph(), glyph {} from {} {}'.format(
currentGlyph.name, self.selectedFont.info.familyName,
self.selectedFont.info.styleName))
selectedFont = currentGlyph.getParent()
roundingsData = pullRoundingsDataFromFont(selectedFont)
if roundingsData is not None:
makeGlyphRound(currentGlyph,
roundingsData,
sourceLayerName=self.sourceLayerName,
targetLayerName=self.targetLayerName)
UpdateCurrentGlyphView()
self.rounderLogger.info(
'end: _roundCurrentGlyph(), glyph {} from {} {}'.format(
currentGlyph.name, selectedFont.info.familyName,
selectedFont.info.styleName))
elif currentGlyph is not None:
self.showMessage('ERROR', NO_DATA_INTO_FONT)
self.rounderLogger.error(NO_DATA_INTO_FONT)
else:
self.showMessage('ERROR', NO_GLYPH_TO_ROUND)
self.rounderLogger.error(NO_GLYPH_TO_ROUND)
def hideRedArrows(self):
self.errors = {}
self.removeObservers()
if roboFontVersion > "1.5.1":
_unregisterFactory()
self.drawing = False
UpdateCurrentGlyphView()
def settingStrokeThicknessFromUI(self, sender):
try:
int(str(self.w.strokeThickness.get()))
except ValueError:
self.w.strokeThickness.set(str(1))
UpdateCurrentGlyphView()
def windowCloseCallback(self, sender):
removeObserver(self, "draw")
removeObserver(self, "drawInactive")
# self.g.removeObserver(self, "Glyph.Changed")
# removeObserver(self, "spaceCenterDraw")
removeObserver(self, "viewDidChangeGlyph")
UpdateCurrentGlyphView()
def buildUI(self):
self.w = FloatingWindow((170, 155), title="Pattern Preview")
row = 6
self.w.heightTitle = TextBox((10, row, -10, 17), "Cell Height:")
row += 20
self.w.heightRadio = RadioGroup((10, row, -10, 42),
["Use font UPM", "Use custom height"],
callback=self.heightRadioCallback)
self.w.heightRadio.set(0)
self.w.heightInput = EditText((30, row + 45, -10, 22),
text=self.height,
callback=self.heightInputCallback)
self.w.heightInput.enable(False)
row += 77
self.w.rowOnlyCheck = CheckBox((11, row, -10, 22),
"Row only",
callback=self.rowOnlyCallback)
row += 20
self.w.colOnlyCheck = CheckBox((11, row, -10, 22),
"Column only",
callback=self.colOnlyCallback)
addObserver(self, "changeGlyph", "viewDidChangeGlyph")
addObserver(self, "showPatternBackground", "drawBackground")
addObserver(self, "showPatternPreview", "drawPreview")
self.setUpBaseWindowBehavior()
self.w.open()
UpdateCurrentGlyphView()
def windowCloseCallback(self, sender):
self.removeObservers()
setExtensionDefault("%s.%s" % (extensionID, "hide"),
self.fontAnchors.hideLists)
setExtensionDefault("%s.%s" % (extensionID, "preview"),
self.showPreview)
super(AnchorOverlay, self).windowCloseCallback(sender)
UpdateCurrentGlyphView()
def mouseMoved(self, info):
if not self.activDraw: return
if self.keydidUp == 1: return
self.mousePt = (info['point'].x, info['point'].y)
self.pen = ClosestPointPen(self.mousePt, self.g.getParent())
self.g.draw(self.pen)
self.closest, self.ortho = self.pen.getClosestData()
UpdateCurrentGlyphView()
def wrapper(self, *args, **kwargs):
func(self, *args, **kwargs)
UpdateCurrentGlyphView()
e = self
if hasattr(self, 'RCJKI'):
e = self.RCJKI
if e.glyphInspectorWindow is not None:
e.glyphInspectorWindow.updatePreview()
def windowCloseCallback(self, sender):
# this receives a notification whenever the window is closed
# remove the observer
removeObserver(self, "draw")
removeObserver(self, "drawInactive")
# and send the notification to the super
super(SimpleWindowObserver, self).windowCloseCallback(sender)
UpdateCurrentGlyphView()
def windowCloseCallback(self, sender):
removeObserver(self, "viewDidChangeGlyph")
removeObserver(self, "drawBackground")
removeObserver(self, "drawPreview")
UpdateCurrentGlyphView()
super(PatternPreview, self).windowCloseCallback(sender)
def drawNeighbors(self, info):
save()
fillColor = NSColor.colorWithCalibratedRed_green_blue_alpha_(
0.0, 0.0, 0.0, 0.05)
fillColor.set()
self._drawLeftNeighborsGlyphs(info["glyph"], scale=info["scale"])
UpdateCurrentGlyphView()
restore()
def checkbox5Callback(self, sender):
if sender.get() == 1:
self.w.ten.set(0)
self.w.sliderInterpol.enable(False)
if sender.get() == 0:
if self.w.ten.get() == 0:
self.w.sliderInterpol.enable(True)
UpdateCurrentGlyphView()
def attachLabelToSelectedPoints(labelName):
myGlyph = CurrentGlyph()
for eachContour in myGlyph:
for eachPt in eachContour.points:
if eachPt.selected is True:
eachPt.name = labelName
myGlyph.update()
UpdateCurrentGlyphView()
def makePreviewGlyph(self, sender=None):
if (sender is not None) and isinstance(sender, dict):
if sender.has_key('notificationName') and sender['notificationName'] == 'mouseDragged':
g = sender['glyph']
if not len(g.selection):
return
self.previewGlyph = self.makeCornerGlyph()
UpdateCurrentGlyphView()
def clearLibCallback(self, sender):
if PLUGIN_KEY in CurrentGlyph().lib:
del CurrentGlyph().lib[PLUGIN_KEY]
if version[0] == '2':
CurrentGlyph().changed()
else:
CurrentGlyph().update()
UpdateCurrentGlyphView()
