Beispiel #1
0
    def background(self, layer):

        # Check if the grid should be drawn

        currentController = self.controller.view().window().windowController()
        if currentController:
            tool = currentController.toolDrawDelegate()
            if (tool.isKindOfClass_(NSClassFromString("GlyphsToolText")) or
                    tool.isKindOfClass_(NSClassFromString("GlyphsToolHand"))):
                return

        try:
            master = layer.parent.parent.masters[layer.layerId]
        except KeyError:
            return
        if master is None:
            return

        gx, gy, grid_type = getGrid(master)
        if gx == 0 or gy == 0:
            return

        if grid_type == "div":
            upm = layer.parent.parent.upm
            gx = upm / gx
            gy = upm / gy

        NSColor.lightGrayColor().set()
        NSBezierPath.setDefaultLineWidth_(0.6 / self.getScale())

        max_x = int(layer.width // gx + 2)
        min_y = int(master.descender // gy)
        max_y = int(master.ascender // gy + 1)

        max_xx = max_x * gx
        min_yy = min_y * gy
        max_yy = max_y * gy

        for x in range(-1, max_x + 1):
            xx = gx * x
            NSBezierPath.strokeLineFromPoint_toPoint_(NSPoint(xx, min_yy),
                                                      NSPoint(xx, max_yy))

        for y in range(min_y, max_y + 1):
            yy = gy * y
            NSBezierPath.strokeLineFromPoint_toPoint_(NSPoint(-gx, yy),
                                                      NSPoint(max_xx, yy))

        # NSBezierPath.setDefaultLineWidth_(1.0/self.getScale())
        s = int(round(12 / self.getScale()))
        s2 = s * 0.25
        sel = int(round(13 / self.getScale()))

        for p in layer.paths:
            for n in p.nodes:
                if n.type != OFFCURVE:
                    x = n.position.x
                    y = n.position.y
                    if n.selected:
                        s1 = sel
                    else:
                        s1 = s
                    if abs((abs(x) + 1) % gx - 1) < 0.5:
                        NSBezierPath.strokeLineFromPoint_toPoint_(
                            NSPoint(x - s2, y - s1), NSPoint(x - s2, y + s1))
                        NSBezierPath.strokeLineFromPoint_toPoint_(
                            NSPoint(x + s2, y - s1), NSPoint(x + s2, y + s1))
                    if abs((abs(y) + 1) % gy - 1) < 0.5:
                        NSBezierPath.strokeLineFromPoint_toPoint_(
                            NSPoint(x - s1, y - s2), NSPoint(x + s1, y - s2))
                        NSBezierPath.strokeLineFromPoint_toPoint_(
                            NSPoint(x - s1, y + s2), NSPoint(x + s1, y + s2))
    def drawTopOrBottom(self, bbox, defaultColor, zones, top, xHeight,
                        italicAngle):
        try:
            bboxOrigin = bbox.origin
            bboxSize = bbox.size
            left = bboxOrigin.x
            right = left + bboxSize.width
            middle = left + bboxSize.width / 2.0
            position = bboxOrigin.y

            surplus = 30.0
            scale = self.getScale()
            numberDistance = 25.0 / scale
            lineDistance = 10.0 / scale

            # adjust values for top/bottom:
            if top:
                position += bboxSize.height
                numberDistance -= 10.0 / scale
            else:
                numberDistance *= -1
                lineDistance *= -1

            # adjust values for italic angle:
            if italicAngle != 0.0:
                offset = (position - xHeight * 0.5) * math.tan(
                    italicAngle * math.pi / 180.0)
                left += offset
                right += offset
                middle += offset

            # draw it red if it is not inside a zone:
            drawColor = NSColor.redColor()
            for thisZone in zones:
                zoneBegin = thisZone[0]
                zoneEnd = zoneBegin + thisZone[1]
                zoneBottom = min((zoneBegin, zoneEnd))
                zoneTop = max((zoneBegin, zoneEnd))
                if position <= zoneTop and position >= zoneBottom:
                    drawColor = defaultColor

            # set line attributes:
            drawColor.set()
            storedLineWidth = NSBezierPath.defaultLineWidth()
            NSBezierPath.setDefaultLineWidth_(1.0 / scale)

            # draw horizontal line on canvas:
            leftPoint = NSPoint(left - surplus, position)
            rightPoint = NSPoint(right + surplus, position)
            NSBezierPath.strokeLineFromPoint_toPoint_(leftPoint, rightPoint)

            # draw vertical line on canvas:
            startPoint = NSPoint(middle, position)
            endPoint = NSPoint(middle, position + lineDistance)
            NSBezierPath.strokeLineFromPoint_toPoint_(startPoint, endPoint)

            # restore default line width:
            NSBezierPath.setDefaultLineWidth_(storedLineWidth)

            # draw number on canvas:
            self.drawTextAtPoint("%.1f" % position,
                                 NSPoint(middle, position + numberDistance),
                                 fontColor=drawColor)
        except Exception as e:
            self.logToConsole("drawBottom: %s" % str(e))