def currentGlyphChanged(self, notification):
glyph = notification['glyph']
if glyph is None: return
changed = False
if glyph.name != self.currentGlyph.name:
changed = True
self.closeimportDCFromCG()
self.currentGlyph = self.currentFont[glyph.name]
if changed:
# self.currentGlyph.sourcesList = []
# for axis, variation in zip(self.currentGlyph._axes, self.currentGlyph._glyphVariations):
# self.currentGlyph.sourcesList.append({"Axis":axis["name"], "Layer":variation["layerName"], "PreviewValue":{axis["name"]:0}, "MinValue":axis["minValue"], "MaxValue":axis["maxValue"]})
# self.currentGlyph.sourcesList = self.sortDeepComponentAxesList(self.currentGlyph.sourcesList)
# self.currentViewSourceList.glyphVariationAxesList.set(self.currentGlyph.sourcesList)
self.glyphInspectorWindow.sourcesItem.setList()
self.glyphInspectorWindow.axesItem.setList()
self.currentViewSourceValue.set("")
if self.currentGlyph.type == 'atomicElement':
uninstallTool(self.transformationTool)
else:
installTool(self.transformationTool)
if self.currentGlyph.type != "atomicElement":
self.addSubView()
self.openGlyphInspector()
self.updateDeepComponent()
self.glyphInspectorWindow.updatePreview()
def installCustomTool(self, install=True, sender=None):
if install:
if self.currentGlyph.type == 'atomicElement':
uninstallTool(self.transformationTool)
else:
installTool(self.transformationTool)
else:
uninstallTool(self.transformationTool)
def _updateTools(self):
for toolName in self.toolDescription:
active = self.toolDescription[toolName]
for toolObj in self.tools:
if toolObj.__class__.__name__ == toolName:
if active:
installTool(toolObj)
else:
if len(getToolOrder()) > 1:
uninstallTool(toolObj)
def listChangedCallback(self, sender):
items = sender.get()
selection = sender.getSelection()
for index,item in enumerate(items):
toolname = item['tool']
oldValue = self.toolDescription[toolname]
newValue = False
if item['active'] == 1: newValue = True
if newValue != oldValue:
self.toolDescription[toolname] = newValue
currTool = None
for toolObj in self.tools:
if toolObj.__class__.__name__ == toolname:
if newValue:
installTool(toolObj)
else:
if len(getToolOrder()) > 1:
uninstallTool(toolObj)
break
if not newValue:
if index in selection:
# if the selected tool is going to be disabled,
# the following code will switch to
# the first enabled tool
listOfValues = [self.toolDescription[name] for name in self.toolNames]
newSelection = []
for i, value in enumerate(listOfValues):
if value:
newSelection += [i]
print(newSelection)
if len(newSelection) > 1:
sender.setSelection([newSelection[0]])
else:
sender.setSelection(newSelection)
def __init__(self):
self.windowWidth, self.windowHeight = 1000,600
self.w = Window((self.windowWidth, self.windowHeight), "Robo CJK", minSize = (300,300), maxSize = (2500,2000))
self.font = CurrentFont()
self.glyph = CurrentGlyph()
self.glyphset = list()
self.font2Storage = dict()
self.layerList = list()
self.glyphsSetDict = dict()
self.newDeepComponent_active = False
self.temp_DeepCompo_slidersValuesList = []
self.temp_DeepComponents = {}
self.activeMaster = True
self.deepCompoWillDrag = False
self.currentGlyph_DeepComponents = {
'CurrentDeepComponents':{},
'Existing':{},
'NewDeepComponents':{},
}
self.deepCompo_DeltaX, self.deepCompo_DeltaY = 0, 0
self.current_DeepComponent_selection = None
self.selectedCompositionGlyphName = ""
self.selectedVariantName = ""
toolbarItems = [
{
'itemIdentifier': "saveUFO(s)",
'label': 'Save UFO(s)',
'callback': self._saveUFOs_callback,
'imagePath': SavePDF
},
{
'itemIdentifier': "testInstall",
'label': 'Test Install',
'callback': self._testInstall_callback,
'imagePath': TestInstallPDF
},
{
'itemIdentifier': NSToolbarFlexibleSpaceItemIdentifier,
},
{
'itemIdentifier': "textCenter",
'label': 'Text Center',
'callback': self._textCenter_callback,
'imagePath': TextCenterPDF
},
{
'itemIdentifier': "mastersOverview",
'label': 'Masters Overview',
'callback': self._textCenter_callback,
'imagePath': MastersOverviewPDF
},
{
'itemIdentifier': NSToolbarFlexibleSpaceItemIdentifier,
},
{
'itemIdentifier': "projectEditor",
'label': 'Projects Editor',
'callback': self._projectsSettings_callback,
'imagePath': ProjectEditorPDF
},
{
'itemIdentifier': "preference",
'label': 'Preference',
'callback': self._preference_callback,
'imagePath': PreferencesPDF,
},
]
self.w.addToolbar("DesignSpaceToolbar", toolbarItems)
self.project_popUpButton_list = ["Load a project..."]
self.w.projects_popUpButton = PopUpButton((10,10,-10,20),
self.project_popUpButton_list,
callback = self._projects_popUpButton_callback)
segmentedElements = ["Active Master", "Deep Components Editor"]
self.w.main_segmentedButton = SegmentedButton((10,40,-180,20),
[dict(title=e, width = (self.windowWidth-224)/len(segmentedElements)) for e in segmentedElements],
callback = self._main_segmentedButton_callback,
sizeStyle='regular')
self.w.main_segmentedButton.set(0)
self.getCompositionGlyph()
self.w.activeMasterGroup = Group((10,70,-205,-20))
self.w.deepComponentsEditorGroup = Group((10,70,-205,-20))
self.w.deepComponentsEditorGroup.show(0)
####### GLYPHSET #######
self.w.activeMasterGroup.glyphSet = GlyphSet((225,0,-0,-200), self)
####### GLYPHSET #######
self.w.activeMasterGroup.glyphData = GlyphData((0,180,215,-0), self)
self.w.activeMasterGroup.DeepComponentsInstantiator = DeepComponentsInstantiator((225,-190,-0,-0), self)
# self.w.deepComponentsEditorGroup.fontsGroup = Fonts((0,0,215,170), self)
self.w.deepComponentsEditorGroup.Layers = Layers((0,150,215,-0), self)
self.w.deepComponentsEditorGroup.GlyphLayers = GlyphLayers((225,0,-0,-0), self)
####### MINIFONT GROUP #######
# self.minifonts = MiniFonts((0,0,-0,-0), self)
####### REFERENCE VIEWER #######
self.referenceViewer = ReferenceViewer((0,0,-0,-0), self)
###### DESIGN FRAMES ######
self.designFrame = DesignFrame((0,0,-0,-0), self)
####### FONT GROUP #######
self.w.fontsGroup = Fonts((10,70,215,170), self)
###### ACCORDION VIEW ######
self.accordionViewDescriptions = [
dict(label="Reference Viewer", view=self.referenceViewer, size=55, collapsed=True, canResize=0),
dict(label="Design Frame", view=self.designFrame, size=173, collapsed=False, canResize=0),
]
self.w.accordionView = AccordionView((-200, 40, -0, -20), self.accordionViewDescriptions,
backgroundColor=NSColor.colorWithCalibratedRed_green_blue_alpha_(1, 1, 1, 1))
###### DARK MODE ######
self.darkMode = 1
Helpers.setDarkMode(self.w, self.darkMode)
self.w.darkMode_checkBox = CheckBox((10,-20,-10,-0),
"Dark Mode",
sizeStyle = "small",
value = self.darkMode,
callback = self._darkMode_checkBox_checkBox)
###### OFF TOOLS ######
PowerRuler.Ruler(self)
BalanceHandles.BalanceHandles(self)
OpenSelectedComponent.OpenSelectedComponent(self)
self.smartSelector = SmartSelector(self)
installTool(self.smartSelector)
###### OBSERVER ######
self.observer()
self.w.bind('close', self.windowWillClose)
self.w.bind('resize', self.windowDidResize)
###### LAUNCH WINDOW ######
self.w.open()
self.clearAll()
g = CurrentGlyph()
self.getRatio(g)
def mouseDragged(self, point=None, delta=None):
self.update()
def mouseDown(self, point, event):
self.update()
def mouseUp(self, xx):
self._rin = None
self._rout = None
self.update()
def keyDown(self, event):
self.update()
def becomeInactive(self):
self.clearAll()
def clearAll(self):
self.outgoingLayer.clearSublayers()
self.incomingLayer.clearSublayers()
self.captionTextLayer.clearSublayers()
p = RatioTool()
installTool(p)
print('installed', p)
Draw guidelines for the current box.
"""
g = self.getGlyph()
selectedBox = self.getBox(selected=True)
if selectedBox:
divisionsX = int(self.w.divisionsRadioY.get())
divisionsY = int(self.w.divisionsRadioX.get())
pt1, pt2, pt3, pt4, dimensions = selectedBox
pt1X, pt1Y = pt1 # bottom left
pt2X, pt2Y = pt2 # top left
pt3X, pt3Y = pt3 # top right
pt4X, pt4Y = pt4 # bottom right
width, height = dimensions
italicAngle = 0
if self.w.useItalic.get():
italicAngle = g.getParent().info.italicAngle or 0
g.prepareUndo()
#if self.w.viewX.get():
g.addGuide((pt1X, pt1Y), 90 + italicAngle)
g.addGuide((pt3X, pt3Y), 90 + italicAngle)
#if self.w.viewY.get():
g.addGuide((pt1X, pt1Y), 0)
g.addGuide((pt3X, pt3Y), 0)
g.performUndo()
def updateView(self, sender=None):
UpdateCurrentGlyphView()
installTool(BoundingTool())
cachedW = self.cachedSelectionBounds[
2] - self.cachedSelectionBounds[0]
cachedH = self.cachedSelectionBounds[
3] - self.cachedSelectionBounds[1]
w = self.selectionBounds[2] - self.selectionBounds[0]
h = self.selectionBounds[3] - self.selectionBounds[1]
offsetX = self.selectionBounds[0] - self.cachedSelectionBounds[0]
offsetY = self.selectionBounds[1] - self.cachedSelectionBounds[1]
if cachedW == 0:
scaleW = 0
else:
scaleW = w / cachedW
if cachedH == 0:
scaleH = 0
else:
scaleH = h / cachedH
return (offsetX, offsetY), (scaleW, scaleH)
else:
return None
def pointInBounds(self, point, bounds):
if bounds:
return bounds[0] < point[0] < bounds[2] and bounds[1] < point[
1] < bounds[3]
else:
return False
if RF3:
installTool(SlightlyBetterTransformTool())
def _applyTolerance(self, info):
"""
Pass to delegate object's method:
Redefine tolerance whenever com.ToleranceSettingChanged is triggered
"""
self.delegate.readToleranceSetting()
def _selectSegmentWhenBCPConnectionIsClicked(self):
"""
Keep segment selected when click point is w/in
line connecting bcps
If multiple segments are selected, only one
segment will remain selected
"""
for selected in self.delegate._selectedSegments:
p1, segment = selected
h1, h2, p2 = segment
if hf.isPointInLine(self.mouseDownPoint, (h1, h2), self.delegate.scale):
self.canMarquee = False
self.lineWeightMultiplier = 4
segment.selected = True
if __name__ == "__main__":
dwgDelegate = DrawingDelegate()
parallelGuides = ParallelGuides(dwgDelegate)
parallelTool = EditConnectionLineTool(dwgDelegate)
installTool(parallelTool)
if 'Radial Guide' not in ancs:
g.appendAnchor("Radial Guide", (500, 500))
for a in g.guides:
if a.name in gd:
g.removeGuide(a)
for a in g.anchors:
if a.name == 'Radial Guide':
x = a.x
y = a.y
for angle in range(0, 180, 15):
g.addGuide((x, y), angle, name=("Radial {0}deg".format(angle)))
guide = g.addGuide((x, y), angle, name=("Radial {0}deg".format(angle)))
guide.naked().showMeasurements = True
CurrentFont().update()
def getToolbarIcon(self):
## return the toolbar icon
return toolbarIcon
def getToolbarTip(self):
## return the toolbar tool tip
return "Radial Guides Tool"
## install the tool!!
installTool(RadialGuideTool())
str(int(self.position.x)) + ", " + str(int(self.position.y)),
(x + 20, y + 20))
stroke(1, 0, 0)
rect(self.here.x - size * 1, self.here.y - size * 1, size * 2,
size * 2)
if self.hereOld != None:
xx = self.positionOld.x - size
yy = self.positionOld.y - size
fill(0, 255, 255, 1.0)
fontSize(30)
text(
str(int(self.positionOld.x)) + ", " +
str(int(self.positionOld.y)), (xx + 20, yy + 20))
stroke(1, 0, 0)
rect(self.hereOld.x - size * 1, self.hereOld.y - size * 1,
size * 2, size * 2)
def getToolbarTip(self):
pass
def viewDidChangeGlyph(self):
pass
def preferencesChanged(self):
pass
installTool(AttributeTool())
# scale curve
newDistX = diff(p1.x, p2.x, self.settings['simplified'])
newDistY = diff(p1.y, p2.y, self.settings['simplified'])
p1UtX, p1UtY = newDistX * p1xr + p1.x, newDistY * p1yr + p1.y
p2InX, p2InY = newDistX * p2xr + p2.x, newDistY * p2yr + p2.y
p1Ut.x, p1Ut.y, p2In.x, p2In.y = p1UtX, p1UtY, p2InX, p2InY
# correct offCurve angles
if not self.settings['simplified']:
if prevType == 'line' and p1.smooth: # smooth line before
p1Ut.x, p1Ut.y = smoothLines(p1, p0, p1Ut)
elif p1yx: # diagonal p1Ut
p1Ut.x, p1Ut.y = keepAngles(p1, p1Ut, p1yx, p1xy, p1dx, p1dy)
if not arrowKeyDown and self.commandDown: # keep angle override
if self.settings['smoothsToo'] or not self.settings['smoothsToo'] and not p1.smooth:
if self.settings['selectOnly'] and p1.selected or not self.settings['selectOnly']:
p1Ut.x, p1Ut.y = p1UtX, p1UtY
if nextType == 'line' and p2.smooth: # smooth line after
p2In.x, p2In.y = smoothLines(p2, p3, p2In)
elif p2yx: # diagonal p2In
p2In.x, p2In.y = keepAngles(p2, p2In, p2yx, p2xy, p2dx, p2dy)
if not arrowKeyDown and self.commandDown: # keep angle override
if self.settings['smoothsToo'] or not self.settings['smoothsToo'] and not p2.smooth:
if self.settings['selectOnly'] and p2.selected or not self.settings['selectOnly']:
p2In.x, p2In.y = p2InX, p2InY
installTool(ScalingEditTool())
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()
elif self.drawingMode == COMPONENT_MODE and self.componentName and self.componentName != glyph.name:
pen.addComponent(self.componentName, [1, 0, 0, 1, x, y])
def getDefaultCursor(self):
return pixelCursor
def getToolbarIcon(self):
return pixelToolbarIcon
def getToolbarTip(self):
return "Pixel Tool"
installTool(PixelTool())
nsPathObject = self.getGlyph().getRepresentation("defconAppKit.NSBezierPath")
for pos, val in self.kernel.items():
thisPos = (
samplePoint[0] + pos[0] * self.prefs["chunkSize"],
samplePoint[1] + pos[1] * self.prefs["chunkSize"],
)
# a = math.atan2(pos[0], pos[1])
if thisPos not in self._insides:
self._insides[thisPos] = nsPathObject.containsPoint_(thisPos)
if not self._insides[thisPos]:
level += self.kernel.get(pos)
self._hits[thisPos] = self.kernel.get(pos)
else:
self._misses[thisPos] = self.kernel.get(pos)
self.pts.append((samplePoint, level, self.prefs["toolDiameter"]))
self.samples[(samplePoint, self.prefs["toolDiameter"])] = dict(level=level)
self.dupes.add((self.prefs["toolDiameter"], samplePoint))
return level
def getToolbarTip(self):
return "LightMeter"
def getToolbarIcon(self):
## return the toolbar icon
return toolbarIcon
p = LightMeterTool()
installTool(p)
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())
path.curveToPoint_controlPoint1_controlPoint2_(((nextPoint.x + nextPairPoint.x) / 2, (nextPoint.y + nextPairPoint.y) / 2),
(((currentPoint.x + nextPoint.x) / 2 + ccp[currentPairIndex - 1].x) / 2, ((currentPoint.y + nextPoint.y) / 2 + ccp[currentPairIndex - 1].y) / 2),
(((currentPoint.x + nextPoint.x) / 2 + ccp[currentPairIndex - 2].x) / 2, ((currentPoint.y + nextPoint.y) / 2 + ccp[currentPairIndex - 2].y) / 2))
path.stroke()
else:
if pairCurve == False:
ccp = currentContour.points
path = NSBezierPath.bezierPath()
currentColor = NSColor.redColor()
currentColor.set()
path.moveToPoint_(((currentPoint.x + currentPairPoint.x) / 2, (currentPoint.y + currentPairPoint.y) / 2))
path.curveToPoint_controlPoint1_controlPoint2_(((nextPoint.x + nextPairPoint.x) / 2, (nextPoint.y + nextPairPoint.y) / 2),
(((currentPairPoint.x + nextPairPoint.x) / 2 + ccp[currentIndex + 1].x) / 2, ((currentPairPoint.y + nextPairPoint.y) / 2 + ccp[currentIndex + 1].y) / 2),
(((currentPairPoint.x + nextPairPoint.x) / 2 + ccp[currentIndex + 2].x) / 2, ((currentPairPoint.y + nextPairPoint.y) / 2 + ccp[currentIndex + 2].y) / 2))
path.stroke()
else:
ccp = currentContour.points
path = NSBezierPath.bezierPath()
currentColor = NSColor.redColor()
currentColor.set()
path.moveToPoint_(((currentPoint.x + currentPairPoint.x) / 2, (currentPoint.y + currentPairPoint.y) / 2))
path.curveToPoint_controlPoint1_controlPoint2_(((nextPoint.x + nextPairPoint.x) / 2, (nextPoint.y + nextPairPoint.y) / 2),
((ccp[currentIndex + 1].x + ccp[currentPairIndex - 1].x) / 2, (ccp[currentIndex + 1].y + ccp[currentPairIndex - 1].y) / 2),
((ccp[currentIndex + 2].x + ccp[currentPairIndex - 2].x) / 2, (ccp[currentIndex + 2].y + ccp[currentPairIndex - 2].y) / 2))
path.stroke()
drawed = drawed + 1
except AttributeError:
continue
installTool(CenterLine())
def mouseUp(self, point):
self.pEnd = point
self._getSelectedPoints()
#print(self.errorSelection)
self.pStart = None
self.pEnd = None
self._selectedMouseDownPoint = None
def mouseDragged(self, point, delta):
self.pEnd = point
#self._getSelectedPoints()
def draw(self, scale):
if self.isDragging() and self.pStart and self.pEnd:
r = self.getMarqueRect()
if r:
color = getDefaultColor('glyphViewSelectionMarqueColor')
color.set()
path = NSBezierPath.bezierPathWithRect_(r)
path.fill()
return
self.drawSelection(scale)
def drawSelection(self, scale):
self.errorSelection.draw(scale)
installTool(RedArrowFixerTool())
print("Red Arrow Fixer installed in tool bar.")
glyph = self.getGlyph()
path = self.pen.path
for contour in glyph:
for point in contour.points:
result = path.containsPoint_((point.x, point.y))
if self.controlDown:
point.selected = not result
else:
point.selected = result
self._oldPen = self.pen
self.pen = None
def draw(self, scale):
if self.pen is None:
return
fill(0, .1)
stroke(0, .6)
strokeWidth(scale)
drawPath(self.pen.path)
def canSelectWithMarque(self):
return False
def getToolbarTip(self):
return "Polygon Selection Tool"
installTool(PolygonSelectionTool())
def becomeInactive(self):
self.speedpunklib.Close()
def drawBackground(self, scale):
try:
if self.getGlyph() != None:
self.speedpunklib.UpdateGlyph(self.getGlyph())
except:
NSLog('Speed Punk:\n%s' % traceback.format_exc())
def glyphWindowWillClose(self, a):
self.speedpunklib.Close()
def glyphWindowDidOpen(self, a):
self.speedpunklib.Open()
def getToolbarTip(self):
return "Speed Punk"
def getToolbarIcon(self):
NSImage = bundle.getResourceImage("toolbar")
if NSImage:
return NSImage
installTool(SpeedPunkTool())
except:
NSLog('Speed Punk:\n%s' % traceback.format_exc())
"""
g = self.getGlyph()
selectedBox = self.getBox(selected=True)
if selectedBox:
divisionsX = int(self.w.divisionsRadioY.get())
divisionsY = int(self.w.divisionsRadioX.get())
pt1, pt2, pt3, pt4, dimensions = selectedBox
pt1X, pt1Y = pt1 # bottom left
pt2X, pt2Y = pt2 # top left
pt3X, pt3Y = pt3 # top right
pt4X, pt4Y = pt4 # bottom right
width, height = dimensions
italicAngle = 0
if self.w.useItalic.get():
italicAngle = g.getParent().info.italicAngle or 0
g.prepareUndo()
#if self.w.viewX.get():
g.addGuide((pt1X, pt1Y), 90+italicAngle)
g.addGuide((pt3X, pt3Y), 90+italicAngle)
#if self.w.viewY.get():
g.addGuide((pt1X, pt1Y), 0)
g.addGuide((pt3X, pt3Y), 0)
g.performUndo()
def updateView(self, sender=None):
UpdateCurrentGlyphView()
installTool(BoundingTool())
penMethod(_roundPoint(x + w, y + hh + hh*r),
_roundPoint(x + hw + hw*r, y + h),
_roundPoint(x + hw, y + h))
penMethod(_roundPoint(x + hw - hw*r, y + h),
_roundPoint(x, y + hh + hh*r),
_roundPoint(x, y + hh))
penMethod(_roundPoint(x, y + hh - hh*r),
_roundPoint(x + hw - hw*r, y),
_roundPoint(x + hw, y))
pen.closePath()
elif self.drawingMode == COMPONENT_MODE and self.componentName and self.componentName != glyph.name:
pen.addComponent(self.componentName, [1, 0, 0, 1, x, y])
def getDefaultCursor(self):
return pixelCursor
def getToolbarIcon(self):
return pixelCursor.image()
def getToolbarTip(self):
return "Pixel Tool"
installTool(PixelTool())
if bezierTools.distanceFromPointToPoint(anchor, point) < s:
self.selection.addAnchor(anchor, self.shiftDown)
self._selectedMouseDownPoint = (anchor.x, anchor.y)
return
def mouseUp(self, point):
self.pEnd = point
self._getSelectedPoints()
self.pStart = None
self.pEnd = None
self._selectedMouseDownPoint = None
def mouseDragged(self, point, delta):
self.pEnd = point
#self._getSelectedPoints()
def draw(self, scale):
if self.isDragging() and self.pStart and self.pEnd:
r = self.getMarqueRect()
if r:
color = getDefaultColor('glyphViewSelectionMarqueColor')
color.set()
path = NSBezierPath.bezierPathWithRect_(r)
path.fill()
return
self.drawSelection(scale)
installTool(AnchorTool())
#print("Anchor Tool installed in tool bar.")
self.convertToLine(g)
def convertToLine(self, glyph):
if glyph and glyph.selection != []:
glyph.prepareUndo()
for c_index in range(len(glyph.contours)):
c = glyph.contours[c_index]
for s_index in range(len(c.segments)):
s = c.segments[s_index]
if s.selected and s.type == "curve":
s.type = "line"
s.points[0].smooth = False
s.smooth = False
c.segments[s_index - 1].points[-1].smooth = False
glyph.deselect()
UpdateCurrentGlyphView()
glyph.changed()
def getToolbarTip(self):
return "Eraser Tool"
def getToolbarIcon(self):
return toolbarIcon
def getDefaultCursor(self):
return eraserCursor
installTool(EraserTool())
self.updateRoundablePoints()
# def keyUp(self, event):
# print "keyUp"
# def modifiersChanged(self):
# pass
# def drawBackground(self, scale):
# print "drawBackground here"
#def getDefaultCursor(self):
# this will be the cursor default is an arrow
# return aNSCursor
def getToolbarIcon(self):
return toolbarIcon
def getToolbarTip(self):
return "Rounding Tool"
#notifications
def viewDidChangeGlyph(self):
self.init()
# def preferencesChanged(self):
# print "prefs changed"
installTool(RoundingTool())
#tangent 1, horizontal
self._t1_h = self._xMin + .5 * self._width - self.flatFactor_x * .5 * self._width
#tangent 2, horizontal
self._t2_h = self._xMin + .5 * self._width + self.flatFactor_x * .5 * self._width
#tangent 1, vertical
self._t1_v = self._yMin + .5 * self._height - self.flatFactor_y * .5 * self._height
#tangent 2, vertical
self._t2_v = self._yMin + .5 * self._height + self.flatFactor_y * .5 * self._height
#tangent 1, horizontal
self._t1_h = self._xMin + .5 * self._width - self.flatFactor_x * .5 * self._width
#tangent 2, horizontal
self._t2_h = self._xMin + .5 * self._width + self.flatFactor_x * .5 * self._width
# bcps
self._b1_v = self._yMin + self.bcpFactor_y * (self._t1_v - self._yMin)
self._b2_v = self._t2_v + (1 - self.bcpFactor_y) * (self._yMax -
self._t2_v)
self._b1_h = self._xMin + self.bcpFactor_x * (self._t1_h - self._xMin)
self._b2_h = self._t2_h + (1 - self.bcpFactor_x) * (self._xMax -
self._t2_h)
def canSelectWithMarque(self):
return False
def getToolbarTip(self):
return "Symmetrical Round Shape Drawing Tool"
installTool(SymmetricalRoundShapeDrawingTool())
for contour in glyph:
for point in contour.points:
result = path.containsPoint_((point.x, point.y))
if self.controlDown:
point.selected = not result
else:
point.selected = result
self._oldPen = self.pen
self.pen = None
def draw(self, scale):
if self.pen is None:
return
fill(0, .1)
stroke(0, .6)
strokeWidth(scale)
drawPath(self.pen.path)
def canSelectWithMarque(self):
return False
def getToolbarTip(self):
return "Lasso"
def getToolbarIcon(self):
return toolbarIcon
installTool(PolygonSelectionTool())
# apply default _mouseDragged behavior first
shiftdown = self.shiftDown
self.shiftDown = False
super()._mouseDragged(point, delta)
self.shiftDown = shiftdown
# handle single off-curve point selection
if self.shiftDown and self.selection.containsSingleOffCurve():
# get selected off-curve point
offcurve = self.selection.selectedPoints[0]
# get related on-curve point
info = self.selection.selectionDataForPoint(offcurve)
anchor = info["anchor"]
# calculate delta for off-curve point
offcurveDelta = Point(
(offcurve.x - anchor.x, offcurve.y - anchor.y))
# constrain delta to angle
self.modifyDeltaForAngle(offcurveDelta, self.angle)
# update position of off-curve point
offcurve.x = anchor.x + offcurveDelta.x
offcurve.y = anchor.y + offcurveDelta.y
installTool(ConstrainAngleEditingTool())
new_x_baseGlyph_anchor = selectedComponent_anchor.x + selected_component.offset[
0] - x_offset
new_y_baseGlyph_anchor = selectedComponent_anchor.y + selected_component.offset[
1] - y_offset
self.drawInfos(
new_x_baseGlyph_anchor,
new_y_baseGlyph_anchor,
viewScale,
glyphView,
baseGlyph_anchor
)
### Update baseGlyph anchor
baseGlyph_anchor.x = new_x_baseGlyph_anchor
baseGlyph_anchor.y = new_y_baseGlyph_anchor
if self.SettingsWindow.w.updateComposites.get(
) == 1:
self.updateRelatedComposites(
glyph_constructor,
cg, cf,
new_base_glyph,
baseGlyph_anchor,
composed_glyph
)
installTool(ComponentTool())
for segment in self.selectedSegments:
selectedOnCurves = []
selectedOffCurves = []
for point in segment.points:
if point.type == "offcurve":
selectedOffCurves.append(point)
else:
selectedOnCurves.append(point)
pt0 = self._findPrevOnCurvePt(selectedOnCurves[0],
contourPoints).position
pt1 = selectedOnCurves[0].position
pt2 = selectedOffCurves[0].position
pt3 = selectedOffCurves[1].position
# if lines are parallel, lines are green; otherwise, red
if self._checkParallel((pt0, pt1), (pt2, pt3)):
dt.stroke(0, 1, 0, 1)
else:
dt.stroke(1, 0, 0, 1)
dt.strokeWidth(lineThickness)
dt.line(pt0, pt1)
dt.line(pt2, pt3)
def getToolbarTip(self):
return "Check Parallel Tool"
installTool(CheckParallel())
path = NSBezierPath.bezierPathWithRect_(rect)
elif self.shape == "oval":
## create a oval path
path = NSBezierPath.bezierPathWithOvalInRect_(rect)
## set the line width
path.setLineWidth_(scale)
## draw without anit-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())
class MyTool(BaseEventTool):
def setup(self):
self.position = None
def mouseDown(self, point, clickCount):
self.position = point
def mouseDragged(self, point, delta):
self.position = point
def mouseUp(self, point):
self.position = None
def draw(self, scale):
if self.position is not None:
size = 10
x = self.position.x - size
y = self.position.y - size
fill(None)
stroke(1, 0, 0)
oval(x, y, size*2, size*2)
def getToolbarTip(self):
return "My Tool Tip"
installTool(MyTool())
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())
UpdateCurrentGlyphView()
def drawInactive(self,info):
self.drawPoints(info)
class SurgeonTool(EditingTool):
def becomeActive(self):
self.SurgeonToolUI = BezierSurgeon()
def becomeInactive(self):
self.SurgeonToolUI.closeWindow(None)
self.SurgeonToolUI.w.close()
def glyphWindowDidOpen(self, info):
self.SurgeonToolUI.w.show()
def glyphWindowWillClose(self,info):
# print("becomeInactive_noWindow")
self.SurgeonToolUI.closeWindow(None)
self.SurgeonToolUI.w.hide()
def getToolbarTip(self):
return "Bezier Surgeon"
def getToolbarIcon(self):
return toolbarIcon
installTool(SurgeonTool())
# scale bcps:
newDistX = diff(p1.anchor[0], p2.anchor[0])
newDistY = diff(p1.anchor[1], p2.anchor[1])
p1.bcpOut = newDistX * p1xr, newDistY * p1yr
p2.bcpIn = newDistX * p2xr, newDistY * p2yr
# correct bcp angles:
if prevType == 'line' and p1smooth: # smooth line before
bcpLen = sqrt(p1.bcpOut[0]**2 + p1.bcpOut[1]**2)
p1.bcpOut = smoothLines(p1, p0, bcpLen)
elif p1yx: # angled p1.bcpOuts
if not self.commandDown or self.isArrowKeyDown:
bcpLen = sqrt(p1.bcpOut[0]**2 + p1.bcpOut[1]**2)
newX = bcpLen / sqrt(p1yx**2 + 1)
newY = bcpLen / sqrt(p1xy**2 + 1)
p1.bcpOut = newX * p1dx, newY * p1dy
if nextType == 'line' and p2smooth: # smooth line after
bcpLen = sqrt(p2.bcpIn[0]**2 + p2.bcpIn[1]**2)
p2.bcpIn = smoothLines(p2, p3, bcpLen)
elif p2yx: # angled p2.bcpIns
if not self.commandDown or self.isArrowKeyDown:
bcpLen = sqrt(p2.bcpIn[0]**2 + p2.bcpIn[1]**2)
newX = bcpLen / sqrt(p2yx**2 + 1)
newY = bcpLen / sqrt(p2xy**2 + 1)
p2.bcpIn = newX * p2dx, newY * p2dy
installTool(ScalingEditTool())
self._selectedMouseDownPoint = p
break
def mouseUp(self, point):
self.pEnd = point
self._getSelectedPoints()
#print self.errorSelection
self.pStart = None
self.pEnd = None
self._selectedMouseDownPoint = None
def mouseDragged(self, point, delta):
self.pEnd = point
#self._getSelectedPoints()
def draw(self, scale):
if self.isDragging() and self.pStart and self.pEnd:
r = self.getMarqueRect()
if r:
color = getDefaultColor('glyphViewSelectionMarqueColor')
color.set()
path = NSBezierPath.bezierPathWithRect_(r)
path.fill()
return
self.drawSelection(scale)
def drawSelection(self, scale):
self.errorSelection.draw(scale)
installTool(RedArrowFixerTool())
print "Red Arrow Fixer installed in tool bar."