Exemple #1
0
def transform(shiftX=0.0, shiftY=0.0, rotate=0.0, skew=0.0, scale=1.0):
    """
	Returns an NSAffineTransform object for transforming layers.
	Apply an NSAffineTransform t object like this:
		Layer.transform_checkForSelection_doComponents_(t,False,True)
	Access its transformation matrix like this:
		tMatrix = t.transformStruct() # returns the 6-float tuple
	Apply the matrix tuple like this:
		Layer.applyTransform(tMatrix)
		Component.applyTransform(tMatrix)
		Path.applyTransform(tMatrix)
	Chain multiple NSAffineTransform objects t1, t2 like this:
		t1.appendTransform_(t2)
	"""
    myTransform = NSAffineTransform.transform()
    if rotate:
        myTransform.rotateByDegrees_(rotate)
    if scale != 1.0:
        myTransform.scaleBy_(scale)
    if not (shiftX == 0.0 and shiftY == 0.0):
        myTransform.translateXBy_yBy_(shiftX, shiftY)
    if skew:
        skewStruct = NSAffineTransformStruct()
        skewStruct.m11 = 1.0
        skewStruct.m22 = 1.0
        skewStruct.m21 = math.tan(math.radians(skew))
        skewTransform = NSAffineTransform.transform()
        skewTransform.setTransformStruct_(skewStruct)
        myTransform.appendTransform_(skewTransform)
    return myTransform
Exemple #2
0
    def drawRect_(self, rect):

        NSColor.whiteColor().set()
        NSBezierPath.fillRect_(rect)

        if Glyphs.font is None:
            return

        if not Glyphs.font.selectedLayers:
            return

        glyphToRotate = None
        try:
            glyphToRotate = Glyphs.font.selectedLayers[0]
        except:
            print(traceback.format_exc())

        if glyphToRotate is None:
            return

        try:
            previewPath = glyphToRotate.completeBezierPath

            rotationFactor = self.wrapper._rotationFactor
            Width = NSWidth(self.frame())
            Height = NSHeight(self.frame())

            scaleFactor = 0.666666 / (glyphToRotate.parent.parent.upm /
                                      min(Width, Height))

            ## scaling and zeroing the glyph
            #------------------------
            transform = NSAffineTransform.transform()
            transform.scaleBy_(scaleFactor)
            bounds = glyphToRotate.bounds
            transform.translateXBy_yBy_(-NSMidX(bounds), -NSMidY(bounds))
            previewPath.transformUsingAffineTransform_(transform)

            ## rotation
            #------------------------
            transform = NSAffineTransform.transform()
            transform.rotateByDegrees_(rotationFactor)
            previewPath.transformUsingAffineTransform_(transform)

            ## positioning to the middle of the viewport
            #------------------------
            transform = NSAffineTransform.transform()
            transform.translateXBy_yBy_(Width / 2, Height / 2 - 8)
            previewPath.transformUsingAffineTransform_(transform)

            ## fill path
            #------------------------
            NSColor.blackColor().set()
            previewPath.fill()

        except:
            print(traceback.format_exc())
Exemple #3
0
 def getImage(self):
     image = NSImage.alloc().initWithSize_((self.width, self.height))
     image.setFlipped_(True)
     image.lockFocus()
     context = NSGraphicsContext.currentContext()
     bodyRect = ((0, 0), (self.width, self.height - self.headerHeight))
     headerRect = ((0, -self.height + self.headerHeight),
                   (self.width, self.headerHeight))
     # draw a background color
     cellBackgroundColor.set()
     NSRectFill(((0, 0), (self.width, self.height)))
     # background
     context.saveGraphicsState()
     bodyTransform = NSAffineTransform.transform()
     bodyTransform.translateXBy_yBy_(0, self.height - self.headerHeight)
     bodyTransform.scaleXBy_yBy_(1.0, -1.0)
     bodyTransform.concat()
     self.drawCellBackground(bodyRect)
     context.restoreGraphicsState()
     # glyph
     if self.shouldDrawMetrics:
         self.drawCellHorizontalMetrics(bodyRect)
         self.drawCellVerticalMetrics(bodyRect)
     context.saveGraphicsState()
     NSBezierPath.clipRect_(
         ((0, 0), (self.width, self.height - self.headerHeight)))
     glyphTransform = NSAffineTransform.transform()
     glyphTransform.translateXBy_yBy_(self.xOffset, self.yOffset)
     glyphTransform.scaleBy_(self.scale)
     glyphTransform.concat()
     self.drawCellGlyph()
     context.restoreGraphicsState()
     # foreground
     context.saveGraphicsState()
     bodyTransform.concat()
     self.drawCellForeground(bodyRect)
     context.restoreGraphicsState()
     # header
     if self.shouldDrawHeader:
         context.saveGraphicsState()
         headerTransform = NSAffineTransform.transform()
         headerTransform.translateXBy_yBy_(0, self.headerHeight)
         headerTransform.scaleXBy_yBy_(1.0, -1.0)
         headerTransform.concat()
         self.drawCellHeaderBackground(headerRect)
         self.drawCellHeaderText(headerRect)
         context.restoreGraphicsState()
     # done
     image.unlockFocus()
     return image
 def getImage(self):
     image = NSImage.alloc().initWithSize_((self.width, self.height))
     image.setFlipped_(True)
     image.lockFocus()
     context = NSGraphicsContext.currentContext()
     bodyRect = ((0, 0), (self.width, self.height - self.headerHeight))
     headerRect = ((0, -self.height + self.headerHeight), (self.width, self.headerHeight))
     # draw a background color
     cellBackgroundColor.set()
     NSRectFill(((0, 0), (self.width, self.height)))
     # background
     context.saveGraphicsState()
     bodyTransform = NSAffineTransform.transform()
     bodyTransform.translateXBy_yBy_(0, self.height - self.headerHeight)
     bodyTransform.scaleXBy_yBy_(1.0, -1.0)
     bodyTransform.concat()
     self.drawCellBackground(bodyRect)
     context.restoreGraphicsState()
     # glyph
     if self.shouldDrawMetrics:
         self.drawCellHorizontalMetrics(bodyRect)
         self.drawCellVerticalMetrics(bodyRect)
     context.saveGraphicsState()
     NSBezierPath.clipRect_(((0, 0), (self.width, self.height - self.headerHeight)))
     glyphTransform = NSAffineTransform.transform()
     glyphTransform.translateXBy_yBy_(self.xOffset, self.yOffset)
     glyphTransform.scaleBy_(self.scale)
     glyphTransform.concat()
     self.drawCellGlyph()
     context.restoreGraphicsState()
     # foreground
     context.saveGraphicsState()
     bodyTransform.concat()
     self.drawCellForeground(bodyRect)
     context.restoreGraphicsState()
     # header
     if self.shouldDrawHeader:
         context.saveGraphicsState()
         headerTransform = NSAffineTransform.transform()
         headerTransform.translateXBy_yBy_(0, self.headerHeight)
         headerTransform.scaleXBy_yBy_(1.0, -1.0)
         headerTransform.concat()
         self.drawCellHeaderBackground(headerRect)
         self.drawCellHeaderText(headerRect)
         context.restoreGraphicsState()
     # done
     image.unlockFocus()
     return image
Exemple #5
0
def drawTextAtPoint(text, pt, scale, attributes={}, xAlign="left", yAlign="bottom", flipped=False):
    text = NSAttributedString.alloc().initWithString_attributes_(text, attributes)
    if xAlign != "left" or yAlign != "bottom":
        width, height = text.size()
        width *= scale
        height *= scale
        x, y = pt
        f = 1
        if flipped:
            f = -1
        if xAlign == "center":
            x -= width / 2
        elif xAlign == "right":
            x -= width
        if yAlign == "center":
            y -= height / 2 * f
        elif yAlign == "top":
            y -= height * f
        pt = (x, y)
    context = NSGraphicsContext.currentContext()
    context.saveGraphicsState()
    transform = NSAffineTransform.transform()
    transform.translateXBy_yBy_(pt[0], pt[1])
    if flipped:
        s = -scale
    else:
        s = scale
    transform.scaleXBy_yBy_(scale, s)
    transform.concat()
    text.drawAtPoint_((0, 0))
    context.restoreGraphicsState()
Exemple #6
0
    def _drawUnspecified(self, position, kind, size, vector=(-1, 1)):
        if vector is None:
            vector = (-1, 1)
        angle = atan2(vector[1], vector[0])
        circle_size = size * 1.3
        x, y = position
        NSColor.colorWithCalibratedRed_green_blue_alpha_(0.9, 0.1, 0.0,
                                                         0.85).set()

        t = NSAffineTransform.transform()
        t.translateXBy_yBy_(x, y)
        t.rotateByRadians_(angle)

        myPath = NSBezierPath.alloc().init()
        myPath.setLineWidth_(0)
        myPath.appendBezierPathWithOvalInRect_(
            NSMakeRect(x - 0.5 * circle_size, y - 0.5 * circle_size,
                       circle_size, circle_size))
        myPath.stroke()
        if self.show_labels or distance_between_points(self.mouse_position,
                                                       position) < size:
            self._drawTextLabel(
                transform=t,
                text=kind,
                size=size,
                angle=angle,
            )
Exemple #7
0
 def __init__(self, width, height):
     GPixmap.__init__(self)
     # ns_size = NSSize(width, height)
     # ns_image = NSImage.alloc().initWithSize_(ns_size)
     ns_image = NSImage.alloc().init()
     ns_image.setCacheMode_(NSImageCacheNever)
     row_bytes = 4 * width
     ns_bitmap = NSBitmapImageRep.alloc().initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bytesPerRow_bitsPerPixel_(
         None, width, height, 8, 4, True, False, NSCalibratedRGBColorSpace, row_bytes, 32
     )
     ns_image.addRepresentation_(ns_bitmap)
     ns_bitmap_context = NSGraphicsContext.graphicsContextWithBitmapImageRep_(ns_bitmap)
     ns_graphics_context = FlippedNSGraphicsContext.alloc().initWithBase_(ns_bitmap_context)
     ns_tr = NSAffineTransform.transform()
     ns_tr.translateXBy_yBy_(0.0, height)
     ns_tr.scaleXBy_yBy_(1.0, -1.0)
     #  Using __class__ to get +saveGraphicsState instead of -saveGraphicsState
     NSGraphicsContext.__class__.saveGraphicsState()
     try:
         NSGraphicsContext.setCurrentContext_(ns_graphics_context)
         ns_tr.concat()
     finally:
         NSGraphicsContext.__class__.restoreGraphicsState()
     self._init_with_ns_image(ns_image, flipped=True)  # False)
     self._ns_bitmap_image_rep = ns_bitmap
     self._ns_graphics_context = ns_graphics_context
Exemple #8
0
    def drawFriends(self, layer):
        try:
            friends = self.currentWindow.glyphList.get()
        except:
            friends = None

        c = 0

        if friends:
            for friend in friends:
                if friend.get("Visibility", 0):
                    g = friend["layer"]
                    if g.completeBezierPath is not None:
                        bP = g.completeBezierPath.copy()
                        t = NSAffineTransform.transform()

                        if self.alignment == 1:
                            translateX = layer.width / 2.0 - g.width / 2.0 + friend[
                                "Position"]
                        elif self.alignment == 2:
                            translateX = layer.width - g.width + friend[
                                "Position"]
                        else:
                            translateX = int(friend["Position"])

                        t.translateXBy_yBy_(translateX, 0.0)
                        tM = t.transformStruct()
                        bP.applyTransform_(tM)

                        NSColor.colorWithDeviceRed_green_blue_alpha_(
                            1.0, 0.73, c, 0.35).set()
                        bP.fill()

                        c = (c + 0.27) % 1.0
    def background(self, layer):
        try:
            NSColor.colorWithDeviceRed_green_blue_alpha_(0.2, 0.2, 0.2,
                                                         0.5).set()
            for a in layer.anchors:
                if a not in layer.selection:
                    continue
                for (l2,
                     otherAnchor) in self.matchingGlyphsAndAnchorsForAnchor(
                         layer, a):
                    if l2.parent.name in self.skipMark:
                        continue
                    anchorAnchorPos = NSPoint(
                        a.position.x - otherAnchor.position.x,
                        a.position.y - otherAnchor.position.y,
                    )
                    bez = NSBezierPath.bezierPath()
                    bez.appendBezierPath_(l2.bezierPath)

                    t = NSAffineTransform.transform()
                    t.translateXBy_yBy_(anchorAnchorPos.x, anchorAnchorPos.y)
                    bez.transformUsingAffineTransform_(t)
                    bez.fill()

        except:
            print("Oops!", sys.exc_info()[0], "occured.")
            traceback.print_exc(file=sys.stdout)
def MenuImageRepresentationFactory(glyph):
    font = glyph.font
    cellHeight = 60.0
    cellWidth = 60.0
    imageSize = (cellWidth, cellHeight)
    availableHeight = cellHeight * .6
    yBuffer = int((cellHeight - availableHeight) / 2)
    upm = font.info.unitsPerEm
    descender = font.info.descender
    scale = availableHeight / upm
    glyphWidth = glyph.width * scale
    centerOffset = (cellWidth - glyphWidth) * 0.5
    path = glyph.getRepresentation("defconAppKit.NSBezierPath")
    image = NSImage.alloc().initWithSize_(imageSize)
    image.lockFocus()
    bounds = ((0, 0), imageSize)
    MenuImageBackgroundColor.set()
    NSRectFillUsingOperation(bounds, NSCompositeSourceOver)
    transform = NSAffineTransform.transform()
    transform.translateXBy_yBy_(centerOffset, yBuffer)
    transform.scaleXBy_yBy_(scale, scale)
    transform.translateXBy_yBy_(0, abs(descender))
    transform.concat()
    MenuImageGlyphColor.set()
    path.fill()
    image.unlockFocus()
    return image
Exemple #11
0
	def __init__(self, width, height):
		GPixmap.__init__(self)
		#ns_size = NSSize(width, height)
		#ns_image = NSImage.alloc().initWithSize_(ns_size)
		ns_image = NSImage.alloc().init()
		ns_image.setCacheMode_(NSImageCacheNever)
		row_bytes = 4 * width
		ns_bitmap = NSBitmapImageRep.alloc().\
			initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bytesPerRow_bitsPerPixel_(
			None, width, height, 8, 4, True, False, NSCalibratedRGBColorSpace, row_bytes, 32)
		ns_image.addRepresentation_(ns_bitmap)
		ns_bitmap_context = NSGraphicsContext.graphicsContextWithBitmapImageRep_(ns_bitmap)
		ns_graphics_context = FlippedNSGraphicsContext.alloc().initWithBase_(ns_bitmap_context)
		ns_tr = NSAffineTransform.transform()
		ns_tr.translateXBy_yBy_(0.0, height)
		ns_tr.scaleXBy_yBy_(1.0, -1.0)
		#  Using __class__ to get +saveGraphicsState instead of -saveGraphicsState
		NSGraphicsContext.__class__.saveGraphicsState()
		try:
			NSGraphicsContext.setCurrentContext_(ns_graphics_context)
			ns_tr.concat()
		finally:
			NSGraphicsContext.__class__.restoreGraphicsState()
		self._init_with_ns_image(ns_image, flipped = True) #False)
		self._ns_bitmap_image_rep = ns_bitmap
		self._ns_graphics_context = ns_graphics_context
Exemple #12
0
def getAffineTransform(angle, centerX, centerY):
    u"""Rotates at angle around point by shifting object to origin first, then
    putting it back after."""
    at = NSAffineTransform.transform()
    at.translateXBy_yBy_(centerX, centerY)
    at.rotateByDegrees_(angle)
    at.translateXBy_yBy_(-centerX, -centerY)
    return at
Exemple #13
0
def getAffineTransform(angle, point):
    u"""Rotates at angle around point."""
    x = point[0]
    y = point[1]
    at = NSAffineTransform.transform()
    at.translateXBy_yBy_(x, y)
    at.rotateByDegrees_(angle)
    at.translateXBy_yBy_(-x, -y)
    return at
Exemple #14
0
    def drawRect_(self, rect):
        try:
            NSColor.whiteColor().set()
            NSRectFill(self.bounds())
            NSColor.blackColor().setFill()
            NSColor.blueColor().setStroke()
            p = NSBezierPath.bezierPath()
            xcursor = 0
            string = self.string
            master = self.master
            for s in range(0, len(string)):
                thisPath = NSBezierPath.bezierPath()
                gsglyph = master.font.glyphs[string[s]]
                layer = gsglyph.layers[master.id]
                thisPath.appendBezierPath_(layer.completeBezierPath)
                # print("X cursor was",xcursor)
                xcursor = xcursor - layer.bounds.origin.x
                # print("Moving backwards", layer.bounds.origin.x)
                t = NSAffineTransform.transform()
                t.translateXBy_yBy_(xcursor, -master.descender)
                thisPath.transformUsingAffineTransform_(t)
                # print("Drawing at",xcursor)
                # print(thisPath)
                xcursor = xcursor + layer.bounds.origin.x
                xcursor = xcursor + layer.bounds.size.width
                # print("Adding width", layer.bounds.size.width)
                if s < len(string) - 1:
                    xcursor = xcursor + self.distances[(string[s],
                                                        string[s + 1])]
                p.appendBezierPath_(thisPath)

            t = NSAffineTransform.transform()
            if xcursor > 0:
                vscale = self.bounds().size.height / (master.ascender -
                                                      master.descender)
                hscale = self.bounds().size.width / xcursor
                t.scaleBy_(min(hscale, vscale))
                p.transformUsingAffineTransform_(t)
            p.fill()
        except:
            print("Oops!", sys.exc_info()[0], "occured.")
            traceback.print_exc(file=sys.stdout)
Exemple #15
0
def drawGlyphImage(glyph, scale, rect, backgroundColor=None):
    if glyph.image.fileName is None:
        return
    context = NSGraphicsContext.currentContext()
    context.saveGraphicsState()
    aT = NSAffineTransform.transform()
    aT.setTransformStruct_(glyph.image.transformation)
    aT.concat()
    image = glyph.image.getRepresentation("defconAppKit.NSImage")
    image.drawAtPoint_fromRect_operation_fraction_(
        (0, 0), ((0, 0), image.size()), NSCompositeSourceOver, 1.0)
    context.restoreGraphicsState()
Exemple #16
0
def drawGlyphImage(glyph, scale, rect, backgroundColor=None):
    if glyph.image.fileName is None:
        return
    context = NSGraphicsContext.currentContext()
    context.saveGraphicsState()
    aT = NSAffineTransform.transform()
    aT.setTransformStruct_(glyph.image.transformation)
    aT.concat()
    image = glyph.image.getRepresentation("defconAppKit.NSImage")
    image.drawAtPoint_fromRect_operation_fraction_(
        (0, 0), ((0, 0), image.size()), NSCompositeSourceOver, 1.0
    )
    context.restoreGraphicsState()
Exemple #17
0
def slantLayers(layers, angle):
    Font.disableUpdateInterface()
    xHeight = layers[0].associatedFontMaster().xHeight
    transform = NSAffineTransform.new()
    slant = math.tan(skewAngle * math.pi / 180.0)
    transform.shearXBy_atCenter_(slant, -xHeight / 2.0)

    for layer in selectedLayers:
        for path in layer.paths:
            for node in path.nodes:
                node.position = transform.transformPoint_(node.position)
        for anchor in layer.anchors:
            anchor.position = transform.transformPoint_(anchor.position)

    Font.enableUpdateInterface()
Exemple #18
0
def drawCoords(coords, centerX, centerY, rotate=45):
    path = BezierPath()
    at = NSAffineTransform.transform()
    at.translateXBy_yBy_(centerX, centerY)
    at.rotateByDegrees_(rotate)
    at.translateXBy_yBy_(-centerX, -centerY)

    p0 = coords[0]
    path.moveTo((p0[0], p0[1]))
    for coord in coords[1:]:
        path.lineTo((coord[0], coord[1]))

    nsPath = path.getNSBezierPath()
    nsPath = at.transformBezierPath_(nsPath)
    path.setNSBezierPath(nsPath)
    drawPath(path)
Exemple #19
0
def pathCountInKernPair( firstGlyphName, secondGlyphName, thisFont, thisFontMasterID, minDistance ):
	#ligatureName = "%s_%s" % ( nameUntilFirstPeriod(firstGlyphName), nameUntilFirstPeriod(secondGlyphName) )
	#newGlyph = thisFont.newGlyphWithName_changeName_( "_deleteMe", False )

	ligatureLayer = thisFont.glyphs[secondGlyphName].layers[thisFontMasterID].copyDecomposedLayer()
	addedLayer = thisFont.glyphs[firstGlyphName].layers[thisFontMasterID].copyDecomposedLayer()
	
	# position of right component:
	kerning = effectiveKerning( firstGlyphName, secondGlyphName, thisFont, thisFontMasterID )
	rightShift = NSAffineTransform.transform()
	rightShift.translateXBy_yBy_( addedLayer.width + kerning - minDistance, 0.0 )
	ligatureLayer.transform_checkForSelection_( rightShift, False )
	
	for addedPath in addedLayer.paths:
		ligatureLayer.addPath_( addedPath.copy() )
	
	return pathCountOnLayer( ligatureLayer )
Exemple #20
0
    def _drawArrow(self, position, kind, size, vector=(-1, 1), level="e"):
        if vector is None:
            vector = (-1, 1)
        angle = atan2(vector[0], -vector[1])
        size *= 2
        x, y = position
        head_ratio = 0.7
        w = size * 0.5
        tail_width = 0.3

        chin = 0.5 * (w - w * tail_width)  # part under the head

        if level == "e":
            arrow_color = error_color
        else:
            arrow_color = warning_color
        NSColor.colorWithCalibratedRed_green_blue_alpha_(*arrow_color).set()
        t = NSAffineTransform.transform()
        t.translateXBy_yBy_(x, y)
        t.rotateByRadians_(angle)
        myPath = NSBezierPath.alloc().init()

        myPath.moveToPoint_((0, 0))
        myPath.relativeLineToPoint_((-size * head_ratio, w * 0.5))
        myPath.relativeLineToPoint_((0, -chin))
        myPath.relativeLineToPoint_((-size * (1 - head_ratio), 0))
        myPath.relativeLineToPoint_((0, -w * tail_width))
        myPath.relativeLineToPoint_((size * (1 - head_ratio), 0))
        myPath.relativeLineToPoint_((0, -chin))
        myPath.closePath()
        myPath.transformUsingAffineTransform_(t)
        myPath.fill()

        percent = 1
        if not self.show_labels:
            percent = (
                -distance_between_points(self.mouse_position, position) /
                size * 2 + 2)
        if self.show_labels or percent > 0.2:
            self._drawTextLabel(
                transform=t,
                text=kind,
                size=size,
                vector=vector,
                percent=percent,
            )
Exemple #21
0
    def _drawUnspecified(self,
                         position,
                         kind,
                         size,
                         vector=(-1, 1),
                         level="e"):
        if vector is None:
            vector = (-1, 1)
        angle = atan2(vector[1], vector[0])
        circle_size = size * 1.3
        x, y = position
        if level == "e":
            arrow_color = error_color
        else:
            arrow_color = warning_color
        NSColor.colorWithCalibratedRed_green_blue_alpha_(*arrow_color).set()

        t = NSAffineTransform.transform()
        t.translateXBy_yBy_(x, y)
        t.rotateByRadians_(angle)

        myPath = NSBezierPath.alloc().init()
        myPath.setLineWidth_(0)
        myPath.appendBezierPathWithOvalInRect_(
            NSMakeRect(
                x - 0.5 * circle_size,
                y - 0.5 * circle_size,
                circle_size,
                circle_size,
            ))
        myPath.stroke()
        percent = (-distance_between_points(self.mouse_position, position) /
                   size * 2 + 2)
        if self.show_labels or percent > 0.2:
            self._drawTextLabel(
                transform=t,
                text=kind,
                size=size,
                vector=vector,
                percent=percent,
            )
    def TransformImagesMain(self, sender):
        try:
            Font = Glyphs.font
            selectedLayers = Font.selectedLayers
            if sender == self.w.backButton:
                factor = -1.0
            elif sender == self.w.runButton:
                factor = 1.0

            for thisLayer in selectedLayers:
                thisImage = thisLayer.backgroundImage
                if thisImage:
                    moveXpreScaled, moveYpreScaled, scaleXfix, scaleYfix = self.w.move_X.get(
                    ), self.w.move_Y.get(), self.w.scale_X.get(
                    ), self.w.scale_Y.get()
                    if moveXpreScaled == "": moveXpreScaled = 0
                    if moveYpreScaled == "": moveYpreScaled = 0
                    if scaleXfix == "": scaleXfix = 0
                    if scaleYfix == "": scaleYfix = 0
                    moveX, moveY = float(moveXpreScaled) * factor, float(
                        moveYpreScaled) * factor
                    scaleX, scaleY = getScale(scaleXfix, factor), getScale(
                        scaleYfix, factor)

                    ScaleAndMoveTransform = NSAffineTransform.transform()
                    ScaleAndMoveTransform.setTransformStruct_(
                        thisImage.transformStruct())
                    ScaleAndMoveTransform.scaleXBy_yBy_(scaleX, scaleY)
                    ScaleAndMoveTransform.translateXBy_yBy_(moveX, moveY)
                    thisImage.setTransformStruct_(
                        ScaleAndMoveTransform.transformStruct())

            if not self.SavePreferences(self):
                print("Note: could not write preferences.")

            # self.w.close()
        except Exception as e:
            raise e
Exemple #23
0
    def _drawArrow(self, position, kind, size, vector=(-1, 1)):
        if vector is None:
            vector = (-1, 1)
        angle = atan2(vector[0], -vector[1])
        size *= 2
        x, y = position
        head_ratio = 0.7
        w = size * 0.5
        tail_width = 0.3

        chin = 0.5 * (w - w * tail_width)  # part under the head

        NSColor.colorWithCalibratedRed_green_blue_alpha_(0.9, 0.1, 0.0,
                                                         0.85).set()
        t = NSAffineTransform.transform()
        t.translateXBy_yBy_(x, y)
        t.rotateByRadians_(angle)
        myPath = NSBezierPath.alloc().init()

        myPath.moveToPoint_((0, 0))
        myPath.relativeLineToPoint_((-size * head_ratio, w * 0.5))
        myPath.relativeLineToPoint_((0, -chin))
        myPath.relativeLineToPoint_((-size * (1 - head_ratio), 0))
        myPath.relativeLineToPoint_((0, -w * tail_width))
        myPath.relativeLineToPoint_((size * (1 - head_ratio), 0))
        myPath.relativeLineToPoint_((0, -chin))
        myPath.closePath()
        myPath.transformUsingAffineTransform_(t)
        myPath.fill()

        if self.show_labels or distance_between_points(self.mouse_position,
                                                       position) < size:
            self._drawTextLabel(
                transform=t,
                text=kind,
                size=size,
                vector=vector,
            )
Exemple #24
0
def drawTextAtPoint(text,
                    pt,
                    scale,
                    attributes={},
                    xAlign="left",
                    yAlign="bottom",
                    flipped=False):
    text = NSAttributedString.alloc().initWithString_attributes_(
        text, attributes)
    if xAlign != "left" or yAlign != "bottom":
        width, height = text.size()
        width *= scale
        height *= scale
        x, y = pt
        f = 1
        if flipped:
            f = -1
        if xAlign == "center":
            x -= width / 2
        elif xAlign == "right":
            x -= width
        if yAlign == "center":
            y -= height / 2 * f
        elif yAlign == "top":
            y -= height * f
        pt = (x, y)
    context = NSGraphicsContext.currentContext()
    context.saveGraphicsState()
    transform = NSAffineTransform.transform()
    transform.translateXBy_yBy_(pt[0], pt[1])
    if flipped:
        s = -scale
    else:
        s = scale
    transform.scaleXBy_yBy_(scale, s)
    transform.concat()
    text.drawAtPoint_((0, 0))
    context.restoreGraphicsState()
Exemple #25
0
	def _drawUnspecified(self, position, kind, size, vector = (-1, 1)):
		if vector is None:
			vector = (-1, 1)
		angle = atan2(vector[1], vector[0])
		circle_size = size * 1.3
		x, y = position
		NSColor.colorWithCalibratedRed_green_blue_alpha_( 0.9, 0.1, 0.0, 0.85 ).set()
		
		t = NSAffineTransform.transform()
		t.translateXBy_yBy_(x, y)
		t.rotateByRadians_(angle)

		myPath = NSBezierPath.alloc().init()
		myPath.setLineWidth_( 0 )
		myPath.appendBezierPathWithOvalInRect_( NSMakeRect( x - 0.5 * circle_size, y - 0.5 * circle_size, circle_size, circle_size ) )
		myPath.stroke()
		if self.show_labels or distance_between_points(self.mouse_position, position) < size:
			self._drawTextLabel(
				transform = t,
				text = kind,
				size = size,
				angle = angle,
			)
    def as_matrix(self, normalize=False, binarize=False):
        """Renders the glyph as a matrix. By default, the matrix values are integer pixel greyscale values
    in the range 0 to 255, but they can be normalized or turned into binary values with the
    appropriate keyword arguments. The matrix is returned as a `GlyphRendering` object which
    can be further manipulated."""
        box_height = int(self.font.full_height_px)
        box_width = int(self.ink_width)

        b = NSBitmapImageRep.alloc(
        ).initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bytesPerRow_bitsPerPixel_(
            None, box_width, box_height, 8, 1, False, False,
            NSCalibratedWhiteColorSpace, 0, 0)
        ctx = NSGraphicsContext.graphicsContextWithBitmapImageRep_(b)
        assert (ctx)
        NSGraphicsContext.setCurrentContext_(ctx)

        NSColor.whiteColor().setFill()
        p2 = NSBezierPath.bezierPath()
        p2.appendBezierPath_(self.layer.completeBezierPath)
        t = NSAffineTransform.transform()
        t.translateXBy_yBy_(-self.lsb,
                            -self.font.descender * self.font.scale_factor)
        t.scaleBy_(self.font.scale_factor)
        p2.transformUsingAffineTransform_(t)
        p2.fill()

        png = b.representationUsingType_properties_(NSPNGFileType, None)
        png.writeToFile_atomically_("/tmp/foo.png", False)
        Z = np.array(b.bitmapData())
        box_width_up = Z.shape[0] / box_height
        Z = Z.reshape((box_height, box_width_up))[0:box_height, 0:box_width]

        if normalize or binarize:
            Z = Z / 255.0
        if binarize:
            Z = Z.astype(int)
        return GlyphRendering.init_from_numpy(self, Z)
Exemple #27
0
	def _drawArrow(self, position, kind, size, vector = (-1, 1)):
		if vector is None:
			vector = (-1, 1)
		angle = atan2(vector[0], -vector[1])
		size *= 2
		x, y = position
		head_ratio = 0.7
		w = size * 0.5
		tail_width = 0.3
		
		chin = 0.5 * (w - w * tail_width) # part under the head

		NSColor.colorWithCalibratedRed_green_blue_alpha_( 0.9, 0.1, 0.0, 0.85 ).set()
		t = NSAffineTransform.transform()
		t.translateXBy_yBy_(x, y)
		t.rotateByRadians_(angle)
		myPath = NSBezierPath.alloc().init()

		myPath.moveToPoint_(         (0, 0)                                       )
		myPath.relativeLineToPoint_( (-size * head_ratio,        w * 0.5)         )
		myPath.relativeLineToPoint_( (0,                         -chin)           )
		myPath.relativeLineToPoint_( (-size * (1 - head_ratio),  0)               )
		myPath.relativeLineToPoint_( (0,                         -w * tail_width) )
		myPath.relativeLineToPoint_( (size * (1 - head_ratio),   0)               )
		myPath.relativeLineToPoint_( (0,                         -chin)           )
		myPath.closePath()
		myPath.transformUsingAffineTransform_(t)
		myPath.fill()
		
		if self.show_labels or distance_between_points(self.mouse_position, position) < size:
			self._drawTextLabel(
				transform = t,
				text = kind,
				size = size,
				vector = vector,
			)
Exemple #28
0
def vector_rotateByDegrees_(vec, deg):
    matrix = NSAffineTransform.transform()
    matrix.rotateByDegrees_(deg)
    return matrix.transformPoint_(vec)
Exemple #29
0
def vector_setMagnitude_(vec, mag):
    matrix = NSAffineTransform.transform()
    matrix.scaleBy_(1.0 / vectorMagnitude_(vec)) # make unit length
    matrix.scaleBy_(mag)
    return matrix.transformPoint_(vec)
Exemple #30
0
 def translate(self, dx, dy):
     matrix = NSAffineTransform.transform()
     matrix.translateXBy_yBy_(dx, dy)
     self._ns_path.transformUsingAffineTransform_(matrix)
     self.transformstack[-1].append(["translate", dx, dy])
Exemple #31
0
 def drawRectRightToLeft_(self, rect):
     self._alternateRects = {}
     # draw the background
     bounds = self.bounds()
     self._backgroundColor.set()
     NSRectFill(bounds)
     # create some reusable values
     scale = self._scale
     descender = self._descender
     upm = self._upm
     scrollWidth = bounds.size[0]
     # offset for the buffer
     ctx = NSGraphicsContext.currentContext()
     ctx.saveGraphicsState()
     aT = NSAffineTransform.transform()
     aT.translateXBy_yBy_(scrollWidth - self._bufferLeft, self._bufferTop)
     aT.concat()
     # offset for the descender
     aT = NSAffineTransform.transform()
     aT.scaleBy_(scale)
     aT.translateXBy_yBy_(0, descender)
     aT.concat()
     # flip
     flipTransform = NSAffineTransform.transform()
     flipTransform.translateXBy_yBy_(0, upm)
     flipTransform.scaleXBy_yBy_(1.0, -1.0)
     flipTransform.concat()
     # set the glyph color
     self._glyphColor.set()
     # draw the records
     left = scrollWidth - self._bufferLeft
     bottom = self._bufferTop
     height = upm * scale
     previousXA = 0
     for recordIndex, glyphRecord in enumerate(reversed(
             self._glyphRecords)):
         glyph = glyphRecord.glyph
         w = glyphRecord.advanceWidth
         h = glyphRecord.advanceHeight
         xP = glyphRecord.xPlacement
         yP = glyphRecord.yPlacement
         xA = glyphRecord.xAdvance
         yA = glyphRecord.yAdvance
         # handle offsets from the record
         bottom += yP * scale
         glyphHeight = height + ((h + yA) * scale)
         glyphLeft = left + ((-w + xP - xA) * scale)
         glyphWidth = (-w - xA) * scale
         # store the glyph rect for the alternate menu
         rect = ((glyphLeft, bottom), (glyphWidth, glyphHeight))
         self._alternateRects[rect] = recordIndex
         self._currentZeroZeroPoint = NSPoint(
             glyphLeft, bottom + height + (descender * scale))
         # handle the placement
         aT = NSAffineTransform.transform()
         if xP:
             xP += previousXA
         aT.translateXBy_yBy_(-w - xA + xP, yP)
         aT.concat()
         # draw the glyph
         rect = ((-w + xA - xP, descender - yP), (w, upm))
         self.drawGlyph(glyph, rect, alternate=bool(glyphRecord.alternates))
         # shift for the next glyph
         aT = NSAffineTransform.transform()
         aT.translateXBy_yBy_(-xP, h + yA - yP)
         aT.concat()
         left += (-w - xP - xA) * scale
         previousXA = xA
     ctx.restoreGraphicsState()
Exemple #32
0
 def move(self):
     dx,dy = self.vector
     matrix = NSAffineTransform.transform()
     matrix.translateXBy_yBy_(dx,dy)
     self.position = matrix.transformPoint_(self.position)
     self.transformUsingAffineTransform_(matrix)
Exemple #33
0
 def scale(self, sx, sy):
     matrix = NSAffineTransform.transform()
     matrix.scaleXBy_yBy_(sx, sy)
     self._ns_path.transformUsingAffineTransform_(matrix)
     self.transformstack[-1].append(["scale", sx, sy])
Exemple #34
0
    def drawRect_(self, rect):
        needCalc = False
        if self.superview(
        ) and self._fitToFrame != self.superview().visibleRect().size:
            needCalc = True
        if self.inLiveResize():
            needCalc = True
        if needCalc:
            self.recalculateFrame()

        self.drawBackground()
        if self._glyph is None:
            return

        # apply the overall scale
        transform = NSAffineTransform.transform()
        transform.scaleBy_(self._scale)
        transform.concat()

        # move into position
        visibleWidth = self.bounds().size[0]
        width = self._glyph.width * self._scale
        diff = visibleWidth - width
        xOffset = round((diff / 2) * self._inverseScale)

        yOffset = self._verticalCenterYBuffer * self._inverseScale
        yOffset -= self._descender

        # @@@
        yOffset -= 270
        xOffset += 130

        transform = NSAffineTransform.transform()
        transform.translateXBy_yBy_(xOffset, yOffset)
        transform.concat()

        # store the current drawing rect
        w, h = self.bounds().size
        w *= self._inverseScale
        h *= self._inverseScale
        justInCaseBuffer = 1 * self._inverseScale
        xOffset += justInCaseBuffer
        yOffset += justInCaseBuffer
        w += justInCaseBuffer * 2
        h += justInCaseBuffer * 2
        self._drawingRect = ((-xOffset, -yOffset), (w, h))

        # gather the layers
        layerSet = self._glyph.layerSet
        if layerSet is None:
            layers = [(self._glyph, None)]
        else:
            glyphName = self._glyph.name
            layers = []
            for layerName in reversed(layerSet.layerOrder):
                layer = layerSet[layerName]
                if glyphName not in layer:
                    continue
                glyph = layer[glyphName]
                if glyph == self._glyph:
                    layerName = None
                layers.append((glyph, layerName))

        for glyph, layerName in layers:
            # draw the image
            if self.getDrawingAttribute_layerName_("showGlyphImage",
                                                   layerName):
                self.drawImage(glyph, layerName)
            # draw the blues
            if layerName is None and self.getDrawingAttribute_layerName_(
                    "showFontPostscriptBlues", None):
                self.drawBlues(glyph, layerName)
            if layerName is None and self.getDrawingAttribute_layerName_(
                    "showFontPostscriptFamilyBlues", None):
                self.drawFamilyBlues(glyph, layerName)
            # draw the margins
            if self.getDrawingAttribute_layerName_("showGlyphMargins",
                                                   layerName):
                self.drawMargins(glyph, layerName)
            # draw the vertical metrics
            if layerName is None and self.getDrawingAttribute_layerName_(
                    "showFontVerticalMetrics", None):
                self.drawVerticalMetrics(glyph, layerName)
            # draw the glyph
            if self.getDrawingAttribute_layerName_(
                    "showGlyphFill",
                    layerName) or self.getDrawingAttribute_layerName_(
                        "showGlyphStroke", layerName):
                self.drawFillAndStroke(glyph, layerName)
            if self.getDrawingAttribute_layerName_(
                    "showGlyphOnCurvePoints",
                    layerName) or self.getDrawingAttribute_layerName_(
                        "showGlyphOffCurvePoints", layerName):
                self.drawPoints(glyph, layerName)
            if self.getDrawingAttribute_layerName_("showGlyphAnchors",
                                                   layerName):
                self.drawAnchors(glyph, layerName)
def GlyphCellDetailFactory(glyph):
    font = glyph.font

    imageWidth = 200
    imageHeight = 280

    scale = 120 / font.info.unitsPerEm
    glyphLeftOffset = (imageWidth - (glyph.width * scale)) / 2

    basePath = roundedRectBezierPath(
        ((.5, .5), (imageWidth - 1, imageHeight - 1)), 7)
    basePath.setLineWidth_(1.0)

    glyphPath = glyph.getRepresentation("defconAppKit.NSBezierPath")

    line1Path = NSBezierPath.bezierPath()
    line1Path.moveToPoint_((1, 120.5))
    line1Path.lineToPoint_((imageWidth - 1, 120.5))
    line1Path.setLineWidth_(1.0)

    line2Path = NSBezierPath.bezierPath()
    line2Path.moveToPoint_((1, 121.5))
    line2Path.lineToPoint_((imageWidth - 1, 121.5))
    line2Path.setLineWidth_(1.0)

    lineColor = NSColor.colorWithCalibratedWhite_alpha_(.5, 1.0)

    paragraph = NSMutableParagraphStyle.alloc().init()
    paragraph.setAlignment_(NSRightTextAlignment)
    paragraph.setLineBreakMode_(NSLineBreakByCharWrapping)
    leftAttributes = {
        NSFontAttributeName: NSFont.systemFontOfSize_(12.0),
        NSForegroundColorAttributeName: NSColor.whiteColor(),
        NSParagraphStyleAttributeName: paragraph
    }

    paragraph = NSMutableParagraphStyle.alloc().init()
    paragraph.setAlignment_(NSLeftTextAlignment)
    paragraph.setLineBreakMode_(NSLineBreakByTruncatingMiddle)
    rightAttributes = {
        NSFontAttributeName: NSFont.systemFontOfSize_(12.0),
        NSForegroundColorAttributeName: NSColor.whiteColor(),
        NSParagraphStyleAttributeName: paragraph
    }

    nameTitle = NSAttributedString.alloc().initWithString_attributes_(
        "Name", leftAttributes)
    nameText = NSAttributedString.alloc().initWithString_attributes_(
        glyph.name, rightAttributes)

    uniTitle = NSAttributedString.alloc().initWithString_attributes_(
        "Unicode", leftAttributes)
    uni = glyph.unicode
    if uni is None:
        uni = ""
    else:
        uni = hex(uni)[2:].upper()
        if len(uni) < 4:
            uni = uni.zfill(4)
    uniText = NSAttributedString.alloc().initWithString_attributes_(
        str(uni), rightAttributes)

    widthTitle = NSAttributedString.alloc().initWithString_attributes_(
        "Width", leftAttributes)
    width = glyph.width
    if width is None:
        width = 0
    width = round(width, 3)
    if width == int(width):
        width = int(width)
    widthText = NSAttributedString.alloc().initWithString_attributes_(
        str(width), rightAttributes)

    leftTitle = NSAttributedString.alloc().initWithString_attributes_(
        "Left Margin", leftAttributes)
    leftMargin = glyph.leftMargin
    if leftMargin is None:
        leftMargin = 0
    leftMargin = round(leftMargin, 3)
    if leftMargin == int(leftMargin):
        leftMargin = int(leftMargin)
    leftText = NSAttributedString.alloc().initWithString_attributes_(
        str(leftMargin), rightAttributes)

    rightTitle = NSAttributedString.alloc().initWithString_attributes_(
        "Right Margin", leftAttributes)
    rightMargin = glyph.rightMargin
    if rightMargin is None:
        rightMargin = 0
    rightMargin = round(rightMargin, 3)
    if rightMargin == int(rightMargin):
        rightMargin = int(rightMargin)
    rightText = NSAttributedString.alloc().initWithString_attributes_(
        str(rightMargin), rightAttributes)

    image = NSImage.alloc().initWithSize_((imageWidth, imageHeight))
    image.setFlipped_(True)
    image.lockFocus()

    NSColor.colorWithCalibratedWhite_alpha_(0, .65).set()
    basePath.fill()
    lineColor.set()
    basePath.stroke()

    context = NSGraphicsContext.currentContext()
    context.saveGraphicsState()
    transform = NSAffineTransform.transform()
    transform.translateXBy_yBy_(glyphLeftOffset, 145)
    transform.scaleBy_(scale)
    transform.translateXBy_yBy_(0, -font.info.descender)
    transform.concat()

    NSColor.whiteColor().set()
    glyphPath.fill()
    context.restoreGraphicsState()

    lineColor.set()
    line1Path.stroke()
    NSColor.colorWithCalibratedWhite_alpha_(0, .5).set()
    line2Path.stroke()

    transform = NSAffineTransform.transform()
    transform.translateXBy_yBy_(0, 110)
    transform.scaleXBy_yBy_(1.0, -1.0)
    transform.concat()

    nameTitle.drawInRect_(((0, 0), (90, 17)))
    nameText.drawInRect_(((95, 0), (85, 17)))

    uniTitle.drawInRect_(((0, 20), (90, 17)))
    uniText.drawInRect_(((95, 20), (85, 17)))

    widthTitle.drawInRect_(((0, 40), (90, 17)))
    widthText.drawInRect_(((95, 40), (85, 17)))

    leftTitle.drawInRect_(((0, 60), (90, 17)))
    leftText.drawInRect_(((95, 60), (85, 17)))

    rightTitle.drawInRect_(((0, 80), (90, 17)))
    rightText.drawInRect_(((95, 80), (85, 17)))

    image.unlockFocus()
    return image
Exemple #36
0
 def scale(self, sx, sy):
     matrix = NSAffineTransform.transform()
     matrix.scaleXBy_yBy_(sx, sy)
     self._ns_path.transformUsingAffineTransform_(matrix)
     self.transformstack[-1].append(["scale",sx,sy])    
Exemple #37
0
 def translate(self, dx, dy):
     matrix = NSAffineTransform.transform()
     matrix.translateXBy_yBy_(dx, dy)
     self._ns_path.transformUsingAffineTransform_(matrix)    
     self.transformstack[-1].append(["translate",dx,dy])
Exemple #38
0
	def drawRect_(self, rect): ## needs to be `drawRect_` -- nothing else

		bounds = self.bounds()

		# thisUPM = self._layer.parent.parent.upm
		scaleFactor = self._scaleFactor
		thisUPM = self._upm * scaleFactor
		rectX, rectY, rectWidth, rectHeight = 0, 0, thisUPM, thisUPM
		self.rect = rect

		# self._layer.drawInFrame_(bounds)  # used in Georgs GlyphView


		try:
			layerWidth = self._layer.width * scaleFactor
			descender = self._layer.glyphMetrics()[3] * scaleFactor
			
			## this order is important! Wont work the other way around
			try: # pre Glyphs 2.3
				bezierPathOnly = self._layer.copy().bezierPath()  # Path Only
				bezierPathWithComponents = self._layer.copyDecomposedLayer().bezierPath() # Path & Components				
			except: # Glyphs 2.3
				bezierPathOnly = self._layer.copy().bezierPath  # Path Only
				bezierPathWithComponents = self._layer.copyDecomposedLayer().bezierPath  # Path & Components			

				

			scale = NSAffineTransform.transform()
			scale.translateXBy_yBy_( rectWidth/2 - (layerWidth / 2.0) + self._margin/2, -descender + self._margin/2 )
			scale.scaleBy_( scaleFactor )

			if bezierPathWithComponents:
				bezierPathWithComponents.transformUsingAffineTransform_( scale )
			if bezierPathOnly:
				bezierPathOnly.transformUsingAffineTransform_( scale )

			## DRAW COMPONENTS IN GRAY
			NSColor.darkGrayColor().set() # lightGrayColor
			bezierPathWithComponents.fill()
			
			## CHANGE COLOR FOR NON-EXPORTED GLYPHS
			thisGlyph = self._layer.parent
			if thisGlyph.export:
				NSColor.blackColor().set()

				## DRAW ONLY PATH IN BLACK
				if bezierPathOnly:
					bezierPathOnly.fill()
			else:
				NSColor.orangeColor().set()
				bezierPathWithComponents.fill()
			
			# print self.bounds()

			## AUTO-WIDTH LABEL
			if self._layer.hasAlignedWidth():
				paragraphStyle = NSMutableParagraphStyle.alloc().init()
				paragraphStyle.setAlignment_(2) ## 0=L, 1=R, 2=C, 3=justified
				attributes = {}
				attributes[NSFontAttributeName] = NSFont.systemFontOfSize_(10)
				attributes[NSForegroundColorAttributeName] = NSColor.lightGrayColor()
				attributes[NSParagraphStyleAttributeName] = paragraphStyle
				String = NSAttributedString.alloc().initWithString_attributes_("Auto-Width", attributes)
				# String.drawAtPoint_((rectWidth, 0))
				NSColor.redColor().set()
				# NSRectFill(((0, 0), (self.rect.size.width, 15)))
				String.drawInRect_(((0, 0), (self.rect.size.width, 15)))
		except:
			# pass
			print traceback.format_exc()
def GlyphCellDetailFactory(glyph):
    font = glyph.font

    imageWidth = 200
    imageHeight = 280

    scale = 120 / font.info.unitsPerEm
    glyphLeftOffset = (imageWidth - (glyph.width * scale)) / 2

    basePath = roundedRectBezierPath(((.5, .5), (imageWidth - 1, imageHeight - 1)), 7)
    basePath.setLineWidth_(1.0)

    glyphPath = glyph.getRepresentation("defconAppKit.NSBezierPath")

    line1Path = NSBezierPath.bezierPath()
    line1Path.moveToPoint_((1, 120.5))
    line1Path.lineToPoint_((imageWidth - 1, 120.5))
    line1Path.setLineWidth_(1.0)

    line2Path = NSBezierPath.bezierPath()
    line2Path.moveToPoint_((1, 121.5))
    line2Path.lineToPoint_((imageWidth - 1, 121.5))
    line2Path.setLineWidth_(1.0)

    lineColor = NSColor.colorWithCalibratedWhite_alpha_(.5, 1.0)

    paragraph = NSMutableParagraphStyle.alloc().init()
    paragraph.setAlignment_(NSRightTextAlignment)
    paragraph.setLineBreakMode_(NSLineBreakByCharWrapping)
    leftAttributes = {
        NSFontAttributeName: NSFont.systemFontOfSize_(12.0),
        NSForegroundColorAttributeName: NSColor.whiteColor(),
        NSParagraphStyleAttributeName: paragraph
    }

    paragraph = NSMutableParagraphStyle.alloc().init()
    paragraph.setAlignment_(NSLeftTextAlignment)
    paragraph.setLineBreakMode_(NSLineBreakByTruncatingMiddle)
    rightAttributes = {
        NSFontAttributeName: NSFont.systemFontOfSize_(12.0),
        NSForegroundColorAttributeName: NSColor.whiteColor(),
        NSParagraphStyleAttributeName: paragraph
    }

    nameTitle = NSAttributedString.alloc().initWithString_attributes_("Name", leftAttributes)
    nameText = NSAttributedString.alloc().initWithString_attributes_(glyph.name, rightAttributes)

    uniTitle = NSAttributedString.alloc().initWithString_attributes_("Unicode", leftAttributes)
    uni = glyph.unicode
    if uni is None:
        uni = ""
    else:
        uni = hex(uni)[2:].upper()
        if len(uni) < 4:
            uni = uni.zfill(4)
    uniText = NSAttributedString.alloc().initWithString_attributes_(str(uni), rightAttributes)

    widthTitle = NSAttributedString.alloc().initWithString_attributes_("Width", leftAttributes)
    width = glyph.width
    if width is None:
        width = 0
    width = round(width, 3)
    if width == int(width):
        width = int(width)
    widthText = NSAttributedString.alloc().initWithString_attributes_(str(width), rightAttributes)

    leftTitle = NSAttributedString.alloc().initWithString_attributes_("Left Margin", leftAttributes)
    leftMargin = glyph.leftMargin
    if leftMargin is None:
        leftMargin = 0
    leftMargin = round(leftMargin, 3)
    if leftMargin == int(leftMargin):
        leftMargin = int(leftMargin)
    leftText = NSAttributedString.alloc().initWithString_attributes_(str(leftMargin), rightAttributes)

    rightTitle = NSAttributedString.alloc().initWithString_attributes_("Right Margin", leftAttributes)
    rightMargin = glyph.rightMargin
    if rightMargin is None:
        rightMargin = 0
    rightMargin = round(rightMargin, 3)
    if rightMargin == int(rightMargin):
        rightMargin = int(rightMargin)
    rightText = NSAttributedString.alloc().initWithString_attributes_(str(rightMargin), rightAttributes)

    image = NSImage.alloc().initWithSize_((imageWidth, imageHeight))
    image.setFlipped_(True)
    image.lockFocus()

    NSColor.colorWithCalibratedWhite_alpha_(0, .65).set()
    basePath.fill()
    lineColor.set()
    basePath.stroke()

    context = NSGraphicsContext.currentContext()
    context.saveGraphicsState()
    transform = NSAffineTransform.transform()
    transform.translateXBy_yBy_(glyphLeftOffset, 145)
    transform.scaleBy_(scale)
    transform.translateXBy_yBy_(0, -font.info.descender)
    transform.concat()

    NSColor.whiteColor().set()
    glyphPath.fill()
    context.restoreGraphicsState()

    lineColor.set()
    line1Path.stroke()
    NSColor.colorWithCalibratedWhite_alpha_(0, .5).set()
    line2Path.stroke()

    transform = NSAffineTransform.transform()
    transform.translateXBy_yBy_(0, 110)
    transform.scaleXBy_yBy_(1.0, -1.0)
    transform.concat()

    nameTitle.drawInRect_(((0, 0), (90, 17)))
    nameText.drawInRect_(((95, 0), (85, 17)))

    uniTitle.drawInRect_(((0, 20), (90, 17)))
    uniText.drawInRect_(((95, 20), (85, 17)))

    widthTitle.drawInRect_(((0, 40), (90, 17)))
    widthText.drawInRect_(((95, 40), (85, 17)))

    leftTitle.drawInRect_(((0, 60), (90, 17)))
    leftText.drawInRect_(((95, 60), (85, 17)))

    rightTitle.drawInRect_(((0, 80), (90, 17)))
    rightText.drawInRect_(((95, 80), (85, 17)))

    image.unlockFocus()
    return image
Exemple #40
0
def _drawArrow(position, kind, size, vector=(-1, 1), label_size=1):
        angle = atan2(vector[0], -vector[1])
        print vector, "%0.2f°" % degrees(angle)
        x, y = position
        head_ratio = 0.7
        w = size * 0.5
        tail_width = 0.3
        chin = 0.5 * (w - w * tail_width) # part under the head
        
        NSColor.colorWithCalibratedRed_green_blue_alpha_( 0.9, 0.1, 0.0, 0.85 ).set()
        t = NSAffineTransform.transform()
        t.translateXBy_yBy_(x, y)
        t.rotateByRadians_(angle)
        myPath = NSBezierPath.alloc().init()
        
        myPath.moveToPoint_(         (0, 0)                                       )
        myPath.relativeLineToPoint_( (-size * head_ratio,        w * 0.5)         )
        myPath.relativeLineToPoint_( (0,                         -chin)           )
        myPath.relativeLineToPoint_( (-size * (1 - head_ratio),  0)               )
        myPath.relativeLineToPoint_( (0,                         -w * tail_width) )
        myPath.relativeLineToPoint_( (size * (1 - head_ratio),   0)               )
        myPath.relativeLineToPoint_( (0,                         -chin)           )
        myPath.closePath()
        myPath.transformUsingAffineTransform_(t)
        myPath.fill()
        
        drawPath(myPath)
        
        myString = NSString.string().stringByAppendingString_(kind)
        attrs = {
            NSFontAttributeName:            NSFont.systemFontOfSize_(label_size),
            NSForegroundColorAttributeName: NSColor.colorWithCalibratedRed_green_blue_alpha_( 0.4, 0.4, 0.6, 0.7 ),
        }
        bbox = myString.sizeWithAttributes_(attrs)
        #print bbox
        
        p = NSPoint()
        bw = bbox.width
        bh = bbox.height
        
        #print "   ", cos(angle)
        if -0.5 * pi < angle <= 0.5 * pi:
            p.x, p.y = (
                - size - 20 - bh/2 * sin(angle) - bw/2 * cos(angle), # + bw/2.0 * cos(angle - pi)
                0
            )
        else:
            p.x, p.y = (
                - size - 20 + bh/2 * sin(angle) + bw/2 * cos(angle), # + bw/2.0 * cos(angle - pi)
                0,
            )
        p = t.transformPoint_(p)
        #print p
        
        #fontSize(label_size)
        #text(kind, (p.x - bbox.width/2, p.y - bbox.height/2))
        fill(None)
        rect(p.x - bbox.width/2, p.y - bbox.height/2, bbox.width, bbox.height)
        fill(1, 0, 0)
        #oval(p.x -bh/2.0 , p.y -bh/2.0, bh, bh)
        #myString.drawAtPoint_withAttributes_(p, attrs)
        rr = NSRect(origin=(p.x -bh/2.0, p.y -bw/2.0), size=(bw, bh))
        #print rr
        
        myString.drawInRect_withAttributes_(rr, attrs)
        myString.drawAtPoint_withAttributes_(p, attrs)
Exemple #41
0
def addCountBadgeToIcon(count, iconImage=None):
    if iconImage is None:
        iconImage = NSImage.alloc().initWithSize_((40, 40))
        iconImage.lockFocus()
        NSColor.colorWithCalibratedRed_green_blue_alpha_(0, 0, 1, .5).set()
        path = NSBezierPath.bezierPath()
        path.appendBezierPathWithOvalInRect_(((0, 0), iconImage.size()))
        path.fill()
        iconImage.unlockFocus()

    # badge text
    textShadow = NSShadow.alloc().init()
    textShadow.setShadowOffset_((2, -2))
    textShadow.setShadowColor_(
        NSColor.colorWithCalibratedRed_green_blue_alpha_(0, 0, 0, 1.0))
    textShadow.setShadowBlurRadius_(2.0)

    paragraph = NSMutableParagraphStyle.alloc().init()
    paragraph.setAlignment_(NSCenterTextAlignment)
    paragraph.setLineBreakMode_(NSLineBreakByCharWrapping)
    attributes = {
        NSFontAttributeName: NSFont.boldSystemFontOfSize_(12.0),
        NSForegroundColorAttributeName: NSColor.whiteColor(),
        NSParagraphStyleAttributeName: paragraph,
        NSShadowAttributeName: textShadow
    }
    text = NSAttributedString.alloc().initWithString_attributes_(
        str(count), attributes)
    rectWidth, rectHeight = NSString.stringWithString_(
        str(count)).sizeWithAttributes_(attributes)
    rectWidth = int(round(rectWidth + 8))
    rectHeight = int(round(rectHeight + 4))
    rectLeft = 0
    rectBottom = 0

    # badge shadow
    badgeShadow = NSShadow.alloc().init()
    badgeShadow.setShadowOffset_((0, -2))
    badgeShadow.setShadowColor_(NSColor.blackColor())
    badgeShadow.setShadowBlurRadius_(4.0)

    # badge path
    badgePath = roundedRectBezierPath(
        ((rectLeft, rectBottom), (rectWidth, rectHeight)), 3)

    # badge image
    badgeWidth = rectWidth + 3
    badgeHeight = rectHeight + 3
    badgeImage = NSImage.alloc().initWithSize_((badgeWidth, badgeHeight))
    badgeImage.lockFocus()
    transform = NSAffineTransform.transform()
    transform.translateXBy_yBy_(1.5, 1.5)
    transform.concat()
    NSColor.colorWithCalibratedRed_green_blue_alpha_(.2, .2, .25, 1.0).set()
    badgePath.fill()
    NSColor.colorWithCalibratedRed_green_blue_alpha_(.8, .8, .9, 1.0).set()
    badgePath.setLineWidth_(1.0)
    badgePath.stroke()
    text.drawInRect_(((0, -1), (rectWidth, rectHeight)))
    badgeImage.unlockFocus()

    # make the composite image
    imageWidth, imageHeight = iconImage.size()
    imageWidth += (badgeWidth - 15)
    imageHeight += 10

    badgeLeft = imageWidth - badgeWidth - 3
    badgeBottom = 3

    image = NSImage.alloc().initWithSize_((imageWidth, imageHeight))
    image.lockFocus()
    context = NSGraphicsContext.currentContext()

    # icon
    iconImage.drawAtPoint_fromRect_operation_fraction_(
        (0, 10), ((0, 0), iconImage.size()), NSCompositeSourceOver, 1.0)

    # badge
    context.saveGraphicsState()
    badgeShadow.set()
    badgeImage.drawAtPoint_fromRect_operation_fraction_(
        (badgeLeft, badgeBottom), ((0, 0), badgeImage.size()),
        NSCompositeSourceOver, 1.0)
    context.restoreGraphicsState()

    # done
    image.unlockFocus()
    return image
 def drawRectRightToLeft_(self, rect):
     self._alternateRects = {}
     # draw the background
     bounds = self.bounds()
     self._backgroundColor.set()
     NSRectFill(bounds)
     # create some reusable values
     scale = self._scale
     descender = self._descender
     upm = self._upm
     scrollWidth = bounds.size[0]
     # offset for the buffer
     ctx = NSGraphicsContext.currentContext()
     ctx.saveGraphicsState()
     aT = NSAffineTransform.transform()
     aT.translateXBy_yBy_(scrollWidth - self._bufferLeft, self._bufferTop)
     aT.concat()
     # offset for the descender
     aT = NSAffineTransform.transform()
     aT.scaleBy_(scale)
     aT.translateXBy_yBy_(0, descender)
     aT.concat()
     # flip
     flipTransform = NSAffineTransform.transform()
     flipTransform.translateXBy_yBy_(0, upm)
     flipTransform.scaleXBy_yBy_(1.0, -1.0)
     flipTransform.concat()
     # set the glyph color
     self._glyphColor.set()
     # draw the records
     left = scrollWidth - self._bufferLeft
     bottom = self._bufferTop
     height = upm * scale
     previousXA = 0
     for recordIndex, glyphRecord in enumerate(reversed(self._glyphRecords)):
         glyph = glyphRecord.glyph
         w = glyphRecord.advanceWidth
         h = glyphRecord.advanceHeight
         xP = glyphRecord.xPlacement
         yP = glyphRecord.yPlacement
         xA = glyphRecord.xAdvance
         yA = glyphRecord.yAdvance
         # handle offsets from the record
         bottom += yP * scale
         glyphHeight = height + ((h + yA) * scale)
         glyphLeft = left + ((-w + xP - xA) * scale)
         glyphWidth = (-w - xA) * scale
         # store the glyph rect for the alternate menu
         rect = ((glyphLeft, bottom), (glyphWidth, glyphHeight))
         self._alternateRects[rect] = recordIndex
         self._currentZeroZeroPoint = NSPoint(glyphLeft, bottom + height + (descender * scale))
         # handle the placement
         aT = NSAffineTransform.transform()
         if xP:
             xP += previousXA
         aT.translateXBy_yBy_(-w - xA + xP, yP)
         aT.concat()
         # draw the glyph
         rect = ((-w + xA - xP, descender - yP), (w, upm))
         self.drawGlyph(glyph, rect, alternate=bool(glyphRecord.alternates))
         # shift for the next glyph
         aT = NSAffineTransform.transform()
         aT.translateXBy_yBy_(-xP, h + yA - yP)
         aT.concat()
         left += (-w - xP - xA) * scale
         previousXA = xA
     ctx.restoreGraphicsState()
Exemple #43
0
 def rotate(self, rotation):
     matrix = NSAffineTransform.transform()
     matrix.rotateByDegrees_(rotation)
     self._ns_path.transformUsingAffineTransform_(matrix)
     self.transformstack[-1].append(["rotate",rotation])
Exemple #44
0
    def drawRect_(self, rect):
        self.wrapper._backColour.set()
        NSBezierPath.fillRect_(rect)
        sizes = [
            8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 24, 28, 32, 36, 48, 60, 72,
            90, 120
        ]
        lineSpace = 8
        tab = 30
        w = NSWidth(self.frame())
        h = NSHeight(self.frame())
        glyphNames = self.wrapper._glyphsList
        insIndex = self.wrapper._instanceIndex
        if insIndex == 0:
            font = Glyphs.font
            m = font.selectedFontMaster
        else:
            instance = Glyphs.font.instances[insIndex - 1]
            font = self.wrapper.instances.get(instance.name)
            if font is None:
                font = instance.interpolatedFont
                self.wrapper.instances[instance.name] = font
            m = font.masters[0]
        fullPath = NSBezierPath.alloc().init()
        advance = 0
        self.wrapper._foreColour.set()

        try:
            for i, glyphName in enumerate(glyphNames):

                glyph = self.glyphForName(glyphName, font)
                if glyph:
                    layer = glyph.layers[m.id]

                    layerPath = layer.completeBezierPath
                    kernValue = 0
                    # kerning check
                    if i + 1 < len(glyphNames):
                        nextGlyphName = glyphNames[i + 1]
                        nextGlyph = self.glyphForName(nextGlyphName, font)
                        if nextGlyph:
                            nextLayer = nextGlyph.layers[m.id]
                            if nextLayer:
                                kernValue = getKernValue(layer, nextLayer)
                                if kernValue > 10000:
                                    kernValue = 0

                    transform = NSAffineTransform.transform()
                    transform.translateXBy_yBy_(advance, 0)
                    layerPath.transformUsingAffineTransform_(transform)
                    advance += layer.width + kernValue

                    fullPath.appendBezierPath_(layerPath)
        except:
            print(traceback.format_exc())

        if fullPath is None:
            return

        try:
            sSum = 0
            upm = float(font.upm)
            for i, s in enumerate(sizes):
                sSum += s + s / 4
                transform = NSAffineTransform.transform()
                transform.scaleBy_(s / upm)
                transform.translateXBy_yBy_(tab * upm / s,
                                            (h - s - sSum) * upm / s)
                self.drawText(str(s), self.wrapper._foreColour, 10,
                              h - s - sSum - 2)
                fullPath.transformUsingAffineTransform_(transform)
                fullPath.fill()
                transform.invert()
                fullPath.transformUsingAffineTransform_(transform)
        except StandardError:
            print(traceback.format_exc())
Exemple #45
0
	def drawRect_(self, rect): ## must be `drawRect_` - nothing else

		bounds = self.bounds()
		scaleFactor = self._scaleFactor
		thisUPM = self._upm * scaleFactor # = self._layer.parent.parent.upm
		rectX, rectY, rectWidth, rectHeight = 0, 0, thisUPM, thisUPM
		self.rect = rect


		# self._layer.drawInFrame_(bounds)  # used in Georgs GlyphView

		try:
			thisGlyph = self._layer.parent
			layerWidth = self._layer.width * scaleFactor
			descender = self._layer.glyphMetrics()[3] * scaleFactor
			
			# ## This order is important! Wont work the other way around.
			# try: # pre Glyphs 2.3
			# 	bezierPathOnly = self._layer.copy().bezierPath()  # Path Only
			# 	bezierPathWithComponents = self._layer.copyDecomposedLayer().bezierPath() # Path & Components
			# except: # Glyphs 2.3
			# 	bezierPathOnly = self._layer.copy().bezierPath  # Path Only
			# 	bezierPathWithComponents = self._layer.copyDecomposedLayer().bezierPath  # Path & Components

			## This order is important! Wont work the other way around.
			try: # Glyphs 2.3
				bezierPathOnly = self._layer.copy().bezierPath  # Path Only
				bezierPathWithComponents = self._layer.copyDecomposedLayer().bezierPath  # Path & Components
			except: # Glyphs 2.4
				bezierPathOnly = self._layer.copy().bezierPath  # Path Only
				bezierPathWithComponents = self._layer.completeBezierPath  # Path & Components


			# Set the scale
			#--------------
			scale = NSAffineTransform.transform()
			scale.translateXBy_yBy_( rectWidth/2 - (layerWidth / 2.0) + self._margin/2, -descender + self._margin/2 )
			scale.scaleBy_( scaleFactor )

			if bezierPathWithComponents:
				bezierPathWithComponents.transformUsingAffineTransform_( scale )
			if bezierPathOnly:
				bezierPathOnly.transformUsingAffineTransform_( scale )

			# Draw components in gray
			#------------------------
			NSColor.darkGrayColor().set() # lightGrayColor
			bezierPathWithComponents.fill()
			
			
			# Draw only path in black
			#------------------------
			if thisGlyph.export:
				NSColor.blackColor().set()
				if bezierPathOnly:
					bezierPathOnly.fill()
			# Draw non-exported glyphs in orange
			#-----------------------------------
			else:
				NSColor.orangeColor().set()
				bezierPathWithComponents.fill()
			
			# AUTO-WIDTH LABEL
			#-----------------
			if self._layer.hasAlignedWidth():
				paragraphStyle = NSMutableParagraphStyle.alloc().init()
				paragraphStyle.setAlignment_(2) ## 0=L, 1=R, 2=C, 3=justified
				attributes = {}
				attributes[NSFontAttributeName] = NSFont.systemFontOfSize_(10)
				attributes[NSForegroundColorAttributeName] = NSColor.lightGrayColor()
				attributes[NSParagraphStyleAttributeName] = paragraphStyle
				String = NSAttributedString.alloc().initWithString_attributes_("Auto-Width", attributes)
				# String.drawAtPoint_((rectWidth, 0))
				NSColor.redColor().set()
				# NSRectFill(((0, 0), (self.rect.size.width, 15)))
				String.drawInRect_(((0, 0), (self.rect.size.width, 15)))
		except:
			pass # print traceback.format_exc()
Exemple #46
0
    def drawRect_(self, rect):
        needCalc = False
        if self.superview() and self._fitToFrame != self.superview().visibleRect().size:
            needCalc = True
        if self.inLiveResize():
            needCalc = True
        if needCalc:
            self.recalculateFrame()

        self.drawBackground()
        if self._glyph is None:
            return

        # apply the overall scale
        transform = NSAffineTransform.transform()
        transform.scaleBy_(self._scale)
        transform.concat()

        # move into position
        visibleWidth = self.bounds().size[0]
        width = self._glyph.width * self._scale
        diff = visibleWidth - width
        xOffset = round((diff / 2) * self._inverseScale)

        yOffset = self._verticalCenterYBuffer * self._inverseScale
        yOffset -= self._descender

        transform = NSAffineTransform.transform()
        transform.translateXBy_yBy_(xOffset, yOffset)
        transform.concat()

        # store the current drawing rect
        w, h = self.bounds().size
        w *= self._inverseScale
        h *= self._inverseScale
        justInCaseBuffer = 1 * self._inverseScale
        xOffset += justInCaseBuffer
        yOffset += justInCaseBuffer
        w += justInCaseBuffer * 2
        h += justInCaseBuffer * 2
        self._drawingRect = ((-xOffset, -yOffset), (w, h))

        # gather the layers
        layerSet = self._glyph.layerSet
        if layerSet is None:
            layers = [(self._glyph, None)]
        else:
            glyphName = self._glyph.name
            layers = []
            for layerName in reversed(layerSet.layerOrder):
                layer = layerSet[layerName]
                if glyphName not in layer:
                    continue
                glyph = layer[glyphName]
                if glyph == self._glyph:
                    layerName = None
                layers.append((glyph, layerName))

        for glyph, layerName in layers:
            # draw the image
            if self.getDrawingAttribute_layerName_("showGlyphImage", layerName):
                self.drawImage(glyph, layerName)
            # draw the blues
            if layerName is None and self.getDrawingAttribute_layerName_("showFontPostscriptBlues", None):
                self.drawBlues(glyph, layerName)
            if layerName is None and self.getDrawingAttribute_layerName_("showFontPostscriptFamilyBlues", None):
                self.drawFamilyBlues(glyph, layerName)
            # draw the margins
            if self.getDrawingAttribute_layerName_("showGlyphMargins", layerName):
                self.drawMargins(glyph, layerName)
            # draw the vertical metrics
            if layerName is None and self.getDrawingAttribute_layerName_("showFontVerticalMetrics", None):
                self.drawVerticalMetrics(glyph, layerName)
            # draw the glyph
            if self.getDrawingAttribute_layerName_("showGlyphFill", layerName) or self.getDrawingAttribute_layerName_("showGlyphStroke", layerName):
                self.drawFillAndStroke(glyph, layerName)
            if self.getDrawingAttribute_layerName_("showGlyphOnCurvePoints", layerName) or self.getDrawingAttribute_layerName_("showGlyphOffCurvePoints", layerName):
                self.drawPoints(glyph, layerName)
            if self.getDrawingAttribute_layerName_("showGlyphAnchors", layerName):
                self.drawAnchors(glyph, layerName)
Exemple #47
0
 def rotateByDegrees_(self, rotation):
     matrix = NSAffineTransform.transform()
     matrix.rotateByDegrees_(rotation)
     self.transformUsingAffineTransform_(matrix)
Exemple #48
0
 def translateXBy_yBy_(self, x, y):
     matrix = NSAffineTransform.transform()
     matrix.translateXBy_yBy_(x,y)
     self.transformUsingAffineTransform_(matrix)
Exemple #49
0
	def drawRect_(self, rect):
		# self._layer.drawInFrame_(bounds)  # used in Georgs GlyphView
		try:
			bounds = self.bounds()
			NSColor.textBackgroundColor().set()
			NSRectFill(bounds)
			scaleFactor = self._scaleFactor

			thisGlyph = self._layer.parent
			layerWidth = self._layer.width * scaleFactor
			descender = self._layer.glyphMetrics()[3] * scaleFactor
			ascender = self._layer.glyphMetrics()[1] * scaleFactor

			## This order is important! Wont work the other way around.
			bezierPathOnly = self._layer.bezierPath # Path Only
			if bezierPathOnly is not None:
				bezierPathOnly = bezierPathOnly.copy()
			bezierPathWithComponents = self._layer.completeBezierPath  # Path & Components
			bezierPathOpenWithComponents = self._layer.completeOpenBezierPath  # Path & Components
			
			# Set the scale
			#--------------
			scale = NSAffineTransform.transform()
			scale.translateXBy_yBy_((bounds.size.width - layerWidth) / 2.0, (bounds.size.height - ascender + descender) / 2.0 - descender)
			scale.scaleBy_(scaleFactor)
			
			
			# Draw only path in black
			#------------------------
			if thisGlyph.export:
				pathColor = NSColor.textColor()
				componentColor = NSColor.secondaryLabelColor()
			else:
				pathColor = NSColor.orangeColor()
				componentColor = NSColor.orangeColor()
				
			if bezierPathWithComponents:
				bezierPathWithComponents.transformUsingAffineTransform_(scale)
				componentColor.set() # Draw components in gray
				bezierPathWithComponents.fill()
			if bezierPathOnly:
				pathColor.set()
				bezierPathOnly.transformUsingAffineTransform_(scale)
				bezierPathOnly.fill()
			if bezierPathOpenWithComponents:
				pathColor.set()
				bezierPathOpenWithComponents.transformUsingAffineTransform_(scale)
				bezierPathOpenWithComponents.stroke()
			# Draw non-exported glyphs in orange
			#-----------------------------------
			else:
				NSColor.orangeColor().set()
				bezierPathWithComponents.transformUsingAffineTransform_(scale)
				bezierPathWithComponents.fill()
			
			attributes = {}
			attributes[NSFontAttributeName] = NSFont.systemFontOfSize_(14)
			attributes[NSForegroundColorAttributeName] = NSColor.secondaryLabelColor()
			
			thisLKG = thisGlyph.leftKerningGroup
			thisRKG = thisGlyph.rightKerningGroup
			if thisLKG is not None:
				String = NSAttributedString.alloc().initWithString_attributes_(thisLKG, attributes)
				String.drawAtPoint_alignment_((12, 5), 0)
			if thisRKG is not None:
				String = NSAttributedString.alloc().initWithString_attributes_(thisRKG, attributes)
				String.drawAtPoint_alignment_((bounds.size.width - 12, 5), 2)

			# AUTO-WIDTH LABEL
			#-----------------
			if self._layer.hasAlignedWidth():
				attributes[NSForegroundColorAttributeName] = NSColor.lightGrayColor()
				attributes[NSFontAttributeName] = NSFont.systemFontOfSize_(11)
				String = NSAttributedString.alloc().initWithString_attributes_("Auto-Width", attributes)
				String.drawAtPoint_alignment_((bounds.size.width / 2.0, 5), 1)
		except:
			print(traceback.format_exc())
Exemple #50
0
 def rotate(self, rotation):
     matrix = NSAffineTransform.transform()
     matrix.rotateByDegrees_(rotation)
     self._ns_path.transformUsingAffineTransform_(matrix)
     self.transformstack[-1].append(["rotate", rotation])