def _drawGlyphOutlines(self, glyphName): dt.save() dt.fill(*BLACK) dt.stroke(None) glyphToDisplay = self.fontObj[glyphName] dt.drawGlyph(glyphToDisplay) dt.restore()
def draw(self, info): if not self.calculatePreview: return cur = CurrentGlyph() if cur == None: return; scale = info['scale'] layerToConvert = self.layers[self.w.layerPopup.get()] otherLayer = layerToConvert != 'foreground' if (not otherLayer) and (CurrentFont().lib['com.typemytype.robofont.segmentType'] == 'qcurve'): return if otherLayer: cur.flipLayers('foreground', layerToConvert) copy = cur.copy() if otherLayer: cur.flipLayers('foreground', layerToConvert) convert(copy, self.maxDistanceValue, self.minLengthValue, self.useArcLength) for c in copy: for p in c.points: if p.type == 'offCurve': color = OffColor r = 4*scale else: color = OnColor r = 6*scale self.drawDiscAtPoint(r, p.x, p.y, color) save() stroke(0.2, .8, .8, 1) fill(None) strokeWidth(scale) drawGlyph(copy) restore()
def _curvePreview(self, info): _doodle_glyph = info["glyph"] if CurrentGlyph() is not None and _doodle_glyph is not None and len(_doodle_glyph.components) == 0 and _doodle_glyph.selection != []: ######## # Here's how this works: if there is a current glyph, and that glyph has a selection, we get here # then there is a temp glyph, in memory. Every "draw", this is called, it clears the glyph # and then draws the current glyph in its place, then equilizes that glyph in a different # method, then draws it into this view. # The problem is the outline is not updating. If you commit the change it shows up, but this memory # glyph isn't getting redrawn ever. The glyph is redrawing the same thing over and over. ####### self.tmp_glyph.clear() self.tmp_glyph.appendGlyph(_doodle_glyph) # I think what needs to happen here is instead of this mysterious function happening, # it needs to return an equilized glyph object that is then drawn onto the view # instead of maintaining a virtual copy that needs to be cleared and updated each draw # more like tmp_glyph = self._equalized_glyph(_doodle_glyph); drawGlyph(tmp_glyph) # vvvvvvvvvvvvvvvv self._eqSelected() # ^^^^^^^^^^^^^^^^^ self.tmp_glyph.update() save() stroke(random(), random(), random(), 1.0) # stroke(0, 0, 0, 0.5) #if self.method == "hobby": # fill(1, 0, 0, 0.9) #else: fill(None) strokeWidth(info["scale"]) drawGlyph(self.tmp_glyph) restore()
def drawReferenceGlyph(aGlyph, scalingFactor, startingX, left=False, right=False): dt.save() dt.fill(*BLACK) dt.stroke(None) dt.translate(startingX, 0) dt.scale(scalingFactor, scalingFactor) dt.translate(0, -aGlyph.getParent().info.descender) dt.translate(-aGlyph.width / 2, 0) dt.fill(*BLACK) dt.drawGlyph(aGlyph) descender = aGlyph.getParent().info.descender unitsPerEm = aGlyph.getParent().info.unitsPerEm baseTck = 40 if left is True: dt.fill(*RED) dt.rect(0, -baseTck, aGlyph.leftMargin, baseTck) dt.rect(0, descender, 8, unitsPerEm) if right is True: dt.fill(*BLUE) dt.rect(aGlyph.width - aGlyph.rightMargin, -baseTck, aGlyph.rightMargin, baseTck) dt.rect(aGlyph.width, descender, 8, unitsPerEm) dt.restore()
def draw(self): # draw the color glyph on the canvas if self._font is not None: save() self.setFill(self.colorbg) rect(0, 0, 310, 200) self.setFill(self.color) scale(self.scale) translate(50.5, -self.metrics[0] + 20.5) self._canvas_draw_metrics() for i in range(len(self.layer_glyphs)): layerGlyph = self.layer_glyphs[i]["Layer Glyph"] if self._selected_color_index is None: op_factor = 1.0 else: if self._selected_color_index == self.layer_glyphs[i][ "layer_color_index"]: op_factor = 1.0 else: op_factor = 0.2 if layerGlyph in self.font: if i < len(self.layer_colors): _color = self.layer_colors[i] self.setFill(_color, op_factor) drawGlyph(self.font[layerGlyph]) restore()
def drawOnGlyphCanvas(self, infoDict): glyphOnCanvas = infoDict['glyph'] scalingFactor = infoDict['scale'] bodySize = .25 horizontalOffset = 80 if PLUGIN_LIB_NAME in glyphOnCanvas.lib: thisLib = glyphOnCanvas.lib[PLUGIN_LIB_NAME] else: return None lftGlyph = None if thisLib['lft'] != '': lftGlyph = self.selectedFont[thisLib['lft']] rgtGlyph = None if thisLib['rgt'] != '': rgtGlyph = self.selectedFont[thisLib['rgt']] try: dt.fill(*GRAY) if lftGlyph is not None: dt.save() dt.translate(-lftGlyph.width * bodySize - horizontalOffset, -self.selectedFont.info.unitsPerEm * bodySize) # glyph dt.scale(bodySize) dt.drawGlyph(lftGlyph) # lock if thisLib['lftActive'] is True: txt = u'🔒' else: txt = u'🔓' dt.fontSize(300) txtWdt, txtHgt = dt.textSize(txt) dt.text(txt, (-txtWdt, 0)) dt.restore() if rgtGlyph is not None: dt.save() dt.translate(glyphOnCanvas.width + horizontalOffset, -self.selectedFont.info.unitsPerEm * bodySize) dt.scale(bodySize) dt.drawGlyph(rgtGlyph) # lock if thisLib['rgtActive'] is True: txt = u'🔒' else: txt = u'🔓' dt.fontSize(300) dt.text(txt, (rgtGlyph.width, 0)) dt.restore() except Exception as error: print(error)
def draw(self, info): if not self.calculatePreview: return cur = CurrentGlyph() if cur == None: return scale = info['scale'] layerToConvert = self.layers[self.w.layerPopup.get()] otherLayer = layerToConvert != 'foreground' if (not otherLayer) and ( CurrentFont().lib['com.typemytype.robofont.segmentType'] == 'qcurve'): return if otherLayer: cur.flipLayers('foreground', layerToConvert) copy = cur.copy() if otherLayer: cur.flipLayers('foreground', layerToConvert) convert(copy, self.maxDistanceValue, self.minLengthValue, self.useArcLength) for c in copy: for p in c.points: if p.type == 'offCurve': color = OffColor r = 4 * scale else: color = OnColor r = 6 * scale self.drawDiscAtPoint(r, p.x, p.y, color) save() stroke(0.2, .8, .8, 1) fill(None) strokeWidth(scale) drawGlyph(copy) restore()
def _curvePreview(self, info): _doodle_glyph = info["glyph"] if roboFontVersion > "3.1": _doodle_glyph_selected_points = _doodle_glyph.selectedPoints else: _doodle_glyph_selected_points = _doodle_glyph.selection if CurrentGlyph() is not None \ and _doodle_glyph is not None \ and len(_doodle_glyph.components) == 0 \ and _doodle_glyph_selected_points != []: self.tmp_glyph = CurrentGlyph().copy() self._eqSelected() if self.previewCurves: save() stroke(0, 0, 0, 0.5) fill(None) strokeWidth(info["scale"]) drawGlyph(self.tmp_glyph) restore() if self.drawGeometry: self._drawGeometry(info) if self.previewHandles: self._handlesPreview(info)
def _drawGlyphBlack(self, glyph, scalingFactor, offset_X=0): dt.save() dt.translate(offset_X, 0) dt.fill(*BLACK_COLOR) dt.stroke(None) dt.drawGlyph(glyph) dt.restore()
def drawDiffGlyph(self, info): g = info["glyph"] if g is not None: if g.name in self.headGlyphs: save() strokeWidth(None) fill(1,0,0,0.2) drawGlyph(self.headGlyphs[g.name]) restore()
def drawVariationPreview(self, glyph, scale, color, strokecolor): mjdt.save() mjdt.fill(*color) mjdt.stroke(*strokecolor) mjdt.strokeWidth(scale) loc = {} if glyph.sourcesList: loc = {x["Axis"]: x["PreviewValue"] for x in glyph.sourcesList} for g in glyph.preview(loc, forceRefresh=False): # for g in glyph.previewGlyph: mjdt.drawGlyph(self.roundGlyph(g.glyph)) mjdt.restore()
def draw(self, info): self.w.pointSize.set(self.w.multiLineView.getPointSize()) glyph = self.RCJKI.currentFont[info["glyph"].name]#, self.RCJKI.currentFont._RFont) scale = info["scale"] sourcesList = {x["Axis"]:x["PreviewValue"] for x in self.sourcesList} mjdt.save() mjdt.fill(0, 0, 0, 1) mjdt.stroke(0, 0, 0, 0) mjdt.strokeWidth(scale) for c in glyph.preview(sourcesList, forceRefresh=True): mjdt.drawGlyph(c.glyph) mjdt.restore()
def _drawGlyphOutline(self, glyph, scalingFactor, offset_X=0): dt.save() dt.translate(offset_X, 0) dt.fill(None) dt.strokeWidth(1 * scalingFactor) dt.stroke(*LIGHT_GRAY_COLOR) dt.drawGlyph(glyph) scaledRadius = BCP_RADIUS * scalingFactor for eachContour in glyph: for eachBPT in eachContour.bPoints: dt.stroke(None) dt.fill(*LIGHT_GRAY_COLOR) dt.rect(eachBPT.anchor[0] - scaledRadius / 2., eachBPT.anchor[1] - scaledRadius / 2., scaledRadius, scaledRadius) if eachBPT.bcpIn != (0, 0): dt.stroke(None) dt.fill(*LIGHT_GRAY_COLOR) dt.oval( eachBPT.anchor[0] + eachBPT.bcpIn[0] - scaledRadius / 2., eachBPT.anchor[1] + eachBPT.bcpIn[1] - scaledRadius / 2., scaledRadius, scaledRadius) dt.stroke(*LIGHT_GRAY_COLOR) dt.fill(None) dt.line((eachBPT.anchor[0], eachBPT.anchor[1]), (eachBPT.anchor[0] + eachBPT.bcpIn[0], eachBPT.anchor[1] + eachBPT.bcpIn[1])) if eachBPT.bcpOut != (0, 0): dt.stroke(None) dt.fill(*LIGHT_GRAY_COLOR) dt.oval( eachBPT.anchor[0] + eachBPT.bcpOut[0] - scaledRadius / 2., eachBPT.anchor[1] + eachBPT.bcpOut[1] - scaledRadius / 2., scaledRadius, scaledRadius) dt.stroke(*LIGHT_GRAY_COLOR) dt.fill(None) dt.line((eachBPT.anchor[0], eachBPT.anchor[1]), (eachBPT.anchor[0] + eachBPT.bcpOut[0], eachBPT.anchor[1] + eachBPT.bcpOut[1])) dt.restore()
def _curvePreview(self, info): _doodle_glyph = info["glyph"] if _doodle_glyph is not None and len(_doodle_glyph.components) == 0 and _doodle_glyph.selection != []: self.tmp_glyph.clear() self.tmp_glyph.appendGlyph(_doodle_glyph) self._eqSelected() save() stroke(0, 0, 0, 0.5) #if self.method == "hobby": # fill(1, 0, 0, 0.9) #else: fill(None) strokeWidth(info["scale"]) drawGlyph(self.tmp_glyph) restore()
def spaceCenterDraw(self, notification): glyph = notification["glyph"] attrValues = self.getAttributes() outGlyph = self.getGlyph(glyph, *attrValues) box = glyph.box if box: x, y, maxx, maxy = box w = maxx - x h = maxy - y drawingTools.fill(1) offset = 10 drawingTools.rect(x-offset, y-offset, w+offset*2, h+offset*2) drawingTools.fill(0) drawingTools.drawGlyph(outGlyph)
def _curvePreview(self, info): _doodle_glyph = info["glyph"] if _doodle_glyph is not None and len( _doodle_glyph.components ) == 0 and _doodle_glyph.selection != []: self.tmp_glyph.clear() self.tmp_glyph.appendGlyph(_doodle_glyph) self._eqSelected() save() stroke(0, 0, 0, 0.5) #if self.method == "hobby": # fill(1, 0, 0, 0.9) #else: fill(None) strokeWidth(info["scale"]) drawGlyph(self.tmp_glyph) restore()
def _observer_draw_glyph_window(self, info): # draw the color glyph in the glyph window # print("DEBUG: _observer_draw_glyph_window") if self.glyphPreview in self.cfont.keys(): # print("DEBUG: draw glyph") save() self.setFill(self.color) for i in range(len(self.layer_glyphs_glyph_window)): layerGlyph = self.layer_glyphs_glyph_window[i] if layerGlyph in self.font: if i < len(self.layer_colors_glyph_window): _color = self.layer_colors_glyph_window[i] self.setFill(_color) drawGlyph(self.font[layerGlyph]) restore() if self._debug_enable_live_editing: self.w.preview.update()
def draw(self): if not self.RCJKI.get("currentFont"): return if not self.glyph: return # self.glyph = self.RCJKI.currentFont[self.glyphName] # glyph = self.glyph.preview.computeCharacterGlyphPreview(self.glyph, {"WGHT":1}) mjdt.save() scale = .15 mjdt.scale(scale, scale) mjdt.translate(((200-(self.glyph.width*scale))/scale)*.5, 450) # for g in self.glyph.preview({}, forceRefresh=False): locationKey = ','.join([k+':'+str(v) for k,v in self.glyph.getLocation().items()]) if locationKey in self.glyph.previewLocationsStore: for g in self.glyph.previewLocationsStore[locationKey]: # for g in self.glyph.preview({}, forceRefresh=False): mjdt.drawGlyph(g.glyph) mjdt.restore()
def drawAnchoredGlyphs(self, glyph, preview=False): self.setStroke(0) if preview: self.setFill(self.preview_color) else: self.setFill() #start = time() dbx = 0 dby = 0 for a in glyph.anchors: anchor_name = a.name #print(" %s" % anchor_name) if self.fontAnchors.getVisibility("anchor", anchor_name): glyphsToDraw = self.fontAnchors.getAnchoredGlyphNames( anchor_name) # get translation for base anchor dbx = a.x dby = a.y save() for gn in glyphsToDraw: if (anchor_name[0] != "_" and self.fontAnchors.getVisibility( "mark", gn, False)) or (anchor_name[0] == "_" and self.fontAnchors.getVisibility( "glyph", gn, False)): # get translation for current mark anchor dmx, dmy = self.fontAnchors.anchorPositions[ gn, self.fontAnchors.getMatchingAnchorName(anchor_name )] x = dbx - dmx y = dby - dmy translate(x, y) drawGlyph(self.fontAnchors.font[gn]) dbx = dmx dby = dmy restore()
def spaceCenterDraw(self, notification): glyph = notification["glyph"] spaceCenter = notification["spaceCenter"] scale = notification["scale"] attrValues = self.getAttributes() outGlyph = self.getGlyph(glyph, *attrValues) inverse = spaceCenter.glyphLineView.getDisplayStates()['Inverse'] foreground = tuple(getDefault('spaceCenterGlyphColor')) if not inverse else tuple(getDefault('spaceCenterBackgroundColor')) background = tuple(getDefault('spaceCenterBackgroundColor')) if not inverse else tuple(getDefault('spaceCenterGlyphColor')) # cover current glyph drawingTools.fill(*background) drawingTools.stroke(*background) drawingTools.strokeWidth(2*scale) drawingTools.drawGlyph(glyph) drawingTools.stroke(None) # draw glyph preview drawingTools.fill(*foreground) drawingTools.drawGlyph(outGlyph)
def draw(self): if not self.RCJKI.get("currentFont"): return if not self.glyph: return # self.glyph = self.RCJKI.currentFont[self.glyphName] # glyph = self.glyph.preview.computeCharacterGlyphPreview(self.glyph, {"WGHT":1}) mjdt.save() scale = .15 mjdt.scale(scale, scale) mjdt.translate(((200 - (self.glyph.width * scale)) / scale) * .5, 450) # for g in self.glyph.preview({}, forceRefresh=False): locationKey = ','.join( [k + ':' + str(v) for k, v in self.glyph.getLocation().items()]) if locationKey in self.glyph.previewLocationsStore: for g in self.glyph.previewLocationsStore[locationKey]: # for g in self.glyph.preview({}, forceRefresh=False): mjdt.drawGlyph(g.glyph) mjdt.restore() # outlines, items, width = self.instantiateCharacterGlyph(self.glyph, {"WGHT":1}) # print(outlines, items, width) # self.glyph = self.RCJKI.currentFont[self.glyphName] # d = self.glyph._glyphVariations # if self.glyph.type == "atomicElement": # self.glyph.sourcesList = [ # {"Axis":axisName, "Layer":layer, "PreviewValue":layer.minValue} for axisName, layer in d.items() # ] # else: # self.glyph.sourcesList = [ # {"Axis":axisName, "Layer":layerName, "PreviewValue":layerName.minValue} for axisName, layerName in d.items() # ] if self.glyph.markColor is not None: mjdt.fill(*self.glyph.markColor) mjdt.rect(0, 0, 200, 20)
def _drawGlyphOutlinesFromGroups(self, aPair, kerningReference, correction): prevGlyphName, eachGlyphName = aPair if kerningReference is not None: lftReference, rgtReference = kerningReference else: lftReference = whichGroup(prevGlyphName, 'left', self.fontObj) rgtReference = whichGroup(eachGlyphName, 'right', self.fontObj) prevGlyph, eachGlyph = self.fontObj[prevGlyphName], self.fontObj[ eachGlyphName] reverseScalingFactor = 1 / ( self.ctrlHeight / (self.canvasScalingFactor * self.fontObj.info.unitsPerEm)) # _L__ group if lftReference: if lftReference.startswith('@MMK_L_'): dt.save() dt.fill(*LAYERED_GLYPHS_COLOR) groupContent = self.fontObj.groups[lftReference] if len(groupContent) > 1: for eachGroupSibling in groupContent: if eachGroupSibling != prevGlyphName: glyphToDisplay = self.fontObj[eachGroupSibling] dt.save() dt.translate( -glyphToDisplay.width, 0 ) # back, according to his width, otherwise it does not coincide dt.drawGlyph(glyphToDisplay) dt.restore() dt.fill(*BLACK) # caption dt.translate(-prevGlyph.width, 0) # we need a caption in the right place dt.font(SYSTEM_FONT_NAME) dt.fontSize(GROUP_NAME_BODY_SIZE * reverseScalingFactor) textWidth, textHeight = dt.textSize(lftReference) dt.text(lftReference, (glyphToDisplay.width / 2. - textWidth / 2., -GROUP_NAME_BODY_SIZE * reverseScalingFactor * 2)) dt.restore() # _R__ group if rgtReference: if rgtReference.startswith('@MMK_R_'): dt.save() dt.translate(correction, 0) dt.fill(*LAYERED_GLYPHS_COLOR) groupContent = self.fontObj.groups[rgtReference] if len(groupContent) > 1: for eachGroupSibling in groupContent: if eachGroupSibling != eachGlyphName: glyphToDisplay = self.fontObj[eachGroupSibling] dt.drawGlyph(glyphToDisplay) dt.fill(*BLACK) dt.font(SYSTEM_FONT_NAME) dt.fontSize(GROUP_NAME_BODY_SIZE * reverseScalingFactor) textWidth, textHeight = dt.textSize(rgtReference) dt.text(rgtReference, (glyphToDisplay.width / 2. - textWidth / 2., -GROUP_NAME_BODY_SIZE * reverseScalingFactor * 2)) dt.restore()
def draw(self): w = self.w.c.width() h = self.w.c.height() m = 130 center = w * .5, h * .5 d = self.dotSize r = min(.5 * (h - 2 * m), .5 * (w - 2 * m)) if self.pointer is None: self.pointer = center a1 = self.orientation * math.pi a2 = a1 + 2 / 3 * math.pi a3 = a1 - 2 / 3 * math.pi self.p1 = p1 = center[0] + (r * math.sin(a1)), center[1] + ( r * math.cos(a1)) self.p2 = p2 = center[0] + (r * math.sin(a2)), center[1] + ( r * math.cos(a2)) self.p3 = p3 = center[0] + (r * math.sin(a3)), center[1] + ( r * math.cos(a3)) self.snapped = None if self.closeToPoint(self.p1, self.pointer): self.pointer = self.p1 self.snapped = 0 if self.closeToPoint(self.p2, self.pointer): self.pointer = self.p2 self.snapped = 1 if self.closeToPoint(self.p3, self.pointer): self.pointer = self.p3 self.snapped = 2 p1d = p1[0] - .5 * d, p1[1] - .5 * d, d, d p2d = p2[0] - .5 * d, p2[1] - .5 * d, d, d p3d = p3[0] - .5 * d, p3[1] - .5 * d, d, d ctx.save() ctx.stroke(.8, .8, .7) ctx.strokeWidth(.4) ctx.strokeWidth(.8) ctx.line(p1, p2) ctx.line(p2, p3) ctx.line(p3, p1) if self.pointer is not None: ctx.line(p1, self.pointer) ctx.line(p2, self.pointer) ctx.line(p3, self.pointer) ctx.stroke(None) ctx.fill(0) ctx.oval(*p1d) ctx.oval(*p2d) ctx.oval(*p3d) g1, g2, g3 = self.glyphs if g1 is not None: ctx.save() ctx.translate(p1[0], p1[1]) ctx.scale(self.glyphScale) ctx.translate(100, 0) ctx.drawGlyph(g1) ctx.restore() if g2 is not None: ctx.save() ctx.translate(p2[0], p2[1]) ctx.scale(self.glyphScale) ctx.translate(100, 0) ctx.drawGlyph(g2) ctx.restore() if g3 is not None: ctx.save() ctx.translate(p3[0], p3[1]) ctx.scale(self.glyphScale) ctx.translate(100, 0) ctx.drawGlyph(g3) ctx.restore() if self.pointer: ctx.save() ctx.fill(1, 0, 0) ctx.stroke(None) d = 10 ctx.oval(self.pointer[0] - .5 * d, self.pointer[1] - .5 * d, d, d) f1, f2, f3 = ip(p1, p2, p3, self.pointer) self._factors = f1, f2, f3 r = None if self.mGlyphs is not None: if None not in self.mGlyphs: try: self.result = r = f1 * self.mGlyphs[ 0] + f2 * self.mGlyphs[1] + f3 * self.mGlyphs[2] except IndexError or TypeError: print("Sorry, these glyphs can't interpolate..") if r: ctx.save() ctx.translate(self.pointer[0], self.pointer[1]) ctx.scale(self.glyphScale) ctx.translate(100, 0) g = RGlyph() g.fromMathGlyph(r) ctx.drawGlyph(g) t = "{:02.2f}, {:02.2f}, {:02.2f}".format(f1, f2, f3) ctx.font("Menlo-Regular") ctx.fontSize(6 / self.glyphScale) ctx.text(t, (0, -200)) ctx.restore() ctx.restore() ctx.restore()
def drawAxisPreview(self, glyph, color, scale, customColor, view=False, flatComponentColor=(.8, .6, 0, .7), drawSelectedElements=True): mjdt.save() index = None # loc = {} # if glyph.selectedSourceAxis: # loc = {glyph.selectedSourceAxis:1} # for i, atomicInstance in enumerate(glyph.preview()): for i, atomicInstance in enumerate( glyph.preview(forceRefresh=False, axisPreview=True)): # for i, atomicInstance in enumerate(glyph.previewGlyph): transformIntance = atomicInstance._transformation atomicInstance = atomicInstance.glyph mjdt.fill(*color) if drawSelectedElements and i in glyph.selectedElement: mjdt.save() mjdt.stroke(1, 0, 0, 1) mjdt.strokeWidth(1 * scale) tx = transformIntance['x'] + transformIntance['tcenterx'] ty = transformIntance['y'] + transformIntance['tcentery'] mjdt.line((tx - 5 * scale, ty), (tx + 5 * scale, ty)) mjdt.line((tx, ty - 5 * scale), (tx, ty + 5 * scale)) mjdt.stroke(None) mjdt.fill(1, 0, 0, 1) mjdt.fontSize(8 * scale) mjdt.textBox( f"{int(transformIntance['tcenterx'])} {int(transformIntance['tcentery'])}", ((tx - 30 * scale, ty - 30 * scale, 60 * scale, 20 * scale)), align="center") mjdt.restore() mjdt.fill(0, .8, .8, .5) # for c in atomicInstance: # if c.clockwise: # mjdt.stroke(1, 0, 0, 1) # mjdt.strokeWidth(2*scale) mjdt.save() # mjdt.drawGlyph(atomicInstance.getTransformedGlyph(round = self.RCJKI.roundToGrid)) mjdt.drawGlyph(atomicInstance) mjdt.restore() if customColor is None and view: if i != index: self.drawIndexOfElements(i, atomicInstance, view) if glyph.type == "characterGlyph": response = self.RCJKI.currentFont.mysqlGlyphData.get( glyph.name, False) try: if response: for dc in response["made_of"]: if dc["name"] != glyph._deepComponents[ i].name: continue char = getChar(dc["name"]) if not char: continue txt = "%s/%s\nused at %s%s" % ( len(dc["used_by"]), len(self.RCJKI.currentFont. deepComponents2Chars[char]), round( (len(dc["used_by"]) / len(self.RCJKI.currentFont. deepComponents2Chars[char])) * 100), "%") x, y = atomicInstance[0].points[ 0].x, atomicInstance[0].points[0].y mjdt.fill(1, 0, 1, 1) mjdt.fontSize(10 * scale) mjdt.text(txt, (x, y - 30 * scale)) except Exception as e: pass index = i if customColor is None: mjdt.fill(customColor) else: mjdt.fill(*customColor) mjdt.drawGlyph(glyph) mjdt.restore() for c in glyph.flatComponents: if self.RCJKI.currentFont[c.baseGlyph].type == "atomicElement": mjdt.drawGlyph( self.roundGlyph(self.RCJKI.currentFont[c.baseGlyph])) else: # self.RCJKI.currentFont[c.baseGlyph].preview.computeDeepComponents(update = False) self.drawAxisPreview(self.RCJKI.currentFont[c.baseGlyph], flatComponentColor, scale, customColor, view)
def _drawCentralBackgroundGlyph(self, glyph): dt.save() dt.fill(*LIGHT_GRAY_COLOR) dt.drawGlyph(glyph) dt.restore()
def draw(self, info, customColor=None, refGlyph=None, onlyPreview=False): view = info["view"] scale = info['scale'] color = customColor # if self.RCJKI.currentGlyph.preview.variationPreview: if info["notificationName"] == "draw": previewColor = [(0, 0, 0, 0), (0, 0, 0, .7)][onlyPreview] previewStrokeColor = [(0, 0, 0, .2), (0, 0, 0, 0)][onlyPreview] else: previewColor = [(0, 0, 0, 0), (0, 0, 0, 1)][onlyPreview] previewStrokeColor = [(0, 0, 0, .2), (0, 0, 0, 0)][onlyPreview] self.drawVariationPreview(self.RCJKI.currentGlyph, scale, color=previewColor, strokecolor=previewStrokeColor) # if not onlyPreview: # mjdt.save() # locker = self.RCJKI.currentFont.glyphLockedBy(self.RCJKI.currentGlyph) # if locker != self.RCJKI.currentFont.lockerUserName: # mjdt.fill(1, 0, 0, .1) # mjdt.rect(0, -2000, self.RCJKI.currentFont.defaultGlyphWidth, 10000) # mjdt.fill(1, 0, 0, 1) # mjdt.font("Helvetica") # mjdt.fontSize(40) # mjdt.textBox(f"Already locked by {locker}", (0, 900, 1000, 100), align = 'center') # mjdt.restore() if self.RCJKI.currentGlyph.type == "atomicElement": return if self.refGlyph is not None: mjdt.save() mjdt.fill(0, 0, 0, .2) mjdt.translate(*self.refGlyphPos) mjdt.scale(*self.refGlyphScale) mjdt.drawGlyph(self.roundGlyph(self.refGlyph)) mjdt.restore() if self.existingInstance is not None: mjdt.save() mjdt.fill(1, .8, 0, .8) mjdt.translate(*self.existingInstancePos) mjdt.scale(*self.existingInstanceScale) for c in self.existingInstance: mjdt.drawGlyph(self.roundGlyph(c)) mjdt.restore() if onlyPreview: return if self.RCJKI.currentGlyph.type == "deepComponent": if not color: if not self.RCJKI.currentGlyph.selectedSourceAxis: color = (0, .5, .25, .4) else: color = (.5, .25, 0, .2) elif self.RCJKI.currentGlyph.type == "characterGlyph": if not color: if not self.RCJKI.currentGlyph.selectedSourceAxis: color = (.25, 0, .5, .8) else: color = (.5, 0, .25, .4) self.drawAxisPreview(self.RCJKI.currentGlyph, color, scale, customColor, view)