def init(self, wizard): self = super(SetupWizardWindow, self).initWithContentRect_styleMask_backing_defer_(NSRect((0, 0), (580, 500)), NSTitledWindowMask | NSClosableWindowMask, NSBackingStoreBuffered, NO) if self is not None: self._wizard = wizard self._dropbox_app = wizard.dropbox_app self.setReleasedWhenClosed_(NO) self.center() self.setLevel_(NSFloatingWindowLevel) self._system_font = NSFont.systemFontOfSize_(NSFont.systemFontSizeForControlSize_(NSRegularControlSize)) self._small_system_font = NSFont.systemFontOfSize_(NSFont.systemFontSizeForControlSize_(NSSmallControlSize)) self.setTitle_(SetupWizardStrings.window_title) self._renderers = {Button: self._create_button, CenteredMultiControlLine: self._create_centered_multi_control_line, Checkbox: self._create_checkbox, Choice: self._create_choice, CreditCardType: self._create_credit_card_type, Date: self._create_date, ExampleText: self._create_example_text, FancyRadioGroup: self._create_fancy_radio_group, FlagChoice: self._create_flag_choice, HelpButton: self._create_help_button, Image: self._create_image, LocationChanger: self._create_location_changer, MultiControlLine: self._create_multi_control_line, MultiControlLineSimple: self._create_multi_control_line, TextBlock: self._create_text_block, TextInput: self._create_text_input, PlanChoices: self._create_plan_choices, RadioGroup: self._create_radio_group, SelectiveSync: self._create_selective_sync, Spacer: self._create_spacer} self._buttons = {} return self
def drawFontVerticalMetrics(glyph, scale, rect, drawLines=True, drawText=True, color=None, backgroundColor=None, flipped=False): font = glyph.font if font is None: return if color is None: color = getDefaultColor("fontVerticalMetrics") if backgroundColor is None: backgroundColor = getDefaultColor("background") color.set() # gather y positions toDraw = ( ("Descender", "descender"), ("X Height", "xHeight"), ("Cap Height", "capHeight"), ("Ascender", "ascender") ) toDraw = [(name, getattr(font.info, attr)) for name, attr in toDraw if getattr(font.info, attr) is not None] toDraw.append(("Baseline", 0)) positions = {} for name, position in toDraw: if position not in positions: positions[position] = [] positions[position].append(name) # create lines xMin = rect[0][0] xMax = xMin + rect[1][0] lines = [] for y, names in sorted(positions.items()): names = ", ".join(names) lines.append(((xMin, y), (xMax, y), names)) # draw lines if drawLines: lineWidth = 1.0 * scale for pt1, pt2, names in lines: drawLine(pt1, pt2, lineWidth=lineWidth) # draw text if drawText: fontSize = 9 shadow = NSShadow.shadow() shadow.setShadowColor_(backgroundColor) shadow.setShadowBlurRadius_(5) shadow.setShadowOffset_((0, 0)) attributes = { NSFontAttributeName: NSFont.systemFontOfSize_(fontSize), NSForegroundColorAttributeName: color } glowAttributes = { NSFontAttributeName: NSFont.systemFontOfSize_(fontSize), NSForegroundColorAttributeName: color, NSStrokeColorAttributeName: backgroundColor, NSStrokeWidthAttributeName: 25, NSShadowAttributeName: shadow } for pt1, pt2, names in lines: x, y = pt1 x += 5 * scale y -= (fontSize / 2.0) * scale drawTextAtPoint(names, (x, y), scale, glowAttributes, flipped=flipped) drawTextAtPoint(names, (x, y), scale, attributes, flipped=flipped)
def __init__(self, posSize, titles, isVertical=True, callback=None, sizeStyle="regular"): self._setupView(self.nsMatrixClass, posSize, callback=callback) self._isVertical = isVertical matrix = self._nsObject matrix.setMode_(NSRadioModeMatrix) matrix.setCellClass_(self.nsCellClass) # XXX! this does not work for vertical radio groups! matrix.setAutosizesCells_(True) # we handle the control size setting here # since the actual NS object is a NSMatrix cellSizeStyle = _sizeStyleMap[sizeStyle] font = NSFont.systemFontOfSize_(NSFont.systemFontSizeForControlSize_(cellSizeStyle)) # intercell spacing and cell spacing are based on the sizeStyle if sizeStyle == "regular": matrix.setIntercellSpacing_((4.0, 2.0)) matrix.setCellSize_((posSize[2], 18)) elif sizeStyle == "small": matrix.setIntercellSpacing_((3.5, 2.0)) matrix.setCellSize_((posSize[2], 15)) elif sizeStyle == "mini": matrix.setIntercellSpacing_((3.0, 2.0)) matrix.setCellSize_((posSize[2], 12)) else: raise ValueError("sizeStyle must be 'regular', 'small' or 'mini'") for _ in range(len(titles)): if isVertical: matrix.addRow() else: matrix.addColumn() for title, cell in zip(titles, matrix.cells()): cell.setButtonType_(NSRadioButton) cell.setTitle_(title) cell.setControlSize_(cellSizeStyle) cell.setFont_(font)
def _drawBackground(self, infoDict): assert self.elementShape in SHAPE_OPTIONS glyph = infoDict['glyph'] currentTool = getActiveEventTool() view = currentTool.getNSView() textAttributes = { NSFontAttributeName: NSFont.systemFontOfSize_(bodySizeCaption), NSForegroundColorAttributeName: NSColor.blackColor() } # load data if point is selected if PLUGIN_KEY in glyph.lib: for eachContour in glyph: for eachPt in eachContour.points: if eachPt.selected is True and eachPt.type != 'offCurve' and eachPt.naked( ).uniqueID in glyph.lib[PLUGIN_KEY]: self.loadDataFromLib(glyph, eachPt.naked().uniqueID) # draw interpolateValued ovals if self.preview is True and PLUGIN_KEY in glyph.lib: self._drawElements(glyph, SUB_COLOR, 4, 'canvas') # draw master ovals if self.preview is True and PLUGIN_KEY in glyph.lib: for eachContour in glyph: for eachSegment in eachContour: ID = eachSegment.onCurve.naked().uniqueID if ID in glyph.lib[PLUGIN_KEY]: elementDict = glyph.lib[PLUGIN_KEY][ID] save() fill(*MASTER_COLOR) translate(eachSegment.onCurve.x, eachSegment.onCurve.y) rotate(elementDict['angle']) if self.elementShape == 'Oval': oval(-elementDict['width'] / 2., -elementDict['height'] / 2., elementDict['width'], elementDict['height']) else: rect(-elementDict['width'] / 2., -elementDict['height'] / 2., elementDict['width'], elementDict['height']) restore() # draw values if self.drawValues is True and PLUGIN_KEY in glyph.lib: for eachContour in glyph: for eachSegment in eachContour: ID = eachSegment.onCurve.naked().uniqueID if ID in glyph.lib[PLUGIN_KEY]: nibData = glyph.lib[PLUGIN_KEY][ID] values = '%s: %s\n%s: %s\n%s: %s' % ( 'width', nibData['width'], 'height', nibData['height'], 'angle', nibData['angle']) view._drawTextAtPoint( values, textAttributes, (eachSegment.onCurve.x, eachSegment.onCurve.y), yOffset=2.8 * bodySizeCaption)
def __init__(self, posSize, title=None, fillColor=None, borderColor=None, borderWidth=None, cornerRadius=None): self._setupView(self.nsBoxClass, posSize) if title: self._nsObject.setTitle_(title) if osVersionCurrent < osVersion10_10: self._nsObject.titleCell().setTextColor_(NSColor.blackColor()) font = NSFont.systemFontOfSize_( NSFont.systemFontSizeForControlSize_(NSSmallControlSize)) self._nsObject.setTitleFont_(font) else: self._nsObject.setTitlePosition_(NSNoTitle) if fillColor is not None: self.setFillColor(fillColor) if borderColor is not None: self.setBorderColor(borderColor) if borderWidth is not None: self.setBorderWidth(borderWidth) if cornerRadius is not None: self.setCornerRadius(cornerRadius)
def __init__(self): GObject.GObject.__init__(self) self.props.margin = 0 self.props.spacing = 6 # On OSX, make the font slightly smaller for status bar try: from AppKit import NSFont from gi.repository import Pango system_font = NSFont.systemFontOfSize_(9) self.modify_font( Pango.FontDescription(system_font.displayName() + " 9")) except: pass hbox = self.get_message_area() label = hbox.get_children()[0] hbox.props.spacing = 6 label.props.ellipsize = Pango.EllipsizeMode.NONE hbox.remove(label) hbox.pack_end(label, False, True, 0) self.box_box = Gtk.HBox(homogeneous=False, spacing=6) self.pack_end(self.box_box, False, True, 0) self.box_box.pack_end(self.construct_line_display(), False, True, 0) self.box_box.pack_end(self.construct_highlighting_selector(), False, True, 0) self.box_box.pack_end(self.construct_encoding_selector(), False, True, 0) self.box_box.show_all()
def SmallTextListCell(editable=False): cell = NSTextFieldCell.alloc().init() size = NSSmallControlSize cell.setControlSize_(size) font = NSFont.systemFontOfSize_(NSFont.systemFontSizeForControlSize_(size)) cell.setFont_(font) cell.setEditable_(editable) return cell
def start(self): super(GlyphNameHUDControl, self).start() events.addObserver(self, "currentGlyphChangedCallback", "currentGlyphChanged") self.view.textBox = vanilla.TextBox((0, 0, 0, 0), "") textField = self.view.textBox.getNSTextField() font = NSFont.systemFontOfSize_(20) textField.setFont_(font) textField.setTextColor_(RoboHUDController().getForegroundColor())
def __init__(self, posSize, title=None): self._setupView(self.nsBoxClass, posSize) if title: self._nsObject.setTitle_(title) if osVersionCurrent < osVersion10_10: self._nsObject.titleCell().setTextColor_(NSColor.blackColor()) font = NSFont.systemFontOfSize_(NSFont.systemFontSizeForControlSize_(NSSmallControlSize)) self._nsObject.setTitleFont_(font) else: self._nsObject.setTitlePosition_(NSNoTitle)
def __init__(self, posSize, title=None): self._setupView(self.nsBoxClass, posSize) if title: self._nsObject.setTitle_(title) if osVersionCurrent < osVersion10_10: self._nsObject.titleCell().setTextColor_(NSColor.blackColor()) font = NSFont.systemFontOfSize_( NSFont.systemFontSizeForControlSize_(NSSmallControlSize)) self._nsObject.setTitleFont_(font) else: self._nsObject.setTitlePosition_(NSNoTitle)
def __init__(self, dimensions, font): font_name = font.info.familyName attribution = "{} by {}".format(font_name, font.info.designer) attribution_attributes = { NSFontAttributeName: NSFont.systemFontOfSize_(NSFont.systemFontSize()), NSForegroundColorAttributeName: NSColor.whiteColor() } formatted_attribution = NSMutableAttributedString.alloc().initWithString_attributes_(attribution, attribution_attributes) formatted_attribution.addAttribute_value_range_(NSFontAttributeName, NSFont.boldSystemFontOfSize_(NSFont.systemFontSize()), [0, len(font_name)]) super(AttributionText, self).__init__(dimensions, formatted_attribution)
def drawCellHeaderText(self, rect): paragraph = NSMutableParagraphStyle.alloc().init() paragraph.setAlignment_(NSCenterTextAlignment) paragraph.setLineBreakMode_(NSLineBreakByTruncatingMiddle) attributes = { NSFontAttributeName: NSFont.systemFontOfSize_(10.0), NSForegroundColorAttributeName: NSColor.colorWithCalibratedRed_green_blue_alpha_(.22, .22, .27, 1.0), NSParagraphStyleAttributeName: paragraph, } text = NSAttributedString.alloc().initWithString_attributes_(self.glyph.name, attributes) text.drawInRect_(rect)
def text_Gray(text): size = NSRegularControlSize attrs = {} attrs[NSForegroundColorAttributeName] = NSColor.grayColor() string = NSMutableAttributedString.alloc().initWithString_attributes_( text, attrs) #attrs[NSFontAttributeName] = NSFont.boldSystemFontOfSize_(NSFont.systemFontSizeForControlSize_(size)) attrs[NSFontAttributeName] = NSFont.systemFontOfSize_( NSFont.systemFontSizeForControlSize_(size)) attributedString = NSMutableAttributedString.alloc( ).initWithString_attributes_(text, attrs) return attributedString
def drawFontVerticalMetrics(glyph, scale, rect, drawLines=True, drawText=True, colorMetrics=None, colorMetricsTitles=None, backgroundColor=None, flipped=False): font = glyph.font if font is None: return backgroundColor.set() # gather y positions toDraw = (("Descender", "descender"), ("X Height", "xHeight"), ("Cap Height", "capHeight"), ("Ascender", "ascender")) toDraw = [(name, getattr(font.info, attr)) for name, attr in toDraw if getattr(font.info, attr) is not None] toDraw.append(("Baseline", 0)) positions = {} for name, position in toDraw: if position not in positions: positions[position] = [] positions[position].append(name) # create lines xMin = rect[0][0] xMax = xMin + rect[1][0] lines = [] for y, names in sorted(positions.items()): names = ", ".join(names) lines.append(((xMin, y), (xMax, y), names)) # draw lines if drawLines: colorMetrics.set() lineWidth = 0.5 * scale for pt1, pt2, names in lines: drawLine(pt1, pt2, lineWidth=lineWidth) # draw text if drawText: colorMetricsTitles.set() fontSize = 12 attributes = { NSFontAttributeName: NSFont.systemFontOfSize_(fontSize), NSForegroundColorAttributeName: colorMetricsTitles } for pt1, pt2, names in lines: x, y = pt1 x = glyph.width x += 15 * scale y += 10 * scale y -= (fontSize / 2.0) * scale drawTextAtPoint(names, (x, y), scale, attributes, flipped=flipped)
def initWithFrame_imageDir_(self, frame, imageDir): self = super(IntroView, self).initWithFrame_(frame) if not self: return None dropboxImage = NSImage.alloc().initWithContentsOfFile_(os.path.join(imageDir, u'box_stroked_150.png')) iW, iH = dropboxImage.size() newHeight = iH * 300.0 / iW self.dropboxViewFinalPosition = NSRect((25, frame.size[1] - 43 - newHeight), (300, newHeight)) self.dropboxView = ShadowedImage.alloc().initWithFrame_(self.dropboxViewFinalPosition) self.dropboxView.setImageScaling_(NSScaleToFit) self.dropboxView.setImage_(dropboxImage) self.dropboxView.setShadowColor_(NSColor.colorWithCalibratedRed_green_blue_alpha_(0, 0, 0, 0.5)) self.dropboxView.setShadowOffset_((0.0, -2.0)) self.dropboxView.setShadowBlurRadius_(5.0) logoImage = NSImage.alloc().initWithContentsOfFile_(os.path.join(imageDir, u'dropboxlogo.png')) iW, iH = logoImage.size() newHeight = iH * 300.0 / iW self.logoViewFinalPosition = NSRect((25, frame.size[1] - 334 - newHeight), (300, newHeight)) self.logoView = NSImageView.alloc().initWithFrame_(self.logoViewFinalPosition) self.logoView.setImage_(logoImage) self.versionView = NSTextView.alloc().initWithFrame_(NSRect((0, 0), frame.size)) self.versionView.setDrawsBackground_(NO) self.versionView.setEditable_(NO) self.versionView.setSelectable_(NO) self.versionView.textStorage().mutableString().setString_(u'Version %s' % build_number.VERSION) self.versionView.textStorage().setFont_(NSFont.labelFontOfSize_(14)) self.versionView.layoutManager().glyphRangeForTextContainer_(self.versionView.textContainer()) textSize1 = self.versionView.layoutManager().usedRectForTextContainer_(self.versionView.textContainer()).size textAnchor1 = 5 self.versionView2 = NSTextView.alloc().initWithFrame_(NSRect((0, 0), frame.size)) self.versionView2.setDrawsBackground_(NO) self.versionView2.setEditable_(NO) self.versionView2.setSelectable_(NO) self.versionView2.textStorage().mutableString().setString_(u'Copyright \xa9 2007-2010 Dropbox Inc.') self.versionView2.setFont_(NSFont.systemFontOfSize_(NSFont.systemFontSizeForControlSize_(NSSmallControlSize))) self.versionView2.layoutManager().glyphRangeForTextContainer_(self.versionView2.textContainer()) textSize2 = self.versionView2.layoutManager().usedRectForTextContainer_(self.versionView2.textContainer()).size textAnchor2 = 4 bottomToLogoViewBaseline = self.logoView.frame().origin[1] + 17 textSeparation = 10 combinedHeight = textSize1[1] + textSize2[1] + textSeparation self.versionView2FinalPosition = NSRect(((frame.size[0] - textSize2[0]) / 2.0, (bottomToLogoViewBaseline - combinedHeight) / 2.0), (textSize2[0], textSize2[1] + textAnchor2)) self.versionView2.setFrame_(self.versionView2FinalPosition) self.versionViewFinalPosition = NSRect(((frame.size[0] - textSize1[0]) / 2.0, self.versionView2.frame().origin[1] + textSeparation + self.versionView2.frame().size[1]), (textSize1[0], textSize1[1] + textAnchor1)) self.versionView.setFrame_(self.versionViewFinalPosition) for _view in (self.dropboxView, self.logoView, self.versionView, self.versionView2): self.addSubview_(_view) return self
def __init__(self, font, size): self._max_size = NSMakeSize(sys.float_info.max, sys.float_info.max) self._options = 1 << 3 # NSStringDrawingOptions.NSStringDrawingUsesDeiceMetrics # https://developer.apple.com/documentation/uikit/nsstringdrawingoptions?language=objc if font == "<System>": nsfont = NSFont.systemFontOfSize_(size) else: nsfont = NSFont.fontWithName_size_(font, size) self._attributes = NSMutableDictionary.dictionary() self._attributes.setObject_forKey_(nsfont, NSFontAttributeName) self._terminator = '1' self._terminator_width = self._measure(self._terminator)
def _drawTextLabel(self, transform, text, size, vector, percent=1.0): if text is None: return 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_( text_color[0], text_color[1], text_color[2], text_color[3] * percent, ), # 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)
def drawGlyphAnchors(glyph, scale, rect, drawAnchor=True, drawText=True, color=None, backgroundColor=None, flipped=False): if not glyph.anchors: return if color is None: color = getDefaultColor("glyphAnchor") fallbackColor = color if backgroundColor is None: backgroundColor = getDefaultColor("background") anchorSize = 5 * scale anchorHalfSize = anchorSize / 2 for anchor in glyph.anchors: if anchor.color is not None: color = colorToNSColor(anchor.color) else: color = fallbackColor x = anchor.x y = anchor.y name = anchor.name context = NSGraphicsContext.currentContext() context.saveGraphicsState() shadow = NSShadow.alloc().init() shadow.setShadowColor_(backgroundColor) shadow.setShadowOffset_((0, 0)) shadow.setShadowBlurRadius_(3) shadow.set() if drawAnchor: r = ((x - anchorHalfSize, y - anchorHalfSize), (anchorSize, anchorSize)) color.set() drawFilledOval(r) if drawText and name: attributes = { NSFontAttributeName: NSFont.systemFontOfSize_(9), NSForegroundColorAttributeName: color, } y -= 2 * scale drawTextAtPoint(name, (x, y), scale, attributes, xAlign="center", yAlign="top", flipped=flipped) context.restoreGraphicsState()
def drawCellHeaderText(self, rect): paragraph = NSMutableParagraphStyle.alloc().init() paragraph.setAlignment_(NSCenterTextAlignment) paragraph.setLineBreakMode_(NSLineBreakByTruncatingMiddle) attributes = { NSFontAttributeName: NSFont.systemFontOfSize_(10.0), NSForegroundColorAttributeName: NSColor.colorWithCalibratedRed_green_blue_alpha_( .22, .22, .27, 1.0), NSParagraphStyleAttributeName: paragraph, } text = NSAttributedString.alloc().initWithString_attributes_( self.glyph.name, attributes) text.drawInRect_(rect)
def checkSampleSize(self): text = self.w.selectionUnicodeText.get() minFontSize = 20 maxFontSize = 50 charsForLarge = 35 charsForSmall = 50 if len(text) < charsForLarge: fontSize = maxFontSize elif len(text) > charsForSmall: fontSize = minFontSize else: fs = (len(text)-charsForLarge)/(charsForSmall-charsForLarge) fontSize = maxFontSize + fs * (minFontSize-maxFontSize) tf = self.w.selectionUnicodeText.getNSTextField() nsBig = NSFont.systemFontOfSize_(fontSize) tf.setFont_(nsBig)
def __init__(self, dimensions, font): font_name = font.info.familyName or "" attribution = "{} by {}".format(font_name, font.info.openTypeNameDesigner) attribution_attributes = { NSFontAttributeName: NSFont.systemFontOfSize_(NSFont.systemFontSize()), NSForegroundColorAttributeName: NSColor.whiteColor() } formatted_attribution = NSMutableAttributedString.alloc( ).initWithString_attributes_(attribution, attribution_attributes) formatted_attribution.addAttribute_value_range_( NSFontAttributeName, NSFont.boldSystemFontOfSize_(NSFont.systemFontSize()), [0, len(font_name)]) super(AttributionText, self).__init__(dimensions, formatted_attribution)
def initWithDropboxApp_initialIgnoreList_takeAction_callback_remote_(self, dropbox_app, initial_ignore_list, take_action, callback, remote): self = super(SelectiveSyncView, self).initWithFrame_(NSZeroRect) if self is None: return self._initial_ignore_list = initial_ignore_list self._callback = callback self._take_action = take_action self._remote = remote self.setAutoresizingMask_(NSViewWidthSizable | NSViewHeightSizable) self._dropbox_app = dropbox_app self.initBrowser(self._remote) self.initButtons() f = NSFont.systemFontOfSize_(NSFont.smallSystemFontSize()) self.infoLabel = NSTextField.createLabelWithText_font_(selsync_strings.info, f) self.addSubview_(self.infoLabel) self.reloadInvalidState() self.layoutForWidth_(DEFAULT_ADVANCED_WIDTH if self.forest.advanced_view else DEFAULT_SIMPLE_WIDTH) return self
def __init__(self, posSize, titles, isVertical=True, callback=None, sizeStyle="regular"): self._setupView(self.nsMatrixClass, posSize, callback=callback) self._isVertical = isVertical matrix = self._nsObject matrix.setMode_(NSRadioModeMatrix) matrix.setCellClass_(self.nsCellClass) # XXX! this does not work for vertical radio groups! matrix.setAutosizesCells_(True) # we handle the control size setting here # since the actual NS object is a NSMatrix cellSizeStyle = _sizeStyleMap[sizeStyle] font = NSFont.systemFontOfSize_( NSFont.systemFontSizeForControlSize_(cellSizeStyle)) # intercell spacing and cell spacing are based on the sizeStyle if posSize == "auto": w = 0 else: w = posSize[2] if sizeStyle == "regular": matrix.setIntercellSpacing_((4.0, 2.0)) matrix.setCellSize_((w, 18)) elif sizeStyle == "small": matrix.setIntercellSpacing_((3.5, 2.0)) matrix.setCellSize_((w, 15)) elif sizeStyle == "mini": matrix.setIntercellSpacing_((3.0, 2.0)) matrix.setCellSize_((w, 12)) else: raise ValueError("sizeStyle must be 'regular', 'small' or 'mini'") for _ in range(len(titles)): if isVertical: matrix.addRow() else: matrix.addColumn() for title, cell in zip(titles, matrix.cells()): cell.setButtonType_(NSRadioButton) cell.setTitle_(title) cell.setControlSize_(cellSizeStyle) cell.setFont_(font)
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 )
def __init__(self): super().__init__() self.props.margin = 0 self.props.spacing = 6 # On OSX, make the font slightly smaller for status bar try: from AppKit import NSFont from gi.repository import Pango system_font = NSFont.systemFontOfSize_(9) self.modify_font( Pango.FontDescription(system_font.displayName() + " 9")) except: pass hbox = self.get_message_area() label = hbox.get_children()[0] hbox.props.spacing = 6 label.props.ellipsize = Pango.EllipsizeMode.NONE hbox.remove(label) hbox.pack_end(label, False, True, 0)
def __init__(self): self.alphabetSet = alphabetSetLower # set up window self.w = vanilla.Window((420, 150), "Pangrammer Helper") # set up remaining letters display self.w.alphabet = vanilla.TextBox((15, 15, -15, 20), self.alphabetSet) # set up text field, inserting Space Center text if available if CurrentSpaceCenter() is None: pangram = "Type your pangram here" else: sp = CurrentSpaceCenter() pangram = sp.getRaw() self.w.pangramEditor = vanilla.TextEditor( (15, 40, -15, 70), pangram, callback=self.textEditorCallback) self.w.counter = vanilla.TextBox((-250, 112, -15, 20), "Pangram length: 0", alignment='right') self.w.checkBox = vanilla.CheckBox((15, 110, -15, 20), "", callback=self.checkBoxCallback, value=False) self.w.checkBoxLabel = vanilla.TextBox( # don’t know how to access the NSText of a Vanilla check box label (32, 112, -15, 20), "Mixed case") # set the editor font to be monospaced, and the rest to be system font monospace_font = NSFont.userFixedPitchFontOfSize_(12) system_font = NSFont.systemFontOfSize_(12) self.w.pangramEditor.getNSTextView().setFont_(monospace_font) self.w.alphabet.getNSTextField().setFont_(system_font) self.w.counter.getNSTextField().setFont_(system_font) self.w.checkBoxLabel.getNSTextField().setFont_(system_font) self.w.open() # set remaining letters and counter to reflect contents of text field self.textEditorCallback(self)
def _setupContentView(self): # ------------------------------------------ # # Table View # # ------------------------------------------ # rect = NSMakeRect(0, 0, self.WIDTH, self.HEIGHT) containerView = NSView.alloc().initWithFrame_(rect) # Startup btn height = 20 margin = 20 width = self.WIDTH - 2 * margin self.startupBtn = NSButton.buttonWithTitle_target_action_( "Run safetyapp on startup", self, "startupDidChanged:") self.startupBtn.setButtonType_(NSButtonTypeSwitch) self.startupBtn.setFrame_( NSMakeRect(margin, self.HEIGHT - 2 * height, width, height)) self.startupBtn.setState_(self.data["startup"]) containerView.addSubview_(self.startupBtn) # API Key settings titleLabel = NSTextField.labelWithString_("API Key") titleLabel.setTextColor_(NSColor.blackColor()) rect = NSMakeRect( self.startupBtn.frame().origin.x, self.startupBtn.frame().origin.y - self.startupBtn.frame().size.height - height, width, height) titleLabel.setFrame_(rect) titleLabel.setFont_(NSFont.boldSystemFontOfSize_(14)) containerView.addSubview_(titleLabel) # API Key Sub-label titleSubLabel = NSTextField.labelWithString_( "Lorem lpsum dolor sit amet") titleSubLabel.setTextColor_(NSColor.blackColor()) rect = NSMakeRect( titleLabel.frame().origin.x, titleLabel.frame().origin.y - titleLabel.frame().size.height - height / 2, width, height) titleSubLabel.setFrame_(rect) titleSubLabel.setFont_(NSFont.systemFontOfSize_(14)) containerView.addSubview_(titleSubLabel) # API Key text field self.apiTextField = NSTextField.textFieldWithString_("") rect = NSMakeRect( titleSubLabel.frame().origin.x, titleSubLabel.frame().origin.y - titleSubLabel.frame().size.height - height / 2, width, 1.2 * height) self.apiTextField.setFrame_(rect) self.apiTextField.setFocusRingType_(NSFocusRingTypeNone) self.apiTextField.setTitleWithMnemonic_(self.data["api_key"]) self.apiTextField.setEditable_(True) containerView.addSubview_(self.apiTextField) self.window().makeFirstResponder_(self.apiTextField) # Table title tableTitleLabel = NSTextField.labelWithString_("Directories") tableTitleLabel.setTextColor_(NSColor.blackColor()) rect = NSMakeRect( self.apiTextField.frame().origin.x, self.apiTextField.frame().origin.y - self.apiTextField.frame().size.height - height, width, height) tableTitleLabel.setFrame_(rect) tableTitleLabel.setFont_(NSFont.boldSystemFontOfSize_(14)) containerView.addSubview_(tableTitleLabel) # Table sub-title tableSubTitleLabel = NSTextField.labelWithString_( "Lorem lpsum dolor sit amet") tableSubTitleLabel.setTextColor_(NSColor.blackColor()) rect = NSMakeRect( tableTitleLabel.frame().origin.x, tableTitleLabel.frame().origin.y - tableTitleLabel.frame().size.height - height / 2, width, height) tableSubTitleLabel.setFrame_(rect) tableSubTitleLabel.setFont_(NSFont.systemFontOfSize_(14)) containerView.addSubview_(tableSubTitleLabel) # ------------------------------------------ # # Toolbar button # # ------------------------------------------ # rect = NSMakeRect(20, 20, 67, 21) segControl = NSSegmentedControl.alloc().initWithFrame_(rect) segControl.setSegmentCount_(2) segControl.setSegmentStyle_(NSSegmentStyleSmallSquare) segControl.setWidth_forSegment_(32, 0) segControl.setWidth_forSegment_(32, 1) segControl.setImage_forSegment_( NSImage.imageNamed_(NSImageNameAddTemplate), 0) segControl.setImage_forSegment_( NSImage.imageNamed_(NSImageNameRemoveTemplate), 1) segControl.setTarget_(self) segControl.setAction_("segControlDidClicked:") containerView.addSubview_(segControl) rect = NSMakeRect(86, 21, self.WIDTH - 2 * margin - rect.size.width + 1, 21) toolbar = NSButton.alloc().initWithFrame_(rect) toolbar.setTitle_("") toolbar.setRefusesFirstResponder_(True) toolbar.setBezelStyle_(NSBezelStyleSmallSquare) containerView.addSubview_(toolbar) height = tableSubTitleLabel.frame().origin.y - segControl.frame( ).origin.y - margin - segControl.frame( ).size.height + 1 + tableSubTitleLabel.frame().size.height / 2 rect = NSMakeRect( tableSubTitleLabel.frame().origin.x, tableSubTitleLabel.frame().origin.y - tableSubTitleLabel.frame().size.height / 2 - height, width, height) scrollView = NSScrollView.alloc().initWithFrame_(rect) scrollView.setBorderType_(NSBezelBorder) self.tableView = NSTableView.alloc().initWithFrame_( scrollView.bounds()) self.tableView.setDataSource_(self) self.tableView.setDelegate_(self) self.tableView.setFocusRingType_(NSFocusRingTypeNone) # Path column pathCol = NSTableColumn.alloc().initWithIdentifier_( self.PATH_COL_IDENTIFIER) pathCol.setTitle_("Directory") # <-- Table view directory column title pathCol.setWidth_(self.WIDTH * 0.8) textCell = NSTextFieldCell.alloc().init() textCell.setEditable_(True) textCell.setTarget_(self) pathCol.setDataCell_(textCell) # Enable column enableCol = NSTableColumn.alloc().initWithIdentifier_( self.ENALBE_COL_IDENTIFIER) enableCol.setTitle_("Enable?") # <-- Enable column title enableCol.setWidth_(self.WIDTH * 0.2) cell = NSButtonCell.alloc().init() cell.setButtonType_(NSButtonTypeSwitch) cell.setTitle_("") cell.setTarget_(self) enableCol.setDataCell_(cell) self.tableView.addTableColumn_(pathCol) self.tableView.addTableColumn_(enableCol) scrollView.setDocumentView_(self.tableView) scrollView.setHasVerticalScroller_(True) containerView.addSubview_(scrollView) self.window().setContentView_(containerView)
def regular(size): return {NSFontAttributeName: NSFont.systemFontOfSize_(size)}
def openWindow(self): w = FloatingWindow((200, 242), title="Backdrop", closable=False) w.glyphList = List((10, 10, -10, 160), [{ "Visibility": False, "Status": None, "Name": "None", "Position": 0, "layer": None }], columnDescriptions=[{ "title": "Visibility", "cell": CheckBoxListCell(), "width": 30 }, { "title": "Status", "width": 20, "editable": False }, { "title": "Name", "width": 80, "editable": False }, { "title": "Position", "width": 30 }, { "title": "layer", "width": -3, "editable": False }], showColumnTitles=False, rowHeight=20, drawFocusRing=False, enableDelete=True, editCallback=self.listEdited) w.addGlyphButton = Button((10, 180, 90, 20), "Add Glyph", callback=self.glyphPopover) w.transLeftButton = Button((128, 180, 30, 20), u"←", callback=self.moveLeft) w.transRightButton = Button((160, 180, 30, 20), u"→", callback=self.moveRight) w.alignButton = SegmentedButton( (10, 209, -7, 21), [dict(title=u""), dict(title=u""), dict(title=u"")], callback=self.changeAlignment, selectionStyle="one") w.alignButton.set(self.alignment) w.open() fm = NSFontManager.sharedFontManager() systemFont = NSFont.systemFontOfSize_(NSFont.systemFontSize()) self.italicFont = fm.fontWithFamily_traits_weight_size_( systemFont.fontName(), NSItalicFontMask, 5, systemFont.pointSize()) self.boldFont = fm.fontWithFamily_traits_weight_size_( systemFont.fontName(), NSUnitalicFontMask, 8, systemFont.pointSize()) self.currentWindow = w self.toolStatus = True try: self.currentGlyph = Glyphs.font.selectedLayers[0] except: pass self.refreshGL() self.updateWindowUI()
class LightMeterTool(BaseEventTool): lightMeterToolPrefsLibKey = "com.letterror.lightMeter.prefs" textAttributes = { NSFontAttributeName : NSFont.systemFontOfSize_(10), NSForegroundColorAttributeName : NSColor.whiteColor(), } def setup(self): self.sliderWindow = None self.insides = {} self._hits = {} self._misses = {} self.kernel = None self.diameterStep = 5 self.fullColorMarkerSize = 2 self.diameterMarkerWidth = 0.4 self.toolStep = 2 self.isResizing = False self.pts = [] self.dupes = set() self.samples = {} self.lastPoint = None self._insideColor = (35/255.0,60/255.0,29/255.0) # photoshop self._outsideColor = (255/255.0,234/255.0,192/255.0) self.defaultPrefs = { 'drawTail': False, 'toolStyle': 'fluid', # grid 'invert': False, 'diameter': 200, 'toolDiameter': 30, 'chunkSize': 5, } self.prefs = {} self.getPrefs() def getPrefs(self): # read the prefs from the font lib # so we have consistent tool prefs # between glyphs g = self.getGlyph() if g is None: # no font? no parent? self.prefs.update(self.defaultPrefs) return parentLib = g.getParent().lib if self.lightMeterToolPrefsLibKey in parentLib: self.prefs.update(parentLib[self.lightMeterToolPrefsLibKey]) else: self.prefs.update(self.defaultPrefs) def storePrefs(self): # write the current tool preferences to the font.lib g = self.getGlyph() parentLib = g.getParent().lib if not self.lightMeterToolPrefsLibKey in parentLib: parentLib[self.lightMeterToolPrefsLibKey] = {} parentLib[self.lightMeterToolPrefsLibKey].update(self.prefs) def getKernel(self): kernelRadius = int(round((0.5*self.prefs['diameter'])/self.prefs['chunkSize'])) self.kernel = getKernel(kernelRadius, angle=math.radians(30)) def grid(self, pt): x, y = pt x = x - x%self.prefs['toolDiameter'] + 0.5*self.prefs['toolDiameter'] y = y - y%self.prefs['toolDiameter'] + 0.5*self.prefs['toolDiameter'] return x, y def draw(self, scale): # drawBackground(self if not hasattr(self, "prefs"): return s = self.prefs['toolDiameter'] # / scale last = None if not self.pts: return if self.prefs['drawTail']: drawThese = self.pts[:] else: drawThese = [self.pts[-1]] stroke(None) for (x,y), level, tdm in drawThese: key = (x,y),tdm if self.prefs['invert']: fill(1-level) else: fill(level) stroke(None) if self.prefs['toolStyle'] == "grid": rect(x-.5*tdm, y-0.5*tdm, tdm, tdm) else: oval(x-.5*tdm, y-0.5*tdm, tdm, tdm) if round(level, 3) == 0: stroke(None) fill(1) oval(x-.5*self.fullColorMarkerSize, y-.5*self.fullColorMarkerSize, self.fullColorMarkerSize, self.fullColorMarkerSize) elif round(level,3) == 1.0: stroke(None) fill(0) oval(x-.5*self.fullColorMarkerSize, y-.5*self.fullColorMarkerSize, self.fullColorMarkerSize, self.fullColorMarkerSize) self.drawDiameter(x, y, scale, showSize=self.isResizing) (x,y), level, tdm = drawThese[-1] if self.prefs['invert']: fill(1-level) else: fill(level) stroke(None) if self.prefs['toolStyle'] == "grid": rect(x-.5*tdm, y-0.5*tdm, tdm, tdm) else: oval(x-.5*tdm, y-0.5*tdm, tdm, tdm) tp, level, tdm = self.pts[-1] self.getNSView()._drawTextAtPoint( "%3.2f"%(100-100*level), self.textAttributes, tp, yOffset=-30, drawBackground=True, backgroundColor=NSColor.blueColor()) def drawDiameter(self, x, y, scale=1, showSize=False): # draw points contributing to the level. s = self.prefs['chunkSize'] stroke(None) for (px,py), v in self._hits.items(): fill(self._outsideColor[0],self._outsideColor[1],self._outsideColor[2], v*80) oval(px-0.5*s, py-0.5*s, s, s) for (px,py), v in self._misses.items(): fill(self._insideColor[0],self._insideColor[1],self._insideColor[2], v*80) oval(px-0.5*s, py-0.5*s, s, s) stroke(0.5) strokeWidth(self.diameterMarkerWidth*scale) fill(None) oval(x-0.5*self.prefs['diameter'], y-0.5*self.prefs['diameter'], self.prefs['diameter'], self.prefs['diameter']) if showSize: tp = x, y + 20*scale self.getNSView()._drawTextAtPoint( u"⌀ %3.2f"%(self.prefs['diameter']), self.textAttributes, tp, yOffset=(.5*self.prefs['diameter'])/scale, drawBackground=True, backgroundColor=NSColor.grayColor()) def mouseDown(self, point, event): mods = self.getModifiers() cmd = mods['commandDown'] > 0 self.isResizing = False if cmd: self.clear() def clear(self): self.pts = [] self.dupes = set() self.samples = {} def drawMargins(self): # sample the whole box g = self.getGlyph() if g.box is None: return xMin, yMin, xMax, yMax = self.getGlyph().box for y in range(yMin, yMax+self.prefs['toolDiameter'], self.prefs['toolDiameter']): samplePoint = self.grid((xMin,y)) self.processPoint(samplePoint) samplePoint = self.grid((0,y)) self.processPoint(samplePoint) samplePoint = self.grid((xMax,y)) self.processPoint(samplePoint) samplePoint = self.grid((g.width,y)) self.processPoint(samplePoint) def keyDown(self, event): letter = event.characters() if letter == "i": # invert the paint color on drawing self.prefs['invert'] = not self.prefs['invert'] self.storePrefs() elif letter == "M": # draw the whole bounds self.drawMargins() elif letter == "p": if self.prefs['toolStyle'] == "grid": self.prefs['toolStyle'] = "fluid" else: self.prefs['toolStyle'] = 'grid' self.storePrefs() elif letter == "t": self.prefs['drawTail'] = not self.prefs['drawTail'] self.storePrefs() elif letter == "c": self.clear() mods = self.getModifiers() cmd = mods['commandDown'] > 0 option = mods['optionDown'] > 0 arrows = self.getArrowsKeys() if cmd: # change the grid size if arrows['up']: self.prefs['toolDiameter'] += self.toolStep elif arrows['down']: self.prefs['toolDiameter'] -= self.toolStep self.prefs['toolDiameter'] = abs(self.prefs['toolDiameter']) #self.clear() self.getKernel() self.calcSample(self.lastPoint) self.storePrefs() elif option: # change the chunk size if arrows['left']: self.prefs['chunkSize'] += 1 elif arrows['right']: self.prefs['chunkSize'] = max(4, min(40, self.prefs['chunkSize'] - 1)) self.getKernel() self.calcSample(self.lastPoint) self.storePrefs() else: self.isResizing = True if arrows['up']: self.prefs['diameter'] += self.diameterStep elif arrows['down']: self.prefs['diameter'] -= self.diameterStep self.prefs['diameter'] = abs(self.prefs['diameter']) #self.clear() self.getKernel() self.calcSample(self.lastPoint) self.storePrefs() UpdateCurrentGlyphView() def mouseDragged(self, point, delta): """ Calculate the blurred gray level for this point. """ self.isResizing = False self.lastPoint = samplePoint = point.x, point.y if self.prefs['toolStyle'] == "grid": self.lastPoint = samplePoint = self.grid(samplePoint) self.processPoint(samplePoint) def processPoint(self, samplePoint): if (self.prefs['toolDiameter'], samplePoint) in self.dupes: level = self.samples.get((samplePoint, self.prefs['toolDiameter']))['level'] i = self.pts.index((samplePoint, level, self.prefs['toolDiameter'])) del self.pts[i] self.pts.append((samplePoint, level, self.prefs['toolDiameter'])) self.calcSample(samplePoint) def calcSample(self, samplePoint): if samplePoint is None: return if not self.kernel: self.getKernel() level = 0 self._insides = {} self._hits = {} self._misses = {} nsPathObject = self.getGlyph().getRepresentation("defconAppKit.NSBezierPath") for pos, val in self.kernel.items(): thisPos = samplePoint[0]+pos[0]*self.prefs['chunkSize'], samplePoint[1]+pos[1]*self.prefs['chunkSize'] #a = math.atan2(pos[0], pos[1]) if thisPos not in self._insides: self._insides[thisPos] = nsPathObject.containsPoint_(thisPos) if not self._insides[thisPos]: level += self.kernel.get(pos) self._hits[thisPos] = self.kernel.get(pos) else: self._misses[thisPos] = self.kernel.get(pos) self.pts.append((samplePoint, level, self.prefs['toolDiameter'])) self.samples[(samplePoint, self.prefs['toolDiameter'])] = dict(level=level) self.dupes.add((self.prefs['toolDiameter'], samplePoint)) return level def getToolbarTip(self): return 'LightMeter' def getToolbarIcon(self): ## return the toolbar icon return toolbarIcon
def drawGlyphPoints(glyph, scale, rect, drawStartPoint=True, drawOnCurves=True, drawOffCurves=True, drawCoordinates=True, color=None, backgroundColor=None, flipped=False): layer = glyph.layer if layer is not None: if layer.color is not None: color = colorToNSColor(layer.color) if color is None: color = getDefaultColor("glyphPoints") if backgroundColor is None: backgroundColor = getDefaultColor("background") # get the outline data outlineData = glyph.getRepresentation("defconAppKit.OutlineInformation") points = [] # start point if drawStartPoint and outlineData["startPoints"]: startWidth = startHeight = 15 * scale startHalf = startWidth / 2.0 path = NSBezierPath.bezierPath() for point, angle in outlineData["startPoints"]: x, y = point if angle is not None: path.moveToPoint_((x, y)) path.appendBezierPathWithArcWithCenter_radius_startAngle_endAngle_clockwise_( (x, y), startHalf, angle - 90, angle + 90, True) path.closePath() else: path.appendBezierPathWithOvalInRect_( ((x - startHalf, y - startHalf), (startWidth, startHeight))) r = color.redComponent() g = color.greenComponent() b = color.blueComponent() a = color.alphaComponent() a *= 0.3 startPointColor = NSColor.colorWithCalibratedRed_green_blue_alpha_( r, g, b, a) startPointColor.set() path.fill() # off curve if drawOffCurves and outlineData["offCurvePoints"]: # lines color.set() for point1, point2 in outlineData["bezierHandles"]: drawLine(point1, point2) # points offWidth = 3 * scale offHalf = offWidth / 2.0 path = NSBezierPath.bezierPath() for point in outlineData["offCurvePoints"]: x, y = point["point"] points.append((x, y)) x -= offHalf y -= offHalf path.appendBezierPathWithOvalInRect_( ((x, y), (offWidth, offWidth))) path.setLineWidth_(3.0 * scale) color.set() path.stroke() backgroundColor.set() path.fill() color.set() path.setLineWidth_(1.0 * scale) # on curve if drawOnCurves and outlineData["onCurvePoints"]: width = 4 * scale half = width / 2.0 smoothWidth = 5 * scale smoothHalf = smoothWidth / 2.0 path = NSBezierPath.bezierPath() for point in outlineData["onCurvePoints"]: x, y = point["point"] points.append((x, y)) if point["smooth"]: x -= smoothHalf y -= smoothHalf path.appendBezierPathWithOvalInRect_( ((x, y), (smoothWidth, smoothWidth))) else: x -= half y -= half path.appendBezierPathWithRect_(((x, y), (width, width))) backgroundColor.set() path.setLineWidth_(3.0 * scale) path.stroke() color.set() path.fill() # coordinates if drawCoordinates: r = color.redComponent() g = color.greenComponent() b = color.blueComponent() a = color.alphaComponent() a *= 0.6 color = NSColor.colorWithCalibratedRed_green_blue_alpha_(r, g, b, a) fontSize = 9 attributes = { NSFontAttributeName: NSFont.systemFontOfSize_(fontSize), NSForegroundColorAttributeName: color } for x, y in points: posX = x posY = y - 3 x = round(x, 1) if int(x) == x: x = int(x) y = round(y, 1) if int(y) == y: y = int(y) text = "%d %d" % (x, y) drawTextAtPoint(text, (posX, posY), scale, attributes=attributes, xAlign="center", yAlign="top", flipped=flipped)
def drawFontVerticalMetrics(glyph, scale, rect, drawLines=True, drawText=True, color=None, backgroundColor=None, flipped=False): font = glyph.font if font is None: return if color is None: color = getDefaultColor("fontVerticalMetrics") if backgroundColor is None: backgroundColor = getDefaultColor("background") color.set() # gather y positions toDraw = (("Descender", "descender"), ("X Height", "xHeight"), ("Cap Height", "capHeight"), ("Ascender", "ascender")) toDraw = [(name, getattr(font.info, attr)) for name, attr in toDraw if getattr(font.info, attr) is not None] toDraw.append(("Baseline", 0)) positions = {} for name, position in toDraw: if position not in positions: positions[position] = [] positions[position].append(name) # create lines xMin = rect[0][0] xMax = xMin + rect[1][0] lines = [] for y, names in sorted(positions.items()): names = ", ".join(names) lines.append(((xMin, y), (xMax, y), names)) # draw lines if drawLines: lineWidth = 1.0 * scale for pt1, pt2, names in lines: drawLine(pt1, pt2, lineWidth=lineWidth) # draw text if drawText: fontSize = 9 shadow = NSShadow.shadow() shadow.setShadowColor_(backgroundColor) shadow.setShadowBlurRadius_(5) shadow.setShadowOffset_((0, 0)) attributes = { NSFontAttributeName: NSFont.systemFontOfSize_(fontSize), NSForegroundColorAttributeName: color } glowAttributes = { NSFontAttributeName: NSFont.systemFontOfSize_(fontSize), NSForegroundColorAttributeName: color, NSStrokeColorAttributeName: backgroundColor, NSStrokeWidthAttributeName: 25, NSShadowAttributeName: shadow } for pt1, pt2, names in lines: x, y = pt1 x += 5 * scale y -= (fontSize / 2.0) * scale drawTextAtPoint(names, (x, y), scale, glowAttributes, flipped=flipped) drawTextAtPoint(names, (x, y), scale, attributes, flipped=flipped)
class ZoneCheckerTool(EditingTool): zoneCheckerToolPrefsLibKey = "com.letterror.zoneChecker.prefs" textAttributes = { NSFontAttributeName: NSFont.systemFontOfSize_(10), NSForegroundColorAttributeName: NSColor.whiteColor(), } margin = 3 # how far off are points? def setup(self): self.markColor = (255 / 255.0, 0 / 255.0, 0 / 255.0, 0.8) self.okColor = (0 / 255.0, 0 / 255.0, 255 / 255.0, 0.8) self.outside = [] self.inside = [] def _p(self, items): if len(items) % 2 != 0: return [] return [(items[i], items[i + 1]) for i in range(0, len(items) - 1, 2)] def findMisalignedPoints(self): g = CurrentGlyph() f = CurrentFont() if f is None: return if not g: return self.outside = [] self.inside = [] zones = [] for a, b in self._p(f.info.postscriptBlueValues): zones.append((a, b)) for a, b in self._p(f.info.postscriptOtherBlues): zones.append((a, b)) for a, b in self._p(f.info.postscriptFamilyBlues): zones.append((a, b)) for c in g.contours: for p in c.points: if p.type == "offCurve": continue y = p.y for a, b in zones: if (a - self.margin < y < b + self.margin): if not (a <= y <= b): self.outside.append((p.x, p.y)) else: self.inside.append((p.x, p.y)) def draw(self, scale): self.findMisalignedPoints() if scale == 0: return save() fill(None) for x, y in self.outside: d = scale * 25 d2 = 2 * d strokeWidth(20 * scale) stroke(self.markColor[0], self.markColor[1], self.markColor[2], self.markColor[3]) oval(x - d, y - d, d2, d2) for x, y in self.inside: d = scale * 9 d2 = 2 * d strokeWidth(2 * scale) stroke(self.okColor[0], self.okColor[1], self.okColor[2], self.okColor[3]) oval(x - d, y - d, d2, d2) restore() # self.getNSView()._drawTextAtPoint( # "%3.2f"%(100-100*level), # self.textAttributes, # tp, # yOffset=-30, # drawBackground=True, # backgroundColor=NSColor.blueColor()) def mouseDown(self, point, event): pass # mods = self.getModifiers() # cmd = mods['commandDown'] > 0 # self.isResizing = False # if cmd: # self.clear() def clear(self): self.marked = None pass # self.pts = [] # self.dupes = set() # self.samples = {} def keyDown(self, event): pass # letter = event.characters() # if letter == "i": # # invert the paint color on drawing # self.prefs['invert'] = not self.prefs['invert'] # self.storePrefs() # UpdateCurrentGlyphView() def mouseDragged(self, point, delta): """ Calculate the blurred gray level for this point. """ pass def getToolbarTip(self): return 'ZoneChecker' def getToolbarIcon(self): ## return the toolbar icon return toolbarIcon
def save(): # save the current graphic state NSGraphicsContext.currentContext().saveGraphicsState() def restore(): # restore the current graphic state NSGraphicsContext.currentContext().restoreGraphicsState() currentPath = None currentFillColor = NSColor.blackColor() currentStrokeColor = None currentGradient = None currentStrokeWidth = None currentFont = NSFont.systemFontOfSize_(NSFont.systemFontSize()) def rect(x, y, width, height): # draws a rectangle drawPath(NSBezierPath.bezierPathWithRect_(NSMakeRect(x, y, width, height))) def oval(x, y, width, height): # draws an oval drawPath( NSBezierPath.bezierPathWithOvalInRect_(NSMakeRect(x, y, width, height))) def line(x1, y1, x2=None, y2=None):
# # Python GUI - Standard Fonts - PyObjC # from AppKit import NSFont from GUI import Font system_font = Font._from_ns_font(NSFont.systemFontOfSize_(0)) application_font = Font._from_ns_font(NSFont.userFontOfSize_(0))
def drawRect_(self, rect): # self._layer.drawInFrame_(bounds) # used in Georgs GlyphView try: bounds = self.bounds() NSColor.textBackgroundColor().set() NSRectFill(bounds) scaleFactor = self._scaleFactor thisGlyph = self._layer.parent layerWidth = self._layer.width * scaleFactor descender = self._layer.glyphMetrics()[3] * scaleFactor ascender = self._layer.glyphMetrics()[1] * scaleFactor ## This order is important! Wont work the other way around. bezierPathOnly = self._layer.bezierPath # Path Only if bezierPathOnly is not None: bezierPathOnly = bezierPathOnly.copy() bezierPathWithComponents = self._layer.completeBezierPath # Path & Components bezierPathOpenWithComponents = self._layer.completeOpenBezierPath # Path & Components # Set the scale #-------------- scale = NSAffineTransform.transform() scale.translateXBy_yBy_((bounds.size.width - layerWidth) / 2.0, (bounds.size.height - ascender + descender) / 2.0 - descender) scale.scaleBy_(scaleFactor) # Draw only path in black #------------------------ if thisGlyph.export: pathColor = NSColor.textColor() componentColor = NSColor.secondaryLabelColor() else: pathColor = NSColor.orangeColor() componentColor = NSColor.orangeColor() if bezierPathWithComponents: bezierPathWithComponents.transformUsingAffineTransform_(scale) componentColor.set() # Draw components in gray bezierPathWithComponents.fill() if bezierPathOnly: pathColor.set() bezierPathOnly.transformUsingAffineTransform_(scale) bezierPathOnly.fill() if bezierPathOpenWithComponents: pathColor.set() bezierPathOpenWithComponents.transformUsingAffineTransform_(scale) bezierPathOpenWithComponents.stroke() # Draw non-exported glyphs in orange #----------------------------------- else: NSColor.orangeColor().set() bezierPathWithComponents.transformUsingAffineTransform_(scale) bezierPathWithComponents.fill() attributes = {} attributes[NSFontAttributeName] = NSFont.systemFontOfSize_(14) attributes[NSForegroundColorAttributeName] = NSColor.secondaryLabelColor() thisLKG = thisGlyph.leftKerningGroup thisRKG = thisGlyph.rightKerningGroup if thisLKG is not None: String = NSAttributedString.alloc().initWithString_attributes_(thisLKG, attributes) String.drawAtPoint_alignment_((12, 5), 0) if thisRKG is not None: String = NSAttributedString.alloc().initWithString_attributes_(thisRKG, attributes) String.drawAtPoint_alignment_((bounds.size.width - 12, 5), 2) # AUTO-WIDTH LABEL #----------------- if self._layer.hasAlignedWidth(): attributes[NSForegroundColorAttributeName] = NSColor.lightGrayColor() attributes[NSFontAttributeName] = NSFont.systemFontOfSize_(11) String = NSAttributedString.alloc().initWithString_attributes_("Auto-Width", attributes) String.drawAtPoint_alignment_((bounds.size.width / 2.0, 5), 1) except: print(traceback.format_exc())
path = glyph._layer.bezierPath drawPath(path) def save(): # save the current graphic state NSGraphicsContext.currentContext().saveGraphicsState() def restore(): # restore the current graphic state NSGraphicsContext.currentContext().restoreGraphicsState() currentPath = None currentFillColor = NSColor.blackColor() currentStrokeColor = None currentGradient = None currentFont = NSFont.systemFontOfSize_(NSFont.systemFontSize()) def rect(x, y, width, height): # draws a rectangle drawPath(NSBezierPath.bezierPathWithRect_(NSMakeRect(x, y, width, height))) def oval(x, y, width, height): # draws an oval drawPath(NSBezierPath.bezierPathWithOvalInRect_(NSMakeRect(x, y, width, height))) 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))
def _setSizeStyle(self, sizeStyle): value = sizeStyle self._nsObject.cell().setControlSize_(value) font = NSFont.systemFontOfSize_(value) self._nsObject.setFont_(font) self._nsObject.setTextColor_(self.color)
def drawGlyphPoints(glyph, scale, rect, drawStartPoint=False, drawOnCurves=False, drawOffCurves=False, drawCoordinates=False, colorCornerPointsFill=None, colorCornerPointsStroke=None, colorTangentPointsFill=None, colorTangentPointsStroke=None, colorCurvePointsFill=None, colorCurvePointsStroke=None, colorOffCurvePointsFill=None, colorOffCurvePointsStroke=None, colorOffCurveQuadPointsStroke=None, colorSmoothPointStroke=None, colorStartPointsArrow=None, colorOpenStartPointsArrow=None, colorPointCoordinate=None, colorPointCoordinateBackground=None, colorHandlesStroke=None, colorHandlesQuadStroke=None, backgroundColor=None, pointSizeOnCurve=False, pointSizeOffCurve=False, flipped=False): # get the outline data outlineData = glyph.getRepresentation("defconAppKit.OutlineInformation") points = [] # start point if drawStartPoint and outlineData["startPoints"]: startWidth = startHeight = 15 * scale startHalf = startWidth / 2.0 path = NSBezierPath.bezierPath() for point, angle in outlineData["startPoints"]: x, y = point if angle is not None: path.moveToPoint_((x, y)) path.appendBezierPathWithArcWithCenter_radius_startAngle_endAngle_clockwise_( (x, y), startHalf, angle - 90, angle + 90, True) path.closePath() else: path.appendBezierPathWithOvalInRect_( ((x - startHalf, y - startHalf), (startWidth, startHeight))) colorStartPointsArrow.set() path.fill() # off curve if drawOffCurves and outlineData["offCurvePoints"]: # lines colorHandlesStroke.set() for point1, point2 in outlineData["bezierHandles"]: drawLine(point1, point2) # points offWidth = pointSizeOffCurve * scale offHalf = offWidth / 2.0 path = NSBezierPath.bezierPath() for point in outlineData["offCurvePoints"]: x, y = point["point"] points.append((x, y)) x -= offHalf y -= offHalf path.appendBezierPathWithOvalInRect_( ((x, y), (offWidth, offWidth))) path.setLineWidth_(2.0 * scale) colorOffCurvePointsStroke.set() path.stroke() #backgroundColor.set() #path.fill() colorOffCurvePointsFill.set() path.setLineWidth_(1.0 * scale) path.fill() # on curve if drawOnCurves and outlineData["onCurvePoints"]: width = pointSizeOnCurve * scale half = width / 2.0 triOuter = width / math.sqrt(3) triInner = width * math.sqrt(3) / 6.0 for point in outlineData["onCurvePoints"]: path = NSBezierPath.bezierPath() x, y = point["point"] points.append((x, y)) if point["segmentType"] == "curve": if point["smooth"]: path.appendBezierPathWithOvalInRect_( ((x - half, y - half), (width, width))) colorSmoothPointStroke.set() path.setLineWidth_(2 * scale) path.stroke() colorCurvePointsFill.set() path.fill() else: path.appendBezierPathWithOvalInRect_( ((x - half, y - half), (width, width))) colorCurvePointsStroke.set() path.setLineWidth_(2 * scale) path.stroke() colorCurvePointsFill.set() path.fill() elif point["segmentType"] == "line": if point["smooth"]: path.moveToPoint_((x - half, y - triInner)) path.lineToPoint_((x, y + triOuter)) path.lineToPoint_((x + half, y - triInner)) #path.lineToPoint_((x-half, y-third)) path.closePath() #path.appendBezierPathWithRect_(((x-half, y-half), (width, width))) colorTangentPointsStroke.set() path.setLineWidth_(2 * scale) path.stroke() colorTangentPointsFill.set() path.fill() else: path.appendBezierPathWithRect_( ((x - half, y - half), (width, width))) colorCornerPointsStroke.set() path.setLineWidth_(2 * scale) path.stroke() colorCornerPointsFill.set() path.fill() # path.appendBezierPathWithOvalInRect_(((x, y), (smoothWidth, smoothWidth))) # path.appendBezierPathWithRect_(((x, y), (width, width))) # coordinates if drawCoordinates: fontSize = 9 attributes = { NSFontAttributeName: NSFont.systemFontOfSize_(fontSize), NSForegroundColorAttributeName: colorPointCoordinate } for x, y in points: posX = x posY = y - 3 x = round(x, 1) if int(x) == x: x = int(x) y = round(y, 1) if int(y) == y: y = int(y) text = "%d %d" % (x, y) drawTextAtPoint(text, (posX, posY), scale, attributes=attributes, xAlign="center", yAlign="top", flipped=flipped)
def _setSizeStyle(self, value): value = _sizeStyleMap[value] self._nsObject.setControlSize_(value) font = NSFont.systemFontOfSize_( NSFont.systemFontSizeForControlSize_(value)) self._nsObject.setFont_(font)
def drawGlyphPoints(glyph, scale, rect, drawStartPoint=True, drawOnCurves=True, drawOffCurves=True, drawCoordinates=True, color=None, backgroundColor=None, flipped=False): layer = glyph.layer if layer is not None: if layer.color is not None: color = colorToNSColor(layer.color) if color is None: color = getDefaultColor("glyphPoints") if backgroundColor is None: backgroundColor = getDefaultColor("background") # get the outline data outlineData = glyph.getRepresentation("defconAppKit.OutlineInformation") points = [] # start point if drawStartPoint and outlineData["startPoints"]: startWidth = startHeight = 15 * scale startHalf = startWidth / 2.0 path = NSBezierPath.bezierPath() for point, angle in outlineData["startPoints"]: x, y = point if angle is not None: path.moveToPoint_((x, y)) path.appendBezierPathWithArcWithCenter_radius_startAngle_endAngle_clockwise_( (x, y), startHalf, angle - 90, angle + 90, True) path.closePath() else: path.appendBezierPathWithOvalInRect_(((x - startHalf, y - startHalf), (startWidth, startHeight))) r = color.redComponent() g = color.greenComponent() b = color.blueComponent() a = color.alphaComponent() a *= 0.3 startPointColor = NSColor.colorWithCalibratedRed_green_blue_alpha_(r, g, b, a) startPointColor.set() path.fill() # off curve if drawOffCurves and outlineData["offCurvePoints"]: # lines color.set() for point1, point2 in outlineData["bezierHandles"]: drawLine(point1, point2) # points offWidth = 3 * scale offHalf = offWidth / 2.0 path = NSBezierPath.bezierPath() for point in outlineData["offCurvePoints"]: x, y = point["point"] points.append((x, y)) x -= offHalf y -= offHalf path.appendBezierPathWithOvalInRect_(((x, y), (offWidth, offWidth))) path.setLineWidth_(3.0 * scale) color.set() path.stroke() backgroundColor.set() path.fill() color.set() path.setLineWidth_(1.0 * scale) # on curve if drawOnCurves and outlineData["onCurvePoints"]: width = 4 * scale half = width / 2.0 smoothWidth = 5 * scale smoothHalf = smoothWidth / 2.0 path = NSBezierPath.bezierPath() for point in outlineData["onCurvePoints"]: x, y = point["point"] points.append((x, y)) if point["smooth"]: x -= smoothHalf y -= smoothHalf path.appendBezierPathWithOvalInRect_(((x, y), (smoothWidth, smoothWidth))) else: x -= half y -= half path.appendBezierPathWithRect_(((x, y), (width, width))) backgroundColor.set() path.setLineWidth_(3.0 * scale) path.stroke() color.set() path.fill() # coordinates if drawCoordinates: r = color.redComponent() g = color.greenComponent() b = color.blueComponent() a = color.alphaComponent() a *= 0.6 color = NSColor.colorWithCalibratedRed_green_blue_alpha_(r, g, b, a) fontSize = 9 attributes = { NSFontAttributeName: NSFont.systemFontOfSize_(fontSize), NSForegroundColorAttributeName: color } for x, y in points: posX = x posY = y - 3 x = round(x, 1) if int(x) == x: x = int(x) y = round(y, 1) if int(y) == y: y = int(y) text = "%d %d" % (x, y) drawTextAtPoint(text, (posX, posY), scale, attributes=attributes, xAlign="center", yAlign="top", flipped=flipped)
def _setSizeStyle(self, value): value = _sizeStyleMap[value] self._nsObject.cell().setControlSize_(value) font = NSFont.systemFontOfSize_(NSFont.systemFontSizeForControlSize_(value)) self._nsObject.setFont_(font)
def GlyphCellDetailFactory(glyph): font = glyph.font imageWidth = 200 imageHeight = 280 scale = 120 / font.info.unitsPerEm glyphLeftOffset = (imageWidth - (glyph.width * scale)) / 2 basePath = roundedRectBezierPath(((.5, .5), (imageWidth - 1, imageHeight - 1)), 7) basePath.setLineWidth_(1.0) glyphPath = glyph.getRepresentation("defconAppKit.NSBezierPath") line1Path = NSBezierPath.bezierPath() line1Path.moveToPoint_((1, 120.5)) line1Path.lineToPoint_((imageWidth - 1, 120.5)) line1Path.setLineWidth_(1.0) line2Path = NSBezierPath.bezierPath() line2Path.moveToPoint_((1, 121.5)) line2Path.lineToPoint_((imageWidth - 1, 121.5)) line2Path.setLineWidth_(1.0) lineColor = NSColor.colorWithCalibratedWhite_alpha_(.5, 1.0) paragraph = NSMutableParagraphStyle.alloc().init() paragraph.setAlignment_(NSRightTextAlignment) paragraph.setLineBreakMode_(NSLineBreakByCharWrapping) leftAttributes = { NSFontAttributeName: NSFont.systemFontOfSize_(12.0), NSForegroundColorAttributeName: NSColor.whiteColor(), NSParagraphStyleAttributeName: paragraph } paragraph = NSMutableParagraphStyle.alloc().init() paragraph.setAlignment_(NSLeftTextAlignment) paragraph.setLineBreakMode_(NSLineBreakByTruncatingMiddle) rightAttributes = { NSFontAttributeName: NSFont.systemFontOfSize_(12.0), NSForegroundColorAttributeName: NSColor.whiteColor(), NSParagraphStyleAttributeName: paragraph } nameTitle = NSAttributedString.alloc().initWithString_attributes_("Name", leftAttributes) nameText = NSAttributedString.alloc().initWithString_attributes_(glyph.name, rightAttributes) uniTitle = NSAttributedString.alloc().initWithString_attributes_("Unicode", leftAttributes) uni = glyph.unicode if uni is None: uni = "" else: uni = hex(uni)[2:].upper() if len(uni) < 4: uni = uni.zfill(4) uniText = NSAttributedString.alloc().initWithString_attributes_(str(uni), rightAttributes) widthTitle = NSAttributedString.alloc().initWithString_attributes_("Width", leftAttributes) width = glyph.width if width is None: width = 0 width = round(width, 3) if width == int(width): width = int(width) widthText = NSAttributedString.alloc().initWithString_attributes_(str(width), rightAttributes) leftTitle = NSAttributedString.alloc().initWithString_attributes_("Left Margin", leftAttributes) leftMargin = glyph.leftMargin if leftMargin is None: leftMargin = 0 leftMargin = round(leftMargin, 3) if leftMargin == int(leftMargin): leftMargin = int(leftMargin) leftText = NSAttributedString.alloc().initWithString_attributes_(str(leftMargin), rightAttributes) rightTitle = NSAttributedString.alloc().initWithString_attributes_("Right Margin", leftAttributes) rightMargin = glyph.rightMargin if rightMargin is None: rightMargin = 0 rightMargin = round(rightMargin, 3) if rightMargin == int(rightMargin): rightMargin = int(rightMargin) rightText = NSAttributedString.alloc().initWithString_attributes_(str(rightMargin), rightAttributes) image = NSImage.alloc().initWithSize_((imageWidth, imageHeight)) image.setFlipped_(True) image.lockFocus() NSColor.colorWithCalibratedWhite_alpha_(0, .65).set() basePath.fill() lineColor.set() basePath.stroke() context = NSGraphicsContext.currentContext() context.saveGraphicsState() transform = NSAffineTransform.transform() transform.translateXBy_yBy_(glyphLeftOffset, 145) transform.scaleBy_(scale) transform.translateXBy_yBy_(0, -font.info.descender) transform.concat() NSColor.whiteColor().set() glyphPath.fill() context.restoreGraphicsState() lineColor.set() line1Path.stroke() NSColor.colorWithCalibratedWhite_alpha_(0, .5).set() line2Path.stroke() transform = NSAffineTransform.transform() transform.translateXBy_yBy_(0, 110) transform.scaleXBy_yBy_(1.0, -1.0) transform.concat() nameTitle.drawInRect_(((0, 0), (90, 17))) nameText.drawInRect_(((95, 0), (85, 17))) uniTitle.drawInRect_(((0, 20), (90, 17))) uniText.drawInRect_(((95, 20), (85, 17))) widthTitle.drawInRect_(((0, 40), (90, 17))) widthText.drawInRect_(((95, 40), (85, 17))) leftTitle.drawInRect_(((0, 60), (90, 17))) leftText.drawInRect_(((95, 60), (85, 17))) rightTitle.drawInRect_(((0, 80), (90, 17))) rightText.drawInRect_(((95, 80), (85, 17))) image.unlockFocus() return image
def drawRect_(self, rect): ## needs to be `drawRect_` -- nothing else bounds = self.bounds() # thisUPM = self._layer.parent.parent.upm scaleFactor = self._scaleFactor thisUPM = self._upm * scaleFactor rectX, rectY, rectWidth, rectHeight = 0, 0, thisUPM, thisUPM self.rect = rect # self._layer.drawInFrame_(bounds) # used in Georgs GlyphView try: layerWidth = self._layer.width * scaleFactor descender = self._layer.glyphMetrics()[3] * scaleFactor ## this order is important! Wont work the other way around try: # pre Glyphs 2.3 bezierPathOnly = self._layer.copy().bezierPath() # Path Only bezierPathWithComponents = self._layer.copyDecomposedLayer().bezierPath() # Path & Components except: # Glyphs 2.3 bezierPathOnly = self._layer.copy().bezierPath # Path Only bezierPathWithComponents = self._layer.copyDecomposedLayer().bezierPath # Path & Components scale = NSAffineTransform.transform() scale.translateXBy_yBy_( rectWidth/2 - (layerWidth / 2.0) + self._margin/2, -descender + self._margin/2 ) scale.scaleBy_( scaleFactor ) if bezierPathWithComponents: bezierPathWithComponents.transformUsingAffineTransform_( scale ) if bezierPathOnly: bezierPathOnly.transformUsingAffineTransform_( scale ) ## DRAW COMPONENTS IN GRAY NSColor.darkGrayColor().set() # lightGrayColor bezierPathWithComponents.fill() ## CHANGE COLOR FOR NON-EXPORTED GLYPHS thisGlyph = self._layer.parent if thisGlyph.export: NSColor.blackColor().set() ## DRAW ONLY PATH IN BLACK if bezierPathOnly: bezierPathOnly.fill() else: NSColor.orangeColor().set() bezierPathWithComponents.fill() # print self.bounds() ## AUTO-WIDTH LABEL if self._layer.hasAlignedWidth(): paragraphStyle = NSMutableParagraphStyle.alloc().init() paragraphStyle.setAlignment_(2) ## 0=L, 1=R, 2=C, 3=justified attributes = {} attributes[NSFontAttributeName] = NSFont.systemFontOfSize_(10) attributes[NSForegroundColorAttributeName] = NSColor.lightGrayColor() attributes[NSParagraphStyleAttributeName] = paragraphStyle String = NSAttributedString.alloc().initWithString_attributes_("Auto-Width", attributes) # String.drawAtPoint_((rectWidth, 0)) NSColor.redColor().set() # NSRectFill(((0, 0), (self.rect.size.width, 15))) String.drawInRect_(((0, 0), (self.rect.size.width, 15))) except: # pass print traceback.format_exc()
def layout(self): self._thumbnail = ThumbnailBoxView.alloc().initWithFrame_(NSZeroRect) self._thumbnail.setImage_(Images.Box64) self._thumbnail.setImageAlignment_(NSImageAlignCenter) self._thumbnail.setImageScaling_(NSScaleToFit) self._thumbnail.setFrameSize_(self.THUMBNAIL_SIZE) self._thumbnail.setFrameOrigin_(self.THUMBNAIL_ORIGIN) self._thumbnail.setShadowOffset_(self.SHADOW_OFFSET) self._thumbnail.setShadowBlurRadius_(self.SHADOW_BLUR) self._thumbnail.setShadowColor_(NSColor.blackColor().colorWithAlphaComponent_(0.3)) self._label = NSTextField.createLabelWithText_font_('', NSFont.boldSystemFontOfSize_(13)) self._label.setFrameOrigin_(self.LABEL_ORIGIN) self._progress_bar = NSProgressIndicator.alloc().initWithFrame_(NSRect(self.PROGRESS_ORIGIN, self.PROGRESS_SIZE)) self._progress_bar.setStyle_(NSProgressIndicatorBarStyle) self._progress_bar.setIndeterminate_(YES) self._progress_bar.setFrameOrigin_(self.PROGRESS_ORIGIN) self._estimate = NSTextField.createLabelWithText_font_('', NSFont.systemFontOfSize_(NSFont.smallSystemFontSize())) self._estimate.setFrameOrigin_(self.ESTIMATE_ORIGIN) self._hide_button = self.addNormalRoundButtonWithTitle_action_(MiscStrings.hide_button, self.handleHideButton_) self._hide_button.setKeyEquivalent_(ENTER_KEY) self._hide_button.alignRightInSuperview() self._hide_button.alignBottomInSuperview() self._cancel_button = self.addNormalRoundButtonWithTitle_action_(MiscStrings.cancel_button, self.handleCancelButton_) self._cancel_button.placeLeftOfButton_(self._hide_button) self.addSubview_(self._thumbnail) self.addSubview_(self._label) self.addSubview_(self._progress_bar) self.addSubview_(self._estimate) @message_sender(AppHelper.callAfter) def handleMessage(message): self._label.setStringValue_(message) self._label.sizeToFit() @message_sender(AppHelper.callAfter) def handleTotalBytes(total_bytes): self._progress_bar.setIndeterminate_(YES if total_bytes == 0 else NO) self._progress_bar.setMinValue_(0.0) self._progress_bar.setMaxValue_(total_bytes) self._progress_bar.setDoubleValue_(self.ui.cur_bytes.get()) @message_sender(AppHelper.callAfter) def handleCurBytes(cur_bytes): self._progress_bar.setDoubleValue_(cur_bytes) self._estimate.setStringValue_(self.ui.get_remaining_message()) self._estimate.sizeToFit() @message_sender(AppHelper.callAfter) def handleLastPhoto(path): if path: if time.time() - self.last_photo_time > self.THUMBNAIL_TIMEOUT: image = NSImage.alloc().initByReferencingFile_(unicode(path)) if image.isValid(): self._thumbnail.setBorder_(True) self._thumbnail.setImage_(image) self.last_photo_time = time.time() else: self._thumbnail.setBorder_(False) self._thumbnail.setImage_(Images.Box64) handleMessage(self.ui.message.get()) handleTotalBytes(self.ui.total_bytes.get()) handleCurBytes(self.ui.cur_bytes.get()) handleLastPhoto(self.ui.last_photo.get()) self.ui.message.register(handleMessage) self.ui.total_bytes.register(handleTotalBytes) self.ui.cur_bytes.register(handleCurBytes) self.ui.last_photo.register(handleLastPhoto)
def layout(self): height = self.BORDER + self.IMAGE_PADDING width = self.VIEW_SIZE[0] - self.BORDER * 2 image = NonBlurryImageView.alloc().initWithFrame_(NSZeroRect) image.setImage_(self.image) image.setFrameSize_(self.image.size()) self.addSubview_(image) image.setFrameOrigin_((0, height)) image.centerHorizontallyInSuperview() height += NSHeight(image.frame()) + self.HEADER_PADDING label1 = NSTextField.createLabelWithText_font_maxWidth_origin_(self.header, NSFont.boldSystemFontOfSize_(self.HEADER_SIZE) if self.BOLD_HEADER else NSFont.systemFontOfSize_(self.HEADER_SIZE), width, NSPoint(0, height)) self.addSubview_(label1) label1.centerHorizontallyInSuperview() label1.setTextColor_(self.HEADER_COLOR) height += NSHeight(label1.frame()) + self.SUBHEADER_PADDING label2 = NSTextField.createLabelWithText_font_maxWidth_origin_(NSAttributedString.boldify(self.subheader, font=NSFont.systemFontOfSize_(self.SUBHEADER_SIZE), bold_font=NSFont.boldSystemFontOfSize_(self.SUBHEADER_SIZE), center=True, line_height=self.SUBHEADER_LINE_HEIGHT), NSFont.systemFontOfSize_(self.SUBHEADER_SIZE), width, NSPoint(0, height)) self.addSubview_(label2) label2.setAlignment_(NSCenterTextAlignment) label2.setTextColor_(self.SUBHEADER_COLOR) label2.balancedWrapToWidth_(width) label2.centerHorizontallyInSuperview() if self.checkbox_text: checkbox = NSButton.alloc().initWithFrame_(NSZeroRect) self.addSubview_(checkbox) checkbox.setButtonType_(NSSwitchButton) checkbox.setAttributedTitle_(NSAttributedString.boldify(self.checkbox_text, font=NSFont.systemFontOfSize_(self.CHECKBOX_SIZE), bold_font=NSFont.boldSystemFontOfSize_(self.CHECKBOX_SIZE))) checkbox.setTextColor_(Colors.camera_font) checkbox.sizeToFit() if NSWidth(checkbox.frame()) > width: checkbox.setAttributedTitle_(CameraStrings.splash_always_import_no_name) checkbox.setTextColor_(Colors.camera_font) checkbox.sizeToFit() checkbox.setState_(True) checkbox.centerHorizontallyInSuperview() checkbox.alignBottomInSuperview(self.BORDER - checkbox.flippedBaselineOffset()) self.checkbox = checkbox else: self.checkbox = None height += NSHeight(label2.frame()) + self.FINE_PRINT_PADDING if self.fine_print: fine_print = NSTextField.createLabelWithText_font_maxWidth_origin_(self.fine_print, NSFont.systemFontOfSize_(self.FINE_PRINT_SIZE), width, NSPoint(0, height)) self.addSubview_(fine_print) fine_print.setAlignment_(NSCenterTextAlignment) fine_print.setTextColor_(Colors.fine_print) fine_print.balancedWrapToWidth_(width) fine_print.centerHorizontallyInSuperview() self.fine_print_label = fine_print else: self.fine_print_label = None self.combo = None if self.choice_selector: subview = NSView.alloc().initWithFrame_(NSZeroRect) combo_descriptor = NSTextField.createLabelWithText_(NSAttributedString.boldify(self.choice_selector.text, font=NSFont.systemFontOfSize_(NSRegularControlSize), bold_font=NSFont.boldSystemFontOfSize_(NSRegularControlSize))) combo_descriptor.setTextColor_(self.SUBHEADER_COLOR) subview.addSubview_(combo_descriptor) combo = NSPopUpButton.createNormalPopUpButtonWithChoices_default_(self.choice_selector.selections, self.choice_selector.default_index) combo.sizeToFit() subview.addSubview_(combo) descriptor_frame = combo_descriptor.frame() half = combo.frame().size.height / 2.0 descriptor_half = descriptor_frame.size.height / 2.0 combo_descriptor.setFrameOrigin_(NSPoint(descriptor_frame.origin.x, half - descriptor_half + 2.0)) combo.setFrameOrigin_(NSPoint(descriptor_frame.origin.x + descriptor_frame.size.width, 0)) subview.setFrameSize_((combo.frame().size.width + descriptor_frame.size.width, combo.frame().size.height)) self.addSubview_(subview) subview.centerHorizontallyInSuperview() subview.alignBottomInSuperview(CONTENT_BORDER + self.CHOICE_SELECTOR_PADDING) self.combo = combo
def _drawArrow(position, kind, size, vector=(-1, 1), label_size=1): angle = atan2(vector[0], -vector[1]) print vector, "%0.2f°" % degrees(angle) x, y = position head_ratio = 0.7 w = size * 0.5 tail_width = 0.3 chin = 0.5 * (w - w * tail_width) # part under the head NSColor.colorWithCalibratedRed_green_blue_alpha_( 0.9, 0.1, 0.0, 0.85 ).set() t = NSAffineTransform.transform() t.translateXBy_yBy_(x, y) t.rotateByRadians_(angle) myPath = NSBezierPath.alloc().init() myPath.moveToPoint_( (0, 0) ) myPath.relativeLineToPoint_( (-size * head_ratio, w * 0.5) ) myPath.relativeLineToPoint_( (0, -chin) ) myPath.relativeLineToPoint_( (-size * (1 - head_ratio), 0) ) myPath.relativeLineToPoint_( (0, -w * tail_width) ) myPath.relativeLineToPoint_( (size * (1 - head_ratio), 0) ) myPath.relativeLineToPoint_( (0, -chin) ) myPath.closePath() myPath.transformUsingAffineTransform_(t) myPath.fill() drawPath(myPath) myString = NSString.string().stringByAppendingString_(kind) attrs = { NSFontAttributeName: NSFont.systemFontOfSize_(label_size), NSForegroundColorAttributeName: NSColor.colorWithCalibratedRed_green_blue_alpha_( 0.4, 0.4, 0.6, 0.7 ), } bbox = myString.sizeWithAttributes_(attrs) #print bbox p = NSPoint() bw = bbox.width bh = bbox.height #print " ", cos(angle) if -0.5 * pi < angle <= 0.5 * pi: p.x, p.y = ( - size - 20 - bh/2 * sin(angle) - bw/2 * cos(angle), # + bw/2.0 * cos(angle - pi) 0 ) else: p.x, p.y = ( - size - 20 + bh/2 * sin(angle) + bw/2 * cos(angle), # + bw/2.0 * cos(angle - pi) 0, ) p = t.transformPoint_(p) #print p #fontSize(label_size) #text(kind, (p.x - bbox.width/2, p.y - bbox.height/2)) fill(None) rect(p.x - bbox.width/2, p.y - bbox.height/2, bbox.width, bbox.height) fill(1, 0, 0) #oval(p.x -bh/2.0 , p.y -bh/2.0, bh, bh) #myString.drawAtPoint_withAttributes_(p, attrs) rr = NSRect(origin=(p.x -bh/2.0, p.y -bw/2.0), size=(bw, bh)) #print rr myString.drawInRect_withAttributes_(rr, attrs) myString.drawAtPoint_withAttributes_(p, attrs)