def drawWithFrame_inView_(self, frame, view):
if hasattr(self, '_path'):
if not hasattr(self, '_image'):
self._image = self._callbackTarget.imageForPath_(self._path)
self.setTitle_(self._callbackTarget.titleForPath_(self._path))
self._checkCell.setIntValue_(self._callbackTarget.stateForPath_(self._path))
x = frame.origin.x
y = frame.origin.y + 1
height = frame.size.height - 1
if self.state() or self.isHighlighted():
highlight_rect = NSMakeRect(x, y, frame.size.width, height)
if view.needsToDrawRect_(highlight_rect):
self.highlightColorInView_(view).set()
NSBezierPath.bezierPathWithRect_(highlight_rect).fill()
x += CHECK_CELL_LEFT_PADDING
checkCellSize = self._checkCell.cellSize()
check_cell_rect = NSMakeRect(x, y, checkCellSize.width, height)
if view.needsToDrawRect_(check_cell_rect):
self._checkCell.drawWithFrame_inView_(check_cell_rect, view)
x += checkCellSize.width - 1
imageSize = self._image.size()
image_rect = NSMakeRect(x, y, imageSize.width, imageSize.height)
if view.needsToDrawRect_(image_rect):
self._image.drawInRect_fromRect_operation_fraction_(image_rect, NSZeroRect, NSCompositeSourceOver, 1.0)
x += imageSize.width + 4
rest_of_cell_rect = NSMakeRect(x, y, frame.size.width - x, height)
if view.needsToDrawRect_(rest_of_cell_rect):
super(SelectiveSyncBrowserCell, self).drawWithFrame_inView_(rest_of_cell_rect, view)
else:
super(SelectiveSyncBrowserCell, self).drawWithFrame_inView_(frame, view)
def draw(self, scale):
controlSoftColor = self.controlSoftColor
controlStrongColor = self.controlStrongColor
if self._roundedGlyph is not None:
self._roundedGlyph.drawPreview(scale,
styleFill=False,
showNodes=False,
strokeWidth=2,
strokeColor=controlStrongColor)
for point in self.roundablePoints:
x, y = point.x, point.y
(cx, cy), r = self.getControlPoint(point)
controlSoftColor.set()
controlStrongColor.setStroke()
radiusCircle = NSBezierPath.bezierPathWithOvalInRect_(
((x - r, y - r), (r * 2, r * 2)))
radiusCircle.fill()
radiusCircle.setLineWidth_(scale)
radiusCircle.stroke()
controlStrongColor.set()
cor = 12 * scale
controlDot = NSBezierPath.bezierPathWithOvalInRect_(
((cx - cor, cy - cor), (cor * 2, cor * 2)))
controlDot.fill()
if point.labels['cornerRadius']:
fill(1)
fontSize(9 * scale)
_r = str(r)
textBox(_r, (cx - cor, cy - (cor * 1.5), cor * 2, cor * 2),
align='center')
def draw(self, scale):
controlSoftColor = self.controlSoftColor
controlStrongColor = self.controlStrongColor
if self._roundedGlyph is not None:
self._roundedGlyph.drawPreview(
scale, styleFill=False, showNodes=False, strokeWidth=2, strokeColor=controlStrongColor
)
for point in self.roundablePoints:
x, y = point.x, point.y
(cx, cy), r = self.getControlPoint(point)
controlSoftColor.set()
controlStrongColor.setStroke()
radiusCircle = NSBezierPath.bezierPathWithOvalInRect_(((x - r, y - r), (r * 2, r * 2)))
radiusCircle.fill()
radiusCircle.setLineWidth_(scale)
radiusCircle.stroke()
controlStrongColor.set()
cor = 12 * scale
controlDot = NSBezierPath.bezierPathWithOvalInRect_(((cx - cor, cy - cor), (cor * 2, cor * 2)))
controlDot.fill()
if point.labels["cornerRadius"]:
fill(1)
fontSize(9 * scale)
_r = str(r)
textBox(_r, (cx - cor, cy - (cor * 1.5), cor * 2, cor * 2), align="center")
def drawPoints(self, glyph, scale):
save()
_onCurveSize = self._onCurvePointsSize * scale
_offCurveSize = self._offCurvePointsSize * scale
_strokeWidth = self._strokeWidth * scale
self._pointsColor.set()
path = NSBezierPath.bezierPath()
offCurveHandlesPath = NSBezierPath.bezierPath()
pointsData = glyph.getRepresentation("doodle.OutlineInformation")
for point1, point2 in pointsData["bezierHandles"]:
offCurveHandlesPath.moveToPoint_(point1)
offCurveHandlesPath.lineToPoint_(point2)
for point in pointsData.get("offCurvePoints"):
(x, y) = point["point"]
path.appendBezierPathWithOvalInRect_(NSMakeRect(x - _offCurveSize, y - _offCurveSize, _offCurveSize * 2, _offCurveSize * 2))
for point in pointsData.get("onCurvePoints"):
(x, y) = point["point"]
path.appendBezierPathWithRect_(NSMakeRect(x - _onCurveSize, y - _onCurveSize, _onCurveSize * 2, _onCurveSize * 2))
path.fill()
offCurveHandlesPath.setLineWidth_(_strokeWidth)
strokePixelPath(offCurveHandlesPath)
restore()
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
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):
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):
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())
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)
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()
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 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]))))
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 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)))
def _ns_arc_path(self, c, r, sa, ea):
ns_path = NSBezierPath.bezierPath()
ns_path.setLineWidth_(self._pensize)
ns_path.\
appendBezierPathWithArcWithCenter_radius_startAngle_endAngle_(
c, r, sa, ea)
return ns_path
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 drawingCalculation(self, curvePoints, interpolFactor): color = self.w.colorFill.get() if len(curvePoints) != 0: path = NSBezierPath.bezierPath() path.setLineWidth_(int(self.w.strokeThickness.get()) / self.scale) for idx, pts in enumerate(curvePoints): if idx == 0: path.moveToPoint_((pts[0],pts[1])) else: path.lineToPoint_((pts[0],pts[1])) color.set() path.stroke() processedPoints = [] interpolatedPoints = [] for i, pts in enumerate(curvePoints): try: pt1 = (pts[0], pts[1]) pt2 = (curvePoints[i+1][0], curvePoints[i+1][1]) processedPoints.append(pt1) processedPoints.append(pt2) interpolatedPt = self.interpolatePoint(pt1, pt2, interpolFactor) interpolatedPoints.append(interpolatedPt) except IndexError: pass return interpolatedPoints return None
def _ns_arc_path(self, c, r, sa, ea):
ns_path = NSBezierPath.bezierPath()
ns_path.setLineWidth_(self._pensize)
ns_path.\
appendBezierPathWithArcWithCenter_radius_startAngle_endAngle_(
c, r, sa, ea)
return ns_path
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 drawIcon(foregroundColor, backgroundColor):
image = NSImage.alloc().initWithSize_((120, 11))
image.lockFocus()
foregroundColor.set()
path = NSBezierPath.bezierPath()
path.setLineWidth_(1.0)
# left
path.moveToPoint_((0, 5.5))
path.lineToPoint_((15, 5.5))
path.moveToPoint_((4, 8.5))
path.lineToPoint_((0, 5.5))
path.lineToPoint_((4, 2.5))
# right
path.moveToPoint_((120, 5.5))
path.lineToPoint_((105, 5.5))
path.moveToPoint_((114, 8.5))
path.lineToPoint_((120, 5.5))
path.lineToPoint_((114, 2.5))
# center
path.moveToPoint_((50, 5.5))
path.lineToPoint_((70, 5.5))
path.moveToPoint_((54, 8.5))
path.lineToPoint_((50, 5.5))
path.lineToPoint_((54, 2.5))
path.moveToPoint_((66, 8.5))
path.lineToPoint_((70, 5.5))
path.lineToPoint_((66, 2.5))
path.stroke()
image.unlockFocus()
return image
def __init__(self, glyphSet, path=None):
BasePen.__init__(self, glyphSet)
if path is None:
from AppKit import NSBezierPath
path = NSBezierPath.bezierPath()
self.path = path
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 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)))
def roundedRectBezierPath(rect, radius,
roundUpperLeft=True, roundUpperRight=True, roundLowerLeft=True, roundLowerRight=True,
closeTop=True, closeBottom=True, closeLeft=True, closeRight=True):
(rectLeft, rectBottom), (rectWidth, rectHeight) = rect
rectTop = rectBottom + rectHeight
rectRight = rectLeft + rectWidth
path = NSBezierPath.bezierPath()
if roundUpperLeft:
path.moveToPoint_((rectLeft, rectHeight-radius))
path.appendBezierPathWithArcFromPoint_toPoint_radius_((rectLeft, rectTop), (rectLeft+radius, rectTop), radius)
else:
path.moveToPoint_((rectLeft, rectTop))
if roundUpperRight:
if closeTop:
path.lineToPoint_((rectRight-radius, rectTop))
else:
path.moveToPoint_((rectRight-radius, rectTop))
path.appendBezierPathWithArcFromPoint_toPoint_radius_((rectRight, rectTop), (rectRight, rectTop-radius), radius)
else:
if closeTop:
path.lineToPoint_((rectRight, rectTop))
else:
path.moveToPoint_((rectRight, rectTop))
if roundLowerRight:
if closeRight:
path.lineToPoint_((rectRight, rectBottom+radius))
else:
path.moveToPoint_((rectRight, rectBottom+radius))
path.appendBezierPathWithArcFromPoint_toPoint_radius_((rectRight, rectBottom), (rectRight-radius, rectBottom), radius)
else:
if closeRight:
path.lineToPoint_((rectRight, rectBottom))
else:
path.moveToPoint_((rectRight, rectBottom))
if roundLowerLeft:
if closeBottom:
path.lineToPoint_((rectLeft+radius, rectBottom))
else:
path.moveToPoint_((rectLeft+radius, rectBottom))
path.appendBezierPathWithArcFromPoint_toPoint_radius_((rectLeft, rectBottom), (rectLeft, rectBottom+radius), radius)
else:
if closeBottom:
path.lineToPoint_((rectLeft, rectBottom))
else:
path.moveToPoint_((rectLeft, rectBottom))
if closeLeft:
if roundUpperLeft:
path.lineToPoint_((rectLeft, rectHeight-radius))
else:
path.lineToPoint_((rectLeft, rectTop))
return path
def drawGlyph(pen, glyph):
save()
stroke(None)
fill(0)
pen.path = NSBezierPath.bezierPath()
glyph.draw(pen)
drawPath(pen.path)
restore()
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 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 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 line(x1, y1, x2=None, y2=None): # draws a line if x2 is None and y2 is None and isinstance(x1, tuple) and isinstance(y1, tuple): (x1, y1), (x2, y2) = x1, y1 p = NSBezierPath.bezierPath() p.moveToPoint_(NSMakePoint(x1, y1)) p.lineToPoint_(NSMakePoint(x2, y2)) drawPath(p)
def draw(self, rect):
#NSColor.redColor().set()
yellowColor.set()
for n in range(50):
rgba(random(), random(), random())
rect = NSMakeRect(n * 400 + M, n * 400 + M, M, M)
path = NSBezierPath.bezierPathWithRect_(rect)
path.fill()
def __init__(self):
self._ns_path = NSBezierPath.bezierPath()
self._ns_path.setWindingRule_(NSEvenOddWindingRule)
self._stack = []
ctx = NSGraphicsContext.currentContext()
ctx.setCompositingOperation_(NSCompositeSourceOver)
GCanvas.__init__(self)
self._printing = not ctx.isDrawingToScreen()
self.initgraphics()
def line(x1, y1, x2=None, y2=None):
# draws a line
if x2 is None and y2 is None and isinstance(x1, tuple) and isinstance(
y1, tuple):
(x1, y1), (x2, y2) = x1, y1
p = NSBezierPath.bezierPath()
p.moveToPoint_(NSMakePoint(x1, y1))
p.lineToPoint_(NSMakePoint(x2, y2))
drawPath(p)
def addGlyph(self, glyph): BezierPath = glyph._layer.bezierPath() if BezierPath != None: BezierPath = BezierPath.copy() else: BezierPath = NSBezierPath.bezierPath() for currComponent in glyph._layer.components: BezierPath.appendBezierPath_(currComponent.bezierPath()) self.getNSBezierPath().appendBezierPath_(BezierPath)
def addGlyph(self, glyph): BezierPath = glyph._layer.bezierPath() if BezierPath != None: BezierPath = BezierPath.copy() else: BezierPath = NSBezierPath.bezierPath() for currComponent in glyph._layer.components: BezierPath.appendBezierPath_(currComponent.bezierPath()) self.getNSBezierPath().appendBezierPath_(BezierPath)
def __init__(self):
self._ns_path = NSBezierPath.bezierPath()
self._ns_path.setWindingRule_(NSEvenOddWindingRule)
self._stack = []
ctx = NSGraphicsContext.currentContext()
ctx.setCompositingOperation_(NSCompositeSourceOver)
GCanvas.__init__(self)
self._printing = not ctx.isDrawingToScreen()
self.initgraphics()
def drawOutline(pen, glyph, color, s):
save()
strokeWidth(1 / s)
stroke(*color)
fill(None)
pen.path = NSBezierPath.bezierPath()
glyph.draw(pen)
drawPath(pen.path)
restore()
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(self, scale):
if self.isDragging() and self.pStart and self.pEnd:
r = self.getMarqueRect()
if r:
color = getDefaultColor('glyphViewSelectionMarqueColor')
color.set()
path = NSBezierPath.bezierPathWithRect_(r)
path.fill()
return
self.drawSelection(scale)
def draw(self, scale):
if self.isDragging() and self.pStart and self.pEnd:
r = self.getMarqueRect()
if r:
color = getDefaultColor('glyphViewSelectionMarqueColor')
color.set()
path = NSBezierPath.bezierPathWithRect_(r)
path.fill()
return
self.drawSelection(scale)
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 drawWithFrame_inView_(self, frame, view):
frame.origin.x -= 1
frame.size.width += 2
frame.origin.y -= 2
frame.size.height += 2
textFrame = NSInsetRect(frame, 2, 2)
text = self.objectValue()
color = getColorDefault("PyDEBackgroundColor", fallbackBackgroundColor)
color.set()
NSBezierPath.bezierPathWithRect_(frame).fill()
if self.isHighlighted():
frame.origin.y += 1
frame.size.height -= 1
color = getColorDefault("PyDEHightLightColor", fallbackHightLightColor)
color.set()
NSBezierPath.bezierPathWithRect_(frame).fill()
text.drawInRect_(textFrame)
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())
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()
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()
def draw_bbox(x1, y1, x2, y2, x3, y3, x4, y4, outline=False):
path = NSBezierPath.bezierPath()
path.moveToPoint_((x1, y1))
path.lineToPoint_((x2, y2))
path.lineToPoint_((x3, y3))
path.lineToPoint_((x4, y4))
path.lineToPoint_((x1, y1))
if not outline:
path.fill()
else:
path.setLineWidth_(30)
path.stroke()
def drawGlyph(glyph): BezierPath = glyph._layer.bezierPath() if BezierPath != None: BezierPath = BezierPath.copy() else: BezierPath = NSBezierPath.bezierPath() OpenBezierPath = glyph._layer.openBezierPath() if OpenBezierPath: BezierPath.appendBezierPath_(OpenBezierPath) for currComponent in glyph._layer.components: BezierPath.appendBezierPath_(currComponent.bezierPath()) _drawBotDrawingTool.drawPath(BezierPath)
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()
def drawGlyph(glyph): BezierPath = glyph._layer.bezierPath if BezierPath != None: BezierPath = BezierPath.copy() else: BezierPath = NSBezierPath.bezierPath() OpenBezierPath = glyph._layer.openBezierPath if OpenBezierPath: BezierPath.appendBezierPath_(OpenBezierPath) for currComponent in glyph._layer.components: BezierPath.appendBezierPath_(currComponent.bezierPath) _drawBotDrawingTool.drawPath(BezierPath)
def extensionIconPlaceholder(self):
width = 200
height = 200
image = NSImage.alloc().initWithSize_((width, height))
image.lockFocus()
path = NSBezierPath.bezierPathWithOvalInRect_(
((0, 0), (width, height)))
color1 = NSColor.disabledControlTextColor()
color1.set()
path.fill()
image.unlockFocus()
return image
def drawCellHorizontalMetrics(self, rect):
(xMin, yMin), (width, height) = rect
font = self.font
scale = self.scale
yOffset = self.yOffset
path = NSBezierPath.bezierPath()
lines = set((0, font.info.descender, font.info.xHeight, font.info.capHeight, font.info.ascender))
for y in lines:
y = round((y * scale) + yMin + yOffset) - .5
path.moveToPoint_((xMin, y))
path.lineToPoint_((xMin + width, y))
cellMetricsLineColor.set()
path.setLineWidth_(1.0)
path.stroke()
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 animateOneFrame(self):
# choose a random point.
(x, y), (fw, fh) = self.frame()
x, y = randrange(0.0, fw), randrange(0.0, fw)
ballSize = randrange(10.0, 90.0)
path = NSBezierPath.bezierPathWithOvalInRect_(((x, y), (ballSize, ballSize)))
# make a random color.
randomColor = NSColor.colorWithCalibratedRed_green_blue_alpha_(random(), random(), random(), random())
# set it.
randomColor.set()
# draw a new ball.
path.fill()
def __init__(self, dimensions):
super(DashedRectangle, self).__init__(dimensions, scale="none")
box_width = self.getPosSize()[2]
box_height = self.getPosSize()[3]
line_image = NSImage.alloc().initWithSize_((box_width, box_height))
line_image.lockFocus()
path = NSBezierPath.bezierPathWithRoundedRect_xRadius_yRadius_(NSMakeRect(.5, .5, box_width - 1, box_height - 1), 5, 5)
path.setLineWidth_(1.0)
path.setLineDash_count_phase_((5, 5), 2, 0)
NSColor.colorWithCalibratedWhite_alpha_(0, 0.1).set()
path.stroke()
line_image.unlockFocus()
self.setImage(imageObject=line_image)
def getGraph(self):
path = NSBezierPath.bezierPath()
maxMag = 0
mag = self.fieldValue(0)
maxMag = max(maxMag, mag)
path.moveToPoint_(polarToRect((mag, 0)))
for deg in range(1, 359, 1):
r = (deg/180.0)*pi
mag = self.fieldValue(r)
maxMag = max(maxMag, mag)
path.lineToPoint_(polarToRect((mag, r)))
path.closePath()
return path, maxMag;
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 drawLine(xy1, xy2, lineWidth=1.0):
x1, y1 = xy1
x2, y2 = xy2
turnOffAntiAliasing = False
if x1 == x2 or y1 == y2:
turnOffAntiAliasing = True
if turnOffAntiAliasing:
context = NSGraphicsContext.currentContext()
context.setShouldAntialias_(False)
path = NSBezierPath.bezierPath()
path.moveToPoint_((x1, y1))
path.lineToPoint_((x2, y2))
if turnOffAntiAliasing and lineWidth == 1.0:
lineWidth = 0.001
path.setLineWidth_(lineWidth)
path.stroke()
if turnOffAntiAliasing:
context.setShouldAntialias_(True)
def _drawTextLabel(self, transform, text, size, vector):
if vector is None:
vector = (-1, 1)
angle = atan2(vector[0], -vector[1])
text_size = 0.5 * size
#para_style = NSMutableParagraphStyle.alloc().init()
#para_style.setAlignment_(NSCenterTextAlignment)
attrs = {
NSFontAttributeName: NSFont.systemFontOfSize_(text_size),
NSForegroundColorAttributeName: NSColor.colorWithCalibratedRed_green_blue_alpha_( 0.4, 0.4, 0.6, 0.7 ),
#NSParagraphStyleAttributeName: para_style,
}
myString = NSString.string().stringByAppendingString_(text)
bbox = myString.sizeWithAttributes_(attrs)
bw = bbox.width
bh = bbox.height
text_pt = NSPoint()
text_pt.y = 0
if -0.5 * pi < angle <= 0.5 * pi:
text_pt.x = -1.3 * size - bw / 2 * cos(angle) - bh / 2 * sin(angle)
else:
text_pt.x = -1.3 * size + bw / 2 * cos(angle) + bh / 2 * sin(angle)
text_pt = transform.transformPoint_(text_pt)
rr = NSRect(
origin = (text_pt.x - bw / 2, text_pt.y - bh / 2),
size = (bw, bh)
)
if DEBUG:
NSColor.colorWithCalibratedRed_green_blue_alpha_( 0, 0, 0, 0.15 ).set()
myRect = NSBezierPath.bezierPathWithRect_(rr)
myRect.setLineWidth_(0.05 * size)
myRect.stroke()
myString.drawInRect_withAttributes_(
rr,
attrs
)
