def __init__(self):
     bgColor = NSColor.colorWithCalibratedRed_green_blue_alpha_(255, 255, 255, 255)
     buttonColor = NSColor.colorWithCalibratedRed_green_blue_alpha_(0, 0, 0, 255)
     self.w = Window((1000, 400), 'Interpolation Matrix', minSize=(470, 300))
     self.w.getNSWindow().setBackgroundColor_(bgColor)
     self.w.glyphTitle = Box((10, 10, 200, 30))
     self.w.glyphName = TextBox((20, 15, 190, 20), 'No current glyph')
     # self.w.fontList = PopUpButton()
     self.axesGrid = {'horizontal': 3, 'vertical': 1}
     self.masters = []
     self.instanceSpots = []
     self.mutator = None
     self.currentGlyph = None
     self.buildMatrix((self.axesGrid['horizontal'], self.axesGrid['vertical']))
     self.w.addColumn = SquareButton((-80, 10, 30, 30), u'+', callback=self.addColumn)
     self.w.removeColumn = SquareButton((-115, 10, 30, 30), u'-', callback=self.removeColumn)
     self.w.addLine = SquareButton((-40, -40, 30, 30), u'+', callback=self.addLine)
     self.w.removeLine = SquareButton((-40, -70, 30, 30), u'-', callback=self.removeLine)
     for button in [self.w.addColumn, self.w.removeColumn, self.w.addLine, self.w.removeLine]:
         button.getNSButton().setBezelStyle_(10)
     self.w.clearMatrix = Button((220, 15, 70, 20), 'Clear', callback=self.clearMatrix)
     self.w.generate = Button((300, 15, 100, 20), 'Generate', callback=self.instanceGeneration)
     # self.w.saveMatrix = Button((300, 15, 70, 20), 'Save', callback=self.saveMatrix)
     # self.w.loadMatrix = Button((380, 15, 70, 20), 'Load', callback=self.loadMatrix)
     addObserver(self, 'updateMatrix', 'currentGlyphChanged')
     addObserver(self, 'updateMatrix', 'fontDidClose')
     addObserver(self, 'updateMatrix', 'mouseUp')
     addObserver(self, 'updateMatrix', 'keyUp')
     self.w.bind('close', self.windowClose)
     self.w.bind('resize', self.windowResize)
     self.w.open()
 def __init__(self):
     bgColor = NSColor.colorWithCalibratedRed_green_blue_alpha_(255, 255, 255, 255)
     buttonColor = NSColor.colorWithCalibratedRed_green_blue_alpha_(0, 0, 0, 255)
     self.w = Window((1000, 400), 'Interpolation Matrix', minSize=(470, 300))
     self.w.getNSWindow().setBackgroundColor_(bgColor)
     self.w.glyphTitle = Box((10, 10, 200, 30))
     self.w.glyphTitle.name = EditText((5, 0, -5, 20), 'No current glyph', self.changeGlyph, continuous=False)
     glyphEdit = self.w.glyphTitle.name.getNSTextField()
     glyphEdit.setBordered_(False)
     glyphEdit.setBackgroundColor_(Transparent)
     glyphEdit.setFocusRingType_(NSFocusRingTypeNone)
     self.axesGrid = {'horizontal': 3, 'vertical': 1}
     self.masters = []
     self.instanceSpots = []
     self.mutator = None
     self.currentGlyph = None
     self.errorGlyph = errorGlyph()
     self.buildMatrix((self.axesGrid['horizontal'], self.axesGrid['vertical']))
     self.w.addColumn = SquareButton((-80, 10, 30, 30), u'+', callback=self.addColumn)
     self.w.removeColumn = SquareButton((-115, 10, 30, 30), u'-', callback=self.removeColumn)
     self.w.addLine = SquareButton((-40, -40, 30, 30), u'+', callback=self.addLine)
     self.w.removeLine = SquareButton((-40, -70, 30, 30), u'-', callback=self.removeLine)
     for button in [self.w.addColumn, self.w.removeColumn, self.w.addLine, self.w.removeLine]:
         button.getNSButton().setBezelStyle_(10)
     self.w.clearMatrix = Button((220, 15, 70, 20), 'Clear', callback=self.clearMatrix)
     self.w.generate = Button((300, 15, 100, 20), 'Generate', callback=self.instanceGeneration)
     # self.w.saveMatrix = Button((300, 15, 70, 20), 'Save', callback=self.saveMatrix)
     # self.w.loadMatrix = Button((380, 15, 70, 20), 'Load', callback=self.loadMatrix)
     addObserver(self, 'updateMatrix', 'currentGlyphChanged')
     addObserver(self, 'updateMatrix', 'fontDidClose')
     addObserver(self, 'updateMatrix', 'mouseUp')
     addObserver(self, 'updateMatrix', 'keyUp')
     self.w.bind('close', self.windowClose)
     self.w.bind('resize', self.windowResize)
     self.w.open()
Exemplo n.º 3
0
    def __init__(self, drawGrid=False):
        self.w = Window((600, 500), "", minSize=(300, 250))

        grp = Group((0, 0, 0, 0))
        grp.button = Button((10, 10, -10, 20), "Toggle", self.buttonCallback)

        self.view1 = TestSplitSubview((0, 0, 0, 0), NSColor.redColor())
        paneDescriptions2 = [
            dict(view=self.view1, canCollapse=True, size=50, identifier="pane1"),
            dict(view=grp, identifier="pane2"),
            dict(view=TestSplitSubview((0, 0, 0, 0), NSColor.greenColor()), minSize=50, identifier="pane3"),
            dict(view=TestSplitSubview((0, 0, 0, 0), NSColor.yellowColor()), identifier="pane4"),
        ]
        self.nestedSplit = SplitView((0, 0, 0, 0), paneDescriptions2, isVertical=True)
        paneDescriptions1 = [
            dict(view=self.nestedSplit, identifier="pane5"),
            dict(
                view=TestSplitSubview((0, 0, 0, 0), NSColor.magentaColor()),
                minSize=100,
                size=100,
                canCollapse=True,
                identifier="pane6",
            ),
        ]
        self.w.splitView = SplitView((10, 10, -10, -10), paneDescriptions1, isVertical=False)

        if drawGrid:
            self.drawGrid()
        self.w.open()
Exemplo n.º 4
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,
            )
Exemplo n.º 5
0
    def setPixel(self, event, dragging=False):
        if self.data is None:
            return False
        try:
            editView = self.editViewController().graphicView()
        except:
            return False

        layer = editView.activeLayer()
        try:
            master = layer.parent.parent.masters[layer.layerId]
        except KeyError:
            return False
        if master is None:
            return False

        # Get location of click in font coordinates
        Loc = editView.getActiveLocation_(event)
        loc_pixel = ((Loc.x - self.rect.origin.x) / self.pixel_size,
                     (Loc.y - self.rect.origin.y) / self.pixel_size /
                     self.pixel_ratio)
        if self.prev_location != loc_pixel:
            x, y = loc_pixel
            current = NSGraphicsContext.currentContext()
            context = NSGraphicsContext.graphicsContextWithBitmapImageRep_(
                self.data)
            if context is None:
                self.prev_location = loc_pixel
                print("Could not get context in setPixel")
                return False
            NSGraphicsContext.saveGraphicsState()
            NSGraphicsContext.setCurrentContext_(context)
            if self.erase:
                NSColor.whiteColor().set()
            else:
                NSColor.blackColor().set()
            effective_size = self.pen_size / self.pixel_size
            if dragging and self.prev_location is not None:
                px, py = self.prev_location
                path = NSBezierPath.alloc().init()
                path.setLineCapStyle_(NSRoundLineCapStyle)
                path.setLineWidth_(effective_size)
                # path.strokeLineFromPoint_toPoint_(x, y, x + self.pen_size, y + self.pen_size)
                path.moveToPoint_((px, py))
                path.lineToPoint_((x, y))
                path.stroke()
                self.needs_save = True
            else:
                half = effective_size / 2
                rect = NSMakeRect(x - half, y - half, effective_size,
                                  effective_size)
                path = NSBezierPath.bezierPathWithOvalInRect_(rect)
                path.fill()
                self.needs_save = True
            # For rectangular pens:
            # NSBezierPath.fillRect_(rect)
            NSGraphicsContext.setCurrentContext_(current)
            NSGraphicsContext.restoreGraphicsState()
            self.prev_location = loc_pixel
        return True
Exemplo n.º 6
0
    def drawWithFrame_inView_(self, frame, view):
        row = view.selectedRow()
        columnCount = len(view.tableColumns())
        frames = [
            view.frameOfCellAtColumn_row_(i, row) for i in range(columnCount)
        ]
        selected = frame in frames

        (x, y), (w, h) = frame
        y += 1
        h -= 2

        if selected:
            pillTextAttributes[NSForegroundColorAttributeName] = self._color
            foregroundColor = NSColor.whiteColor()
        else:
            pillTextAttributes[
                NSForegroundColorAttributeName] = NSColor.whiteColor()
            foregroundColor = self._color

        text = self.title()
        text = NSAttributedString.alloc().initWithString_attributes_(
            text, pillTextAttributes)
        textRect = text.boundingRectWithSize_options_((w, h), 0)
        (textX, textY), (textW, textH) = textRect

        foregroundColor.set()
        path = NSBezierPath.bezierPath()
        radius = h / 2.0
        path.appendBezierPathWithOvalInRect_(((x, y), (h, h)))
        path.appendBezierPathWithOvalInRect_(((x + textW - 1, y), (h, h)))
        path.appendBezierPathWithRect_(((x + radius, y), (textW - 1, h)))
        path.fill()
        text.drawInRect_(((x + radius, y), (textW, textH)))
Exemplo n.º 7
0
 def __init__(self,):
     self.w = FloatingWindow((self._width, self._height), self._title, closable=False)
     self._all_fonts = AllFonts()
     for f in self._all_fonts:
         self._all_fonts_names.append(get_full_name(f))
     # source font
     self.w._source_label = TextBox((self._padding, self._padding_top, -self._padding, 17), "source font:")
     self.w._source_value = PopUpButton((self._padding, 35, -self._padding, 20), self._all_fonts_names)
     # mark source
     self.w.mark_source_checkbox = CheckBox((self._padding, 65, -self._padding, 20), "mark glyphs", value=True)
     self.w.mark_source_color = ColorWell(
         (120, 65, -13, 20), color=NSColor.colorWithCalibratedRed_green_blue_alpha_(*self._mark_color_source)
     )
     # dest font
     self.w._dest_label = TextBox((self._padding, 100, -self._padding, 17), "target font:")
     self.w._dest_value = PopUpButton((self._padding, 125, -self._padding, 20), self._all_fonts_names)
     # mark dest
     self.w.mark_dest_checkbox = CheckBox((self._padding, 155, -self._padding, 20), "mark glyphs", value=True)
     self.w.mark_dest_color = ColorWell(
         (120, 155, -13, 20), color=NSColor.colorWithCalibratedRed_green_blue_alpha_(*self._mark_color_dest)
     )
     self.w.line = HorizontalLine((self._padding, 200, -self._padding, 1))
     # center
     self.w.center_checkbox = CheckBox((self._padding, 215, -self._padding, 20), "center glyphs", value=False)
     self.w.line2 = HorizontalLine((self._padding, 250, -self._padding, 1))
     # buttons
     self.w.button_apply = Button(
         (self._padding, -50, self._width / 2 - 15, 0), "apply", callback=self.apply_callback
     )
     self.w.button_close = Button(
         (self._width / 2 + 5, -50, -self._padding, 0), "close", callback=self.close_callback
     )
     # open window
     self.w.open()
Exemplo n.º 8
0
    def drawHashMarksAndLabelsInRect_(self, rect):
        bounds = self.bounds()
        view = self.clientView()

        rulerBackgroundColor = self.rulerBackgroundColor()
        if rulerBackgroundColor is not None:
            rulerBackgroundColor.set()
            NSRectFill(bounds)

        if not isinstance(view, NSTextView):
            return

        layoutManager = view.layoutManager()
        container = view.textContainer()
        text = view.string()
        nullRange = NSMakeRange(NSNotFound, 0)
        yinset = view.textContainerInset().height
        visibleRect = self.scrollView().contentView().bounds()
        textAttributes = self.textAttributes()

        lines = self.lineIndices()

        glyphRange = layoutManager.glyphRangeForBoundingRect_inTextContainer_(visibleRect, container)
        _range = layoutManager.characterRangeForGlyphRange_actualGlyphRange_(glyphRange, None)[0]
        _range.length += 1

        count = len(lines)
        index = 0

        lineNumber = self.lineNumberForCharacterIndex_inText_(_range.location, text)

        for line in range(lineNumber, count):
            index = lines[line]
            if NSLocationInRange(index, _range):
                rects, rectCount = layoutManager.rectArrayForCharacterRange_withinSelectedCharacterRange_inTextContainer_rectCount_(
                    NSMakeRange(index, 0),
                    nullRange,
                    container,
                    None
                )
                if rectCount > 0:
                    ypos = yinset + NSMinY(rects[0]) - NSMinY(visibleRect)
                    labelText = NSString.stringWithString_("%s" % (line + 1))
                    stringSize = labelText.sizeWithAttributes_(textAttributes)

                    x = NSWidth(bounds) - stringSize.width - self.RULER_MARGIN
                    y = ypos + (NSHeight(rects[0]) - stringSize.height) / 2.0
                    w = NSWidth(bounds) - self.RULER_MARGIN * 2.0
                    h = NSHeight(rects[0])

                    labelText.drawInRect_withAttributes_(NSMakeRect(x, y, w, h), textAttributes)

            if index > NSMaxRange(_range):
                break

        path = NSBezierPath.bezierPath()
        path.moveToPoint_((bounds.origin.x + bounds.size.width, bounds.origin.y))
        path.lineToPoint_((bounds.origin.x + bounds.size.width, bounds.origin.y + bounds.size.height))
        NSColor.grayColor().set()
        path.stroke()
Exemplo n.º 9
0
    def drawWithFrame_inView_(self, frame, view):
        row = view.selectedRow()
        columnCount = len(view.tableColumns())
        frames = [view.frameOfCellAtColumn_row_(i, row) for i in xrange(columnCount)]
        selected = frame in frames

        (x, y), (w, h) = frame
        y += 1
        h -= 2

        if selected:
            pillTextAttributes[NSForegroundColorAttributeName] = self._color
            foregroundColor = NSColor.whiteColor()
        else:
            pillTextAttributes[NSForegroundColorAttributeName] = NSColor.whiteColor()
            foregroundColor = self._color

        text = self.title()
        text = NSAttributedString.alloc().initWithString_attributes_(text, pillTextAttributes)
        textRect = text.boundingRectWithSize_options_((w, h), 0)
        (textX, textY), (textW, textH) = textRect

        foregroundColor.set()
        path = NSBezierPath.bezierPath()
        radius = h / 2.0
        path.appendBezierPathWithOvalInRect_(((x, y), (h, h)))
        path.appendBezierPathWithOvalInRect_(((x + textW - 1, y), (h, h)))
        path.appendBezierPathWithRect_(((x + radius, y), (textW - 1, h)))
        path.fill()
        text.drawInRect_(((x + radius, y), (textW, textH)))
Exemplo n.º 10
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)
Exemplo n.º 11
0
    def isWindowOnDockingSide(self, dockingWindow):
        '''
            checks whenever dragged docking window is above any dock bar
        '''

        winX, winY, winW, winH = dockingWindow.getPosSize()

        titleBarHeight = self._calculateParentWindowTitlebarHeight()

        x, y = (winX + winW / 2, winY - titleBarHeight / 2)
        px, py, pw, ph = self.getParentWindowPosSize()
        titleBarMiddlePoint = NSPoint(pw - (px - x) - pw, (py - y) + ph)
        isDockingWindowAbove = False
        dockingPosition = None
        for position in self.dockingRectPosSizes.keys():
            dockingSideObj = getattr(self, f'{position}_dockbar', None)
            if dockingSideObj is not None:
                view = dockingSideObj.getNSView().hitTest_(titleBarMiddlePoint)
                if view is not None:
                    dockingSideObj.getNSView().layer().setBackgroundColor_(
                        NSColor.orangeColor().CGColor())
                    dockingPosition = position
                    isDockingWindowAbove = True
                else:
                    dockingSideObj.getNSView().layer().setBackgroundColor_(
                        NSColor.clearColor().CGColor())
        if isDockingWindowAbove:
            dockingWindow.getNSWindow().setAlphaValue_(.4)
        else:
            dockingWindow.getNSWindow().setAlphaValue_(1)
        return dockingPosition, self
Exemplo n.º 12
0
    def start(self):
        self.leftInput = "n"

        super(ptHUDleftContext, self).start()

        addObserver(self, "drawNeighbors", "drawBackground")
        addObserver(self, "drawPreviewNeighBors", "drawPreview")
        addObserver(self, "currentFontChanged", "fontBecameCurrent")

        foregroundColor = NSColor.colorWithCalibratedRed_green_blue_alpha_(
            0.0, 0.0, 0.0, 0.7)
        backgroundColor = NSColor.colorWithCalibratedRed_green_blue_alpha_(
            0.0, 0.0, 0.0, 0.05)

        self.view.unicodeLeftEditText = vanilla.EditText(
            (0, 0, 40, 19),
            "n",
            callback=self.editLeftCallback,
            continuous=False,
            sizeStyle="small")

        controls = [
            (self.view.unicodeLeftEditText, NSCenterTextAlignment),
        ]
        for control, alignment in controls:
            textField = control.getNSTextField()
            textField.setBordered_(False)
            textField.setTextColor_(foregroundColor)
            textField.setBackgroundColor_(backgroundColor)
            textField.setFocusRingType_(NSFocusRingTypeNone)
            textField.setAlignment_(alignment)
Exemplo n.º 13
0
    def __init__(self):
        f = CurrentFont()
        if f is None:
            return
        if f.path is None:
            print("Save this font first!")
            return

        self.designSpaceModel = f.lib.get(self.designSpaceModelLibKey,
                                          "twobytwo")
        #print "self.designSpaceModel", self.designSpaceModel
        if self.designSpaceModel == "twobytwo":
            self.masterNames = [
                'narrow-thin', 'wide-thin', 'narrow-bold', 'wide-bold'
            ]
        elif self.designSpaceModel == "twobyone":
            self.masterNames = ['narrow-thin', 'wide-thin']
        rgbBlack = NSColor.colorWithDeviceRed_green_blue_alpha_(0, 0, 0, 1)
        rgbWhite = NSColor.colorWithDeviceRed_green_blue_alpha_(
            255, 255, 255, 1)
        self.shapeColor = rgbWhite
        self.backgroundColor = rgbBlack
        self.extrapolateMinValue = 0
        self.extrapolateMaxValue = 1
        self.w = vanilla.Window((500, 600),
                                "Responsive Lettering",
                                minSize=(300, 200))
        self.w.preview = HTMLView((0, 0, -0, -140))
        self.w.exportButton = vanilla.Button((-150, -30, -10, 20),
                                             "Export SVG",
                                             callback=self.cbExport)
        columnDescriptions = [
            dict(title="Glyphname", key="name", width=125),
            dict(title="Width", key="width", width=50),
            dict(title="Height", key="height", width=50),
            dict(title="Bounds?", key="bounds", width=75),
            dict(title="Contours", key="contours", width=50),
            dict(title="Points", key="points", width=50),
        ]
        self.w.l = vanilla.List((0, -140, -0, -40),
                                self.wrapGlyphs(),
                                columnDescriptions=columnDescriptions,
                                doubleClickCallback=self.callbackListClick)
        self.w.t = vanilla.TextBox((70, -27, -160, 20),
                                   "FontName",
                                   sizeStyle="small")
        self.w.backgroundColorWell = vanilla.ColorWell(
            (10, -30, 20, 20),
            callback=self.backgroundColorWellCallback,
            color=rgbBlack)
        self.w.shapeColorWell = vanilla.ColorWell(
            (35, -30, 20, 20),
            callback=self.shapeColorWellCallback,
            color=rgbWhite)

        self.w.bind("became main", self.windowBecameMainCallback)
        self.setColorsFromLib()
        self.update()
        self.w.open()
        self.cbMakePreview(None)
Exemplo n.º 14
0
def drawGlyphFillAndStroke(glyph,
                           scale,
                           rect,
                           drawFill=True,
                           drawStroke=True,
                           contourFillColor=None,
                           contourStrokeColor=None,
                           componentFillColor=None,
                           backgroundColor=None,
                           contourStrokeWidth=1.0):
    # get the layer color
    layer = glyph.layer
    layerColor = None
    if layer is not None and layer.color is not None:
        layerColor = colorToNSColor(layer.color)
    # get the paths
    contourPath = glyph.getRepresentation(
        "defconAppKit.NoComponentsNSBezierPath")
    componentPath = glyph.getRepresentation(
        "defconAppKit.OnlyComponentsNSBezierPath")
    # fill
    if drawFill:
        # work out the colors
        if contourFillColor is None and layerColor is not None:
            contourFillColor = layerColor
        elif contourFillColor is None and layerColor is None:
            contourFillColor = getDefaultColor("glyphContourFill")
        if componentFillColor is None and layerColor is not None:
            componentFillColor = layerColor
        elif componentFillColor is None and layerColor is None:
            componentFillColor = getDefaultColor("glyphComponentFill")
        # make the fill less opaque if stroking
        if drawStroke:
            contourFillColor = NSColor.colorWithCalibratedRed_green_blue_alpha_(
                contourFillColor.redComponent(),
                contourFillColor.greenComponent(),
                contourFillColor.blueComponent(),
                contourFillColor.alphaComponent() * 0.6)
            componentFillColor = NSColor.colorWithCalibratedRed_green_blue_alpha_(
                componentFillColor.redComponent(),
                componentFillColor.greenComponent(),
                componentFillColor.blueComponent(),
                componentFillColor.alphaComponent() * 0.6)
        # components
        componentFillColor.set()
        componentPath.fill()
        # contours
        contourFillColor.set()
        contourPath.fill()
    # stroke
    if drawStroke:
        # work out the color
        if contourStrokeColor is None and layerColor is not None:
            contourStrokeColor = layerColor
        elif contourStrokeColor is None and layerColor is None:
            contourStrokeColor = getDefaultColor("glyphContourStroke")
        # contours
        contourPath.setLineWidth_(contourStrokeWidth * scale)
        contourStrokeColor.set()
        contourPath.stroke()
Exemplo n.º 15
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
Exemplo n.º 16
0
def draw_color(layer, info):
    r, g, b, a = 231 / 255.0, 227 / 255.0, 51 / 147.0, 50 / 100.0
    try:
        NSColor.colorWithCalibratedRed_green_blue_alpha_(r, g, b, a).set()
        layer.background.bezierPath.fill()
    except:
        import traceback
        print traceback.format_exc()
Exemplo n.º 17
0
 def drawRect_(self, rect):
     NSColor.whiteColor().set()
     NSRectFill(self.bounds())
     origin = (self.center[0]-self.radius, self.center[1]-self.radius)
     size = (2 * self.radius, 2 * self.radius)
     dotRect = (origin, size)
     self.color.set()
     NSBezierPath.bezierPathWithOvalInRect_(dotRect).fill()
Exemplo n.º 18
0
 def drawRect_(self, rect):
     from AppKit import NSRectFill, NSBezierPath, NSColor
     self.color.set()
     NSRectFill(self.bounds())
     NSColor.blackColor().set()
     p = NSBezierPath.bezierPathWithRect_(self.bounds())
     p.setLineWidth_(10)
     p.stroke()
Exemplo n.º 19
0
 def drawRect_(self, rect):
     NSColor.whiteColor().set()
     NSRectFill(self.bounds())
     origin = (self.center[0] - self.radius, self.center[1] - self.radius)
     size = (2 * self.radius, 2 * self.radius)
     dotRect = (origin, size)
     self.color.set()
     NSBezierPath.bezierPathWithOvalInRect_(dotRect).fill()
Exemplo n.º 20
0
 def drawRect_(self, rect):
     printB("drawRect",  rect )
     
     """."""
     NSColor.whiteColor().set()
     NSBezierPath.fillRect_(rect)
     self.itemColor().set()
     NSBezierPath.fillRect_(self.calculatedItemBounds())
Exemplo n.º 21
0
 def drawRect_(self, rect):
     from AppKit import NSRectFill, NSBezierPath, NSColor
     self.color.set()
     NSRectFill(self.bounds())
     NSColor.blackColor().set()
     p = NSBezierPath.bezierPathWithRect_(self.bounds())
     p.setLineWidth_(10)
     p.stroke()
Exemplo n.º 22
0
 def drawRect_(self, rect):
     super(PictureView, self).drawRect_(rect)
     pos = self.dropboxViewFinalPosition.origin
     size = self.dropboxViewFinalPosition.size
     a = NSBezierPath.bezierPathWithRoundedRect_xRadius_yRadius_(NSRect((pos[0] - 3, pos[1] - 3), (size[0] + 6, size[1] + 6)), 5.0, 5.0)
     a.setLineWidth_(2)
     NSColor.whiteColor().set()
     a.fill()
 def draw_color(self, layer, info):
     r, g, b, a = 231 / 255.0, 227 / 255.0, 51 / 147.0, 50 / 100.0
     
     try:
         NSColor.colorWithCalibratedRed_green_blue_alpha_(r, g, b, a).set()
         layer.background.bezierPath.fill()
     except:
         import traceback
         print traceback.format_exc()
def draw_ground(layer, info):
    # Due to internal Glyphs.app structure, we need to catch and print exceptions
    # of these callback functions with try/except like so:
    try:
        NSColor.colorWithCalibratedRed_green_blue_alpha_(r, g, b, a).set()
        layer.background.bezierPath.fill()  # check how to draw on foreground
    except:
        import traceback
        print traceback.format_exc()
Exemplo n.º 25
0
def linearGradient(startPoint=None, endPoint=None, colors=None, locations=None):
	global currentGradient
	global currentFillColor
	if colors is None:
		colors = [NSColor.greenColor(), NSColor.redColor()]
	if locations is None:
		locations = [i / float(len(colors)-1) for i in range(len(colors))]
	currentGradient = ("linear", startPoint, endPoint, colors, locations)
	currentFillColor = None
Exemplo n.º 26
0
def stroke(r=None, g=None, b=None, a=1):
	# Set the stroke color as RGB value.
	global currentStrokeColor
	if r is None:
		currentStrokeColor = None
	elif g is None:
		currentStrokeColor = NSColor.colorWithDeviceWhite_alpha_(r, a)
	else:
		currentStrokeColor = NSColor.colorWithDeviceRed_green_blue_alpha_(r, g, b, a)
Exemplo n.º 27
0
 def drawRect_(self, rect):
     if not self.border:
         return super(ThumbnailBoxView, self).drawRect_(rect)
     with save_graphics_state():
         self._shadow.set()
         NSColor.whiteColor().set()
         NSBezierPath.bezierPathWithRect_(NSInsetRect(rect, self.BORDER_INSET, self.BORDER_INSET)).fill()
     size = self.image().size()
     self.image().drawInRect_fromRect_operation_fraction_(NSInsetRect(rect, self.IMAGE_INSET, self.IMAGE_INSET), NSMakeRect(*rect_to_centered_square(size.width, size.height)), NSCompositeSourceOver, 1.0)
Exemplo n.º 28
0
def draw_ground(layer, info):
    # Due to internal Glyphs.app structure, we need to catch and print exceptions
    # of these callback functions with try/except like so:
    try:
        NSColor.colorWithCalibratedRed_green_blue_alpha_(r, g, b, a).set()
        layer.background.bezierPath.fill()  # check how to draw on foreground
    except:
        import traceback
        print traceback.format_exc()
Exemplo n.º 29
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())
Exemplo n.º 30
0
def DrawGlyph(f, glyph, PSCommands, xoffset, yoffset, ratio, fillcolour,
              strokecolour, strokewidth, dashed):
    if not PSCommands:
        layer = glyph.layers[0]
        p = layer.drawBezierPath
        transform = NSAffineTransform.new()
        transform.translateXBy_yBy_(xoffset * mm, yoffset * mm)
        transform.scaleBy_(ratio)
        p.transformUsingAffineTransform_(transform)
    else:
        p = NSBezierPath.bezierPath()

        for command in PSCommands:

            if command[0] == 'moveTo':
                try:
                    p.close()
                except:
                    pass

                x = xoffset * mm + command[1][0] * ratio
                y = yoffset * mm + command[1][1] * ratio
                p.moveToPoint_((x, y))
                #print "('moveTo', (%s, %s))," % (command[1][0], command[1][1])

            if command[0] == 'lineTo':
                x = xoffset * mm + command[1][0] * ratio
                y = yoffset * mm + command[1][1] * ratio
                p.lineToPoint_((x, y))
                #print "('lineTo', (%s, %s))," % (command[1][0], command[1][1])

            if command[0] == 'curveTo':

                points = []

                for point in command[1:]:
                    points.append((xoffset * mm + point[0] * ratio,
                                   yoffset * mm + point[1] * ratio))

                p.curveToPoint_controlPoint1_controlPoint2_(
                    points[0], points[1], points[2])
        p.closePath()

    if fillcolour:
        NSColor.colorWithDeviceCyan_magenta_yellow_black_alpha_(
            fillcolour[0], fillcolour[1], fillcolour[2], fillcolour[3],
            1).set()
        p.fill()
    if strokecolour:
        NSColor.colorWithDeviceCyan_magenta_yellow_black_alpha_(
            strokecolour[0], strokecolour[1], strokecolour[2], strokecolour[3],
            1).set()
        if dashed:
            p.setLineDash_count_phase_(dashed, 2, 0.0)
        p.setLineWidth_(strokewidth)
        p.stroke()
def draw_color(layer, info):
    r, g, b, a = 231 / 255.0, 227 / 255.0, 51 / 147.0, 50 / 100.0
    try:
        NSColor.colorWithCalibratedRed_green_blue_alpha_(r, g, b, a).set()
        for gname in up_diacritics:
            l = font.glyphs[d_name].layers['diacritics']
            l.bezierPath.fill()
    except:
        import traceback
        print traceback.format_exc()
Exemplo n.º 32
0
def stroke(r=None, g=None, b=None, a=1):
    # Set the stroke color as RGB value.
    global currentStrokeColor
    if r is None:
        currentStrokeColor = None
    elif g is None:
        currentStrokeColor = NSColor.colorWithDeviceWhite_alpha_(r, a)
    else:
        currentStrokeColor = NSColor.colorWithDeviceRed_green_blue_alpha_(
            r, g, b, a)
Exemplo n.º 33
0
 def check_signature_matcher(self, obj):
     regex       = obj.stringValue()
     feedback    = self.customSignatureMatcherFeedback
     try:
         re.compile(regex)
         feedback.setColor_(NSColor.greenColor())
         feedback.setToolTip_("")
     except re.error, e:
         feedback.setColor_(NSColor.redColor())
         feedback.setToolTip_(str(e))
def draw_color(layer, info):
    r, g, b, a = 231 / 255.0, 227 / 255.0, 51 / 147.0, 50 / 100.0
    try:
        NSColor.colorWithCalibratedRed_green_blue_alpha_(r, g, b, a).set()
        for gname in up_diacritics:
            l = font.glyphs[d_name].layers['diacritics']
            l.bezierPath.fill()
    except:
        import traceback
        print traceback.format_exc()
Exemplo n.º 35
0
    def background(self, layer):

        # Fills background path of current glyph with non-photo blue
        NSColor.colorWithRed_green_blue_alpha_(.643, .867, .929, .3).set()
        if layer.background.bezierPath:
            layer.background.bezierPath.fill()
        # Fills background path of current component glyph with vermillion
        NSColor.colorWithRed_green_blue_alpha_(.89, .259, .204, .3).set()
        for backgroundComponent in layer.background.components:
            backgroundComponent.bezierPath.fill()
 def flatButt(self, this, match=False):
     this = this.getNSButton()
     this.setBezelStyle_(buttstyle)
     this.setBordered_(False)
     this.setWantsLayer_(True)
     this.setBackgroundColor_(NSColor.whiteColor())
     if match == True:
         this.setBackgroundColor_(
             NSColor.colorWithCalibratedRed_green_blue_alpha_(
                 .9, 1, .85, 1))
Exemplo n.º 37
0
 def check_signature_matcher(self, obj):
     regex       = obj.stringValue()
     feedback    = self.customSignatureMatcherFeedback
     try:
         re.compile(regex)
         feedback.setColor_(NSColor.greenColor())
         feedback.setToolTip_("")
     except re.error, e:
         feedback.setColor_(NSColor.redColor())
         feedback.setToolTip_(str(e))
Exemplo n.º 38
0
 def showWindow_(self, sender):
     try:
         edY = 22
         clX = 22
         spX = 8
         spY = 8
         btnY = 17
         self.windowWidth = 300
         self.windowHeight = 240
         self.currentDocument = Glyphs.currentDocument
         self.thisfont = Glyphs.font
         # self.thisfont = GlyphsApp.currentFont()
         self.w = FloatingWindow(
             (self.windowWidth, self.windowWidth),
             self.name,
             autosaveName="com.Tosche.Waterfall.mainwindow",
             minSize=(self.windowWidth, self.windowWidth + 20))
         self.w.bind("close", self.windowClosed_)
         insList = [i.name for i in Glyphs.font.instances]
         insList.insert(0, 'Current Master')
         self.w.edit = EditText(
             (spX, spY, (-spX * 3 - clX * 2) - 80, edY),
             text="The quick brown jumps over the lazy dog.",
             callback=self.textChanged_)
         self.w.edit.getNSTextField().setNeedsLayout_(True)
         defaultWhite = NSColor.colorWithCalibratedRed_green_blue_alpha_(
             1, 1, 1, 1)
         defaultBlack = NSColor.colorWithCalibratedRed_green_blue_alpha_(
             0, 0, 0, 1)
         self.w.foreColour = ColorWell((-spX * 2 - clX * 2, spY, clX, edY),
                                       color=defaultBlack,
                                       callback=self.uiChange_)
         self.w.backColour = ColorWell((-spX - clX, spY, clX, edY),
                                       color=defaultWhite,
                                       callback=self.uiChange_)
         self.w.refresh = Button((-spX - 138, spY, 80, edY),
                                 "Refresh",
                                 callback=self.textChanged_)
         self.w.instancePopup = PopUpButton((spX, spY * 2 + edY, -spX, edY),
                                            insList,
                                            callback=self.changeInstance_)
         self.w.preview = TheView((0, spX * 3 + edY * 2, -0, -0))
         self.w.preview.instances = {}
         self.loadPrefs()
         self.w.open()
         self.uiChange_(None)
         self.changeInstance_(self.w.instancePopup)
         self.textChanged_(self.w.edit)
         Glyphs.addCallback(
             self.changeInstance_, UPDATEINTERFACE
         )  # will be called on every change to the interface
         Glyphs.addCallback(self.changeDocument_, DOCUMENTACTIVATED)
     except:
         print(traceback.format_exc())
Exemplo n.º 39
0
def drawline(x1, y1, x2, y2, colour, strokewidth, dashed):

	NSColor.colorWithDeviceCyan_magenta_yellow_black_alpha_(colour[0], colour[1], colour[2], colour[3], 1).set()
	Path = NSBezierPath.bezierPath()
	Path.moveToPoint_((x1, y1))
	Path.lineToPoint_((x2, y2))
	Path.setLineWidth_(strokewidth)
	
	if dashed:
		Path.setLineDash_count_phase_(dashed, 2, 0.0)
	Path.stroke()
Exemplo n.º 40
0
 def __init__(self, ):
     self.w = FloatingWindow((self._width, self._height),
                             self._title,
                             closable=False)
     self._all_fonts = AllFonts()
     for f in self._all_fonts:
         self._all_fonts_names.append(get_full_name(f))
     # source font
     self.w._source_label = TextBox(
         (self._padding, self._padding_top, -self._padding, 17),
         "source font:")
     self.w._source_value = PopUpButton(
         (self._padding, 35, -self._padding, 20), self._all_fonts_names)
     # mark source
     self.w.mark_source_checkbox = CheckBox(
         (self._padding, 65, -self._padding, 20), "mark glyphs", value=True)
     self.w.mark_source_color = ColorWell(
         (120, 65, -13, 20),
         color=NSColor.colorWithCalibratedRed_green_blue_alpha_(
             *self._mark_color_source))
     # dest font
     self.w._dest_label = TextBox((self._padding, 100, -self._padding, 17),
                                  "target font:")
     self.w._dest_value = PopUpButton(
         (self._padding, 125, -self._padding, 20), self._all_fonts_names)
     # mark dest
     self.w.mark_dest_checkbox = CheckBox(
         (self._padding, 155, -self._padding, 20),
         "mark glyphs",
         value=True)
     self.w.mark_dest_color = ColorWell(
         (120, 155, -13, 20),
         color=NSColor.colorWithCalibratedRed_green_blue_alpha_(
             *self._mark_color_dest))
     self.w.line = HorizontalLine((self._padding, 200, -self._padding, 1))
     # left / right
     self.w.left_checkbox = CheckBox(
         (self._padding, 215, -self._padding, 20), "copy left", value=True)
     self.w.right_checkbox = CheckBox(
         (self._width / 2, 215, -self._padding, 20),
         "copy right",
         value=True)
     self.w.line2 = HorizontalLine((self._padding, 250, -self._padding, 1))
     # buttons
     self.w.button_apply = Button(
         (self._padding, -50, self._width / 2 - 15, 0),
         "apply",
         callback=self.apply_callback)
     self.w.button_close = Button(
         (self._width / 2 + 5, -50, -self._padding, 0),
         "close",
         callback=self.close_callback)
     # open window
     self.w.open()
 def drawCoveringBadge(self, x, y, width, height, radius):
     try:
         myPath = NSBezierPath.alloc().init()
         NSColor.colorWithCalibratedRed_green_blue_alpha_(*COLOR).set()
         myRect = NSRect((x, y), (width, height))
         thisPath = NSBezierPath.bezierPathWithRoundedRect_cornerRadius_(
             myRect, radius)
         myPath.appendBezierPath_(thisPath)
         myPath.fill()
     except:
         print traceback.format_exc()
Exemplo n.º 42
0
	def drawLine(self, x1, y1, x2, y2, strokeWidth=1):
		try:
			myPath = NSBezierPath.bezierPath()
			myPath.moveToPoint_( (x1, y1) )
			myPath.lineToPoint_( (x2, y2) )
			myPath.setLineWidth_( strokeWidth/self.getScale() )
			selectionColor = 0, 0, 0.5, 0.2
			NSColor.colorWithCalibratedRed_green_blue_alpha_( *selectionColor ).set()
			myPath.stroke()
		except:
			print(traceback.format_exc())
Exemplo n.º 43
0
def drawGlyphFillAndStroke(glyph, scale, rect,
        drawFill=True, drawStroke=True,
        contourFillColor=None, contourStrokeColor=None, componentFillColor=None, backgroundColor=None,
        contourStrokeWidth=1.0):
    # get the layer color
    layer = glyph.layer
    layerColor = None
    if layer is not None and layer.color is not None:
        layerColor = colorToNSColor(layer.color)
    # get the paths
    contourPath = glyph.getRepresentation("defconAppKit.NoComponentsNSBezierPath")
    componentPath = glyph.getRepresentation("defconAppKit.OnlyComponentsNSBezierPath")
    # fill
    if drawFill:
        # work out the colors
        if contourFillColor is None and layerColor is not None:
            contourFillColor = layerColor
        elif contourFillColor is None and layerColor is None:
            contourFillColor = getDefaultColor("glyphContourFill")
        if componentFillColor is None and layerColor is not None:
            componentFillColor = layerColor
        elif componentFillColor is None and layerColor is None:
            componentFillColor = getDefaultColor("glyphComponentFill")
        # make the fill less opaque if stroking
        if drawStroke:
            contourFillColor = NSColor.colorWithCalibratedRed_green_blue_alpha_(
                contourFillColor.redComponent(),
                contourFillColor.greenComponent(),
                contourFillColor.blueComponent(),
                contourFillColor.alphaComponent() * 0.6
            )
            componentFillColor = NSColor.colorWithCalibratedRed_green_blue_alpha_(
                componentFillColor.redComponent(),
                componentFillColor.greenComponent(),
                componentFillColor.blueComponent(),
                componentFillColor.alphaComponent() * 0.6
            )
        # components
        componentFillColor.set()
        componentPath.fill()
        # contours
        contourFillColor.set()
        contourPath.fill()
    # stroke
    if drawStroke:
        # work out the color
        if contourStrokeColor is None and layerColor is not None:
            contourStrokeColor = layerColor
        elif contourStrokeColor is None and layerColor is None:
            contourStrokeColor = getDefaultColor("glyphContourStroke")
        # contours
        contourPath.setLineWidth_(contourStrokeWidth * scale)
        contourStrokeColor.set()
        contourPath.stroke()
Exemplo n.º 44
0
def drawline(x1, y1, x2, y2, colour, strokewidth, dashed):

    NSColor.colorWithDeviceCyan_magenta_yellow_black_alpha_(
        colour[0], colour[1], colour[2], colour[3], 1).set()
    Path = NSBezierPath.bezierPath()
    Path.moveToPoint_((x1, y1))
    Path.lineToPoint_((x2, y2))
    Path.setLineWidth_(strokewidth)

    if dashed:
        Path.setLineDash_count_phase_(dashed, 2, 0.0)
    Path.stroke()
Exemplo n.º 45
0
def drawrect(x1, y1, x2, y2, fillcolour, strokecolour, strokewidth, dashed, rounded):
	Rect = NSMakeRect(x1, y1, x2 - x1, y2 - y1)
	Path = NSBezierPath.bezierPathWithRoundedRect_xRadius_yRadius_(Rect, rounded, rounded)
	if fillcolour:
		NSColor.colorWithDeviceCyan_magenta_yellow_black_alpha_(fillcolour[0], fillcolour[1], fillcolour[2], fillcolour[3], 1).set()
		Path.fill()
	if strokecolour:
		Path.setLineWidth_(strokewidth)
		if dashed:
			Path.setLineDash_count_phase_(dashed, 2, 0.0)
		NSColor.colorWithDeviceCyan_magenta_yellow_black_alpha_(strokecolour[0], strokecolour[1], strokecolour[2], strokecolour[3], 1).set()
		Path.stroke()
Exemplo n.º 46
0
def fill(r=None, g=None, b=None, a=1):
	# Set the fill color as RGB value.
	global currentFillColor
	global currentGradient
	if r is None:
		currentFillColor = None
	elif g is None:
		currentFillColor = NSColor.colorWithDeviceWhite_alpha_(r, a)
		currentGradient = None
	else:
		currentFillColor = NSColor.colorWithDeviceRed_green_blue_alpha_(r, g, b, a)
		currentGradient = None
Exemplo n.º 47
0
def linearGradient(startPoint=None,
                   endPoint=None,
                   colors=None,
                   locations=None):
    global currentGradient
    global currentFillColor
    if colors is None:
        colors = [NSColor.greenColor(), NSColor.redColor()]
    if locations is None:
        locations = [i / float(len(colors) - 1) for i in range(len(colors))]
    currentGradient = ("linear", startPoint, endPoint, colors, locations)
    currentFillColor = None
Exemplo n.º 48
0
 def applicationDidFinishLaunching_(self, aNotification):
     d = {'StderrColor': NSArchiver.archivedDataWithRootObject_(NSColor.redColor()),
          'StdoutColor': NSArchiver.archivedDataWithRootObject_(NSColor.blueColor()),
          'CodeColor': NSArchiver.archivedDataWithRootObject_(NSColor.blackColor()),
          }
     defaults = NSUserDefaults.standardUserDefaults()
     defaults.registerDefaults_(d)
     self.textView.setFont_(self.font())
     self._stderrColor = NSUnarchiver.unarchiveObjectWithData_(defaults['StderrColor'])
     self._stdoutColor = NSUnarchiver.unarchiveObjectWithData_(defaults['StdoutColor'])
     self._codeColor = NSUnarchiver.unarchiveObjectWithData_(defaults['CodeColor'])
     self._executeWithRedirectedIO_args_kwds_(self._interp, (), {})
Exemplo n.º 49
0
def setDarkMode(w, darkMode):
    if darkMode:
        appearance = NSAppearance.appearanceNamed_('NSAppearanceNameVibrantDark')
        if hasattr(w, "accordionView"):
            w.accordionView.setBackgroundColor(NSColor.colorWithCalibratedRed_green_blue_alpha_(.08, .08, .08, 1))
    else:
        appearance = NSAppearance.appearanceNamed_('NSAppearanceNameAqua')
        if hasattr(w, "accordionView"):
            w.accordionView.setBackgroundColor(NSColor.colorWithCalibratedRed_green_blue_alpha_(1, 1, 1, 1))
    w.getNSWindow().setAppearance_(appearance)
    if CurrentGlyphWindow():
        CurrentGlyphWindow().window().getNSWindow().setAppearance_(appearance)
Exemplo n.º 50
0
 def __init__(self,
              posSize,
              pointSize=100,
              rightToLeft=False,
              applyKerning=False,
              glyphColor=None,
              backgroundColor=None,
              alternateHighlightColor=None,
              autohideScrollers=True,
              showPointSizePlacard=False):
     if glyphColor is None:
         glyphColor = NSColor.colorWithCalibratedRed_green_blue_alpha_(
             0, 0, 0, 1)
     if backgroundColor is None:
         backgroundColor = NSColor.whiteColor()
     if alternateHighlightColor is None:
         alternateHighlightColor = defaultAlternateHighlightColor
     self._applyKerning = applyKerning
     self._glyphLineView = self.glyphLineViewClass.alloc().init()
     self._glyphLineView.setPointSize_(pointSize)
     self._glyphLineView.setRightToLeft_(rightToLeft)
     self._glyphLineView.setGlyphColor_(glyphColor)
     self._glyphLineView.setBackgroundColor_(backgroundColor)
     self._glyphLineView.setAlternateHighlightColor_(
         alternateHighlightColor)
     self._glyphLineView.vanillaWrapper = weakref.ref(self)
     # don't autohide if the placard is to be visible.
     # bad things will happen if this is not the case.
     if showPointSizePlacard:
         autohideScrollers = False
     # setup the scroll view
     super(GlyphLineView,
           self).__init__(posSize,
                          self._glyphLineView,
                          autohidesScrollers=autohideScrollers,
                          backgroundColor=backgroundColor)
     # placard
     if showPointSizePlacard:
         self._pointSizes = ["Auto"] + [str(i) for i in pointSizes]
         placardW = 55
         placardH = 16
         self._placard = vanilla.Group((0, 0, placardW, placardH))
         self._placard.button = PlacardPopUpButton(
             (0, 0, placardW, placardH),
             self._pointSizes,
             callback=self._placardSelection,
             sizeStyle="mini")
         self.setPlacard(self._placard)
         pointSize = str(pointSize)
         if pointSize in self._pointSizes:
             index = self._pointSizes.index(pointSize)
             self._placard.button.set(index)
def drawGlyphIntoBackground(layer, info):

        # Due to internal Glyphs.app structure, we need to catch and print exceptions
        # of these callback functions with try/except like so:
        try:
        	# Your drawing code here
        	NSColor.yellowColor().set()
        	layer.background.bezierPath.fill()

        # Error. Print exception.
        except:
        	import traceback
        	print traceback.format_exc()
Exemplo n.º 52
0
def drawGlyphIntoBackground(layer, info):

    # Due to internal Glyphs.app structure, we need to catch and print exceptions
    # of these callback functions with try/except like so:
    try:
        # Your drawing code here
        NSColor.yellowColor().set()
        layer.background.bezierPath.fill()

    # Error. Print exception.
    except:
        import traceback
        print traceback.format_exc()
Exemplo n.º 53
0
	def drawRect_(self, rect):
		frame = self.frame()
		NSColor.whiteColor().set()
		NSRectFill(frame)
		try:
			if self._glyph is not None:
				if self._glyph.__class__.__name__ in ("NSKVONotifying_GSLayer", "GSLayer"):
					layer = self._glyph
				elif isinstance(self._glyph, RGlyph):
					layer = self._glyph._layer
				if layer:
					layer.drawInFrame_(frame)
		except:
			print traceback.format_exc()
Exemplo n.º 54
0
def DrawGlyph(f, glyph, PSCommands, xoffset, yoffset, ratio, fillcolour, strokecolour, strokewidth, dashed):
	if not PSCommands:
		layer = glyph.layers[0]
		p = layer.drawBezierPath
		transform = NSAffineTransform.new()
		transform.translateXBy_yBy_(xoffset*mm, yoffset*mm)
		transform.scaleBy_(ratio)
		p.transformUsingAffineTransform_(transform)
	else:
		p = NSBezierPath.bezierPath()
		
		for command in PSCommands:
		
			if command[0] == 'moveTo':
				try:
					p.close()
				except:
					pass
	
				x = xoffset*mm + command[1][0] * ratio
				y = yoffset*mm + command[1][1] * ratio
				p.moveToPoint_((x, y))
				#print "('moveTo', (%s, %s))," % (command[1][0], command[1][1])
	
			if command[0] == 'lineTo':
				x = xoffset*mm + command[1][0] * ratio
				y = yoffset*mm + command[1][1] * ratio
				p.lineToPoint_((x, y))
				#print "('lineTo', (%s, %s))," % (command[1][0], command[1][1])
	
			if command[0] == 'curveTo':
	
				points = []
				
				for point in command[1:]:
					points.append( (xoffset*mm + point[0] * ratio, yoffset*mm + point[1] * ratio) )
				
				p.curveToPoint_controlPoint1_controlPoint2_(points[0], points[1], points[2])
		p.closePath()
	
	if fillcolour:
		NSColor.colorWithDeviceCyan_magenta_yellow_black_alpha_(fillcolour[0], fillcolour[1], fillcolour[2], fillcolour[3], 1).set()
		p.fill()
	if strokecolour:
		NSColor.colorWithDeviceCyan_magenta_yellow_black_alpha_(strokecolour[0], strokecolour[1], strokecolour[2], strokecolour[3], 1).set()
		if dashed:
			p.setLineDash_count_phase_(dashed, 2, 0.0)
		p.setLineWidth_(strokewidth)
		p.stroke()
Exemplo n.º 55
0
def DrawTableLines(list, colour, thickness):
	
	global myDialog
	for i, point in enumerate(list):

		try:
			drawline(list[i][1]*mm, list[i][2]*mm, list[i+1][1]*mm, list[i+1][2]*mm, colour, thickness, None)
		except:
			pass

		NSColor.colorWithDeviceCyan_magenta_yellow_black_alpha_(colour[0], colour[1], colour[2], colour[3], 1).set()
		Rect = NSMakeRect(point[1]*mm-(thickness), point[2]*mm-(thickness), thickness*2, thickness*2)
		NSBezierPath.bezierPathWithOvalInRect_(Rect).fill()
		if Glyphs.boolDefaults["com_yanone_Autopsy_drawpointsvalues"]:
			DrawText(pdffont['Regular'], pointsvaluefontsize, glyphcolour, point[1]*mm + (thickness/6+1)*mm, point[2]*mm - (thickness/6+2.5)*mm, str(int(round(point[0]))))
Exemplo n.º 56
0
	def __init__(self, posSize, layer = None, backgroundColor = None):
		self._setupView(self.nsViewClass, posSize)
		self.layer = layer
		if backgroundColor != None:
			self.backgroundColor = backgroundColor
		else:
			self.backgroundColor = NSColor.whiteColor()
Exemplo n.º 57
0
 def __init__(self):
     self.w = FloatingWindow((self._width, self._height), self._title, closable=False)
     # left
     self.w.left_label = TextBox((self._padding, self._padding, -self._padding, 17), "left")
     self.w.left_mode = PopUpButton(
         (60, self._padding, self._column_1, 20), self._modes, callback=self.left_mode_callback
     )
     self.w.left_value = EditText((195, self._padding, -self._padding, 20), placeholder="set value")
     self.w.left_value.enable(False)
     # right
     self.w.right_label = TextBox((self._padding, 40, -self._padding, 17), "right")
     self.w.right_mode = PopUpButton((60, 40, self._column_1, 20), self._modes, callback=self.right_mode_callback)
     self.w.right_value = EditText((195, 40, -self._padding, 20), placeholder="set value")
     self.w.right_value.enable(False)
     # colors
     self.w.mark_checkbox = CheckBox((self._padding, 75, -170, 20), "mark glyphs", value=True)
     self.w.mark_color = ColorWell(
         (120, 75, -self._padding, 20), color=NSColor.colorWithCalibratedRed_green_blue_alpha_(*self._mark_color)
     )
     # buttons
     self.w.button_apply = Button(
         (self._padding, -35, (self._width / 2) - self._padding, 20), "apply", callback=self.apply_callback
     )
     self.w.button_close = Button(
         ((self._width / 2) + self._padding, -35, -self._padding, 20), "close", callback=self.close_callback
     )
     # open window
     self.w.setDefaultButton(self.w.button_apply)
     self.w.button_close.bind(".", ["command"])
     self.w.button_close.bind(unichr(27), [])
     self.w.open()
Exemplo n.º 58
0
 def __init__(self):
     self.doMarkGlyphs = 0
     self.doOverwrite = 1
     self.sourceFontList = AllFonts()
     self.destinationFontList = AllFonts()
     self.source_font = self.sourceFontList[0]
     self.destination_fonts = None
     self.glyphs = None
     self.mark = NSColor.redColor()
     
     ## create a window
     self.w = Window((700, 500), "Copy Glyphs", minSize=(700, 500))
     self.w.sourceTitle = TextBox((15, 20, 200, 20), "Source Font:")
     self.w.sourceFont = PopUpButton((15, 42, -410, 20), [f.info.familyName + ' ' + f.info.styleName for f in self.sourceFontList], callback=self.sourceCallback)
     self.w.glyphs = GlyphCollectionView((16, 70, -410, -65), initialMode="list", enableDelete=False, allowDrag=False, selectionCallback=self.glyphCallback)
     self._sortGlyphs(self.source_font)
     self.w.desTitle = TextBox((-400, 20, 200, 20), "Destination Fonts:")
     self.w.destinationFonts = FontList((-400, 42, -15, -115), self.destinationFontList, selectionCallback=self.desCallback)
     self.w.overwrite = CheckBox((-395, -105, 130, 22), "Overwrite glyphs", callback=self.overwriteCallback, value=self.doOverwrite)
     self.w.markGlyphs = CheckBox((-395, -84, 100, 22), "Mark Glyphs", callback=self.markCallback, value=self.doMarkGlyphs)
     self.w.copyButton = Button((-115, -40, 100, 20), 'Copy Glyphs', callback=self.copyCallback)
     self.w.line = HorizontalLine((10, -50, -10, 1))
     self._updateDest()
     ## open the window
     self.w.open()
Exemplo n.º 59
0
 def _getColor(self, key, fallback):
     if key not in self._values:
         color = getExtensionDefaultColor(key)
         if color is None:
             color = NSColor.colorWithCalibratedRed_green_blue_alpha_(*fallback)
         self._values[key] = color
     return self._values[key]
Exemplo n.º 60
0
def openSplash():
    global splash
    splash = NSWindow.alloc()
    rect = NSMakeRect(0,0,240,420)
    styleMask = 0
    splash.initWithContentRect_styleMask_backing_defer_(rect, styleMask, NSBackingStoreBuffered, False)

    # http://stackoverflow.com/questions/19437580/splash-screen-in-osx-cocoa-app

    splashImage = NSImageView.alloc().initWithFrame_(rect)
    splashImage.setImageScaling_(NSScaleToFit)
    splashImage.setImage_(NSImage.imageNamed_('ottosplash.png'))
    #[customView addSubview:splashImage];

    #splash.setContentView_(webview)
    splash.setContentView_(splashImage)
    splash.setHasShadow_(True)
    splash.setOpaque_(False)
    splash.setBackgroundColor_(NSColor.clearColor())

    # xPos = NSWidth([[splashWindow screen] frame])/2 - NSWidth([splashWindow frame])/2;
    #CGFloat yPos = NSHeight([[splashWindow screen] frame])/2 - NSHeight([splashWindow frame])/2;
    #[splashWindow setFrame:NSMakeRect(xPos, yPos, NSWidth([splashWindow frame]), NSHeight([splashWindow frame])) display:YES];
    splash.center()
    splash.orderFrontRegardless()