def drawRect_(self, rect): if self.inLiveResize(): self._recalcSize() from random import random NSColor.redColor().set() NSRectFill(self.bounds()) width, height = self.frame()[1] w = width / 5 h = height / 5 for xI in range(5): for yI in range(5): x = xI * w y = height - (yI * h) - h r = ((x, y), (w, h)) NSColor.colorWithDeviceRed_green_blue_alpha_(random(), random(), random(), 1.0).set() NSRectFill(r)
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()
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()
def drawBackground(self): if "glyphViewBackgroundColor" in self._theme: self._backgroundColor = drawing.colorToNSColor( self._theme["glyphViewBackgroundColor"]) else: self._backgroundColor = NSColor.whiteColor() self._backgroundColor.set() NSRectFill(self.bounds())
def drawRect_(self, rect): try: bounds = self.bounds() if self._backgroundColor != None: self._backgroundColor.set() NSRectFill(bounds) self._layer.drawInFrame_(bounds) except: print traceback.format_exc()
def drawRect_(self, rect): VerticalBoxView.drawRect_(self, rect) if self.alternateRows: i = 0 NSColor.colorWithCalibratedRed_green_blue_alpha_( 237 / 256.0, 243 / 256.0, 254 / 256.0, 1.0).set() for v in self.subviews(): if i % 2 == 1: NSRectFill(v.frame()) i += 1 if self.selection != -1 and self.selection < self.subviews().count(): if self.window().isKeyWindow(): NSColor.alternateSelectedControlColor().set() else: NSColor.lightGrayColor().set() NSRectFill(self.subviews()[self.selection].frame())
def drawRect_(self, rect): try: if self._backgroundColor is not None: self._backgroundColor.set() NSRectFill(rect) if self._delegate != None: self._delegate.draw(self) except: print(traceback.format_exc())
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 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())
def drawUnderline(self, layer, options): try: if Glyphs.boolDefaults["GeorgSeifert_showUnderline"]: master = layer.associatedFontMaster() thinkness = master.customParameters["underlineThickness"] position = master.customParameters["underlinePosition"] if thinkness != None and position != None: thinkness = float(thinkness) position = float(position) rect = NSMakeRect(0, position - (thinkness * 0.5), layer.width, thinkness) NSColor.colorWithDeviceRed_green_blue_alpha_( 64.0 / 255.0, 79.0 / 255.0, 104.0 / 255.0, 1).set() NSRectFill(rect) except: NSLog(traceback.format_exc())
def drawCellHeaderBackground(self, rect): (xMin, yMin), (width, height) = rect # background try: gradient = NSGradient.alloc().initWithColors_( [cellHeaderHighlightColor, cellHeaderBaseColor]) gradient.drawInRect_angle_(rect, 90) except NameError: cellHeaderBaseColor.set() NSRectFill(rect) # bottom line cellHeaderLineColor.set() bottomPath = NSBezierPath.bezierPath() bottomPath.moveToPoint_((xMin, yMin + height - .5)) bottomPath.lineToPoint_((xMin + width, yMin + height - .5)) bottomPath.setLineWidth_(1.0) bottomPath.stroke()
def drawRect_(self, rect): try: NSColor.whiteColor().set() NSRectFill(self.bounds()) NSColor.blackColor().setFill() p = NSBezierPath.bezierPath() xcursor = 0 ycursor = 0 for i, g in enumerate(self.glyphs): layer = g.layers[0] if i > 0: # Do anchor correction here prevlayer = self.glyphs[i - 1].layers[0] entry = prevlayer.anchors["entry"] exit = layer.anchors["exit"] if entry and exit: diffX = entry.position.x - exit.position.x diffY = entry.position.y - exit.position.y xcursor = xcursor + diffX ycursor = ycursor + diffY else: NSColor.redColor().setFill() else: xcursor = xcursor - layer.bounds.origin.x thisPath = NSBezierPath.bezierPath() thisPath.appendBezierPath_(layer.completeBezierPath) t = NSAffineTransform.transform() t.translateXBy_yBy_(xcursor, -layer.master.descender + ycursor) thisPath.transformUsingAffineTransform_(t) p.appendBezierPath_(thisPath) t = NSAffineTransform.transform() if xcursor > 0: master = self.glyphs[0].layers[0].master 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 Exception as e: print("Oops!", sys.exc_info()[0], "occured.") traceback.print_exc(file=sys.stdout)
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)
def drawBorderAndBackgroundWithFrame_inView_(self, frame, view): # draw background try: gradient = NSGradient.alloc().initWithColors_([placardGradientColor1, placardGradientColor2]) gradient.drawInRect_angle_(frame, 90) except NameError: placardGradientColorFallback.set() NSRectFill(frame) # draw border (x, y), (w, h) = frame path = NSBezierPath.bezierPath() path.moveToPoint_((x + w - .5, h)) path.lineToPoint_((x + w - .5, .5)) path.lineToPoint_((x, .5)) path.setLineWidth_(1.0) NSColor.colorWithCalibratedWhite_alpha_(.5, .7).set() path.stroke() # let the super do the rest w -= 1 if inOS104: w -= 4 frame = ((x, y), (w, h)) super(DefconAppKitPlacardNSPopUpButtonCell, self).drawBorderAndBackgroundWithFrame_inView_(frame, view)
def drawWithFrame_inView_(self, frame, view): # draw background try: gradient = NSGradient.alloc().initWithColors_([placardGradientColor1, placardGradientColor2]) gradient.drawInRect_angle_(frame, 90) except NameError: placardGradientColorFallback.set() NSRectFill(frame) # draw border (x, y), (w, h) = frame path = NSBezierPath.bezierPath() path.moveToPoint_((x + w - .5, h)) path.lineToPoint_((x + w - .5, .5)) path.lineToPoint_((x, .5)) path.setLineWidth_(1.0) placardBorderColor.set() path.stroke() # draw segments x, y = frame.origin h = frame.size[1] for index in range(self.segmentCount()): w = self.widthForSegment_(index) self.drawSegment_inFrame_withView_(index, ((x, y), (w, h)), view) x += w
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())
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()
def drawRect_(self, rect): HUDWindowLineColor.set() NSRectFill(rect)
def drawRect_(self, rect): if self.background_color: self.background_color.set() NSRectFill(rect)
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()
def drawBackground(self): self._backgroundColor.set() NSRectFill(self.bounds())