Python Foundation.NSURL类代码示例

            def _pyobjc_notify(message, title=None, subtitle=None, appIcon=None, contentImage=None, open_URL=None, delay=0, sound=False):

                swizzle(objc.lookUpClass('NSBundle'),
                        b'bundleIdentifier',
                        swizzled_bundleIdentifier)
                notification = NSUserNotification.alloc().init()
                notification.setInformativeText_(message)
                if title:
                    notification.setTitle_(title)
                if subtitle:
                    notification.setSubtitle_(subtitle)
                if appIcon:
                    url = NSURL.alloc().initWithString_(appIcon)
                    image = NSImage.alloc().initWithContentsOfURL_(url)
                    notification.set_identityImage_(image)
                if contentImage:
                    url = NSURL.alloc().initWithString_(contentImage)
                    image = NSImage.alloc().initWithContentsOfURL_(url)
                    notification.setContentImage_(image)

                if sound:
                    notification.setSoundName_(
                        "NSUserNotificationDefaultSoundName")
                notification.setDeliveryDate_(
                    NSDate.dateWithTimeInterval_sinceDate_(delay, NSDate.date()))
                NSUserNotificationCenter.defaultUserNotificationCenter().scheduleNotification_(
                    notification)

    def next_image(self, _):

        if not os.path.exists(self.media_dir):
            os.makedirs(self.media_dir)

        url = 'https://unsplash.it/'
        if self.gray_mood: url += 'g/'
        url += '{w}/{h}/?random'
        if self.blur: url += '&blur'

        url = url.format(w=self.screen_width, h=self.screen_height)
        file_name = self.media_dir + datetime.datetime.now().strftime("%H:%M:%S.%f") + '.jpg'

        try:
            self.icon = 'img/wait.png'
            urllib.urlretrieve(url, file_name)
            file_url = NSURL.fileURLWithPath_(file_name)

            # Get shared workspace
            ws = NSWorkspace.sharedWorkspace()

            # Iterate over all screens
            for screen in NSScreen.screens():
                # Tell the workspace to set the desktop picture
                (result, error) = ws.setDesktopImageURL_forScreen_options_error_(
                    file_url, screen, {}, None)
            self.icon = 'img/icon.png'
        except IOError:
            print('Service unavailable, check your internet connection.')
            rumps.alert(title='Connection Error', message='Service unavailable\n'
                                                          'Please, check your internet connection')

def exportAllInstances():
	'''
	This will export all instances of the font at 'path' as TrueType fonts.
	'''
	path = os.path.expanduser("~/Desktop/test/file.glyphs")
	doc = Glyphs.openDocumentWithContentsOfFile_display_(path, False)
	print "Exporting:", doc.displayName()
	font = doc.font()
	for instance in font.instances():
		print "Instance:", instance
		instance.generate_({
			'ExportFormat': "TTF",
			'ExportContainer': "woff",
			'Destination': NSURL.fileURLWithPath_(os.path.expanduser("~/Desktop/test/"))
		})
		
	'''
	possible keys:
		ExportContainer: "woff", "woff2", "eot"
		Destination: NSURL
		autoHint: bool (default = true)
		removeOverlap: bool (default = true)
		useSubroutines: bool (default = true)
		useProductionNames: bool (default = true)
	'''
	
	doc.close()
	print "Ready!"

def change_desktop_background(file, desk_id):
    """Function that applies the named file as wallaper for the specified
    monitor (desk_id)"""
    file_url = NSURL.fileURLWithPath_(file)
    screen   = NSScreen.screens()[desk_id]
    ws       = NSWorkspace.sharedWorkspace()
    ws.setDesktopImageURL_forScreen_options_error_(file_url, screen, {}, None)

def set_desktop_background(desktop_picture_path):
    file_url = NSURL.fileURLWithPath_(desktop_picture_path)
    ws = NSWorkspace.sharedWorkspace()

    screens = NSScreen.screens()
    for screen in screens:
        ws.setDesktopImageURL_forScreen_options_error_(file_url, screen, {}, None)

def LoadImageFromPath( path ):

    url = NSURL.fileURLWithPath_(path)
    NSLog( "LoadImageFromPath( %@ )",  url  );

    #
    #   Create image source from URL
    #
    #   An image source abstracts the data-access task and eliminates the need for you to manage data through a raw memory buffer. 
    #   An image source can contain more than one image, thumbnail images, and properties for each image and the image file. 
    #   When you are working with image data and your application runs in Mac OS X v10.4 or later, image 
    #     sources are the preferred way to move image data into your application.
    #
    #   CGImageSource objects, available in Mac OS X v10.4 or later, abstract the data-reading task. An image source can 
    #     read image data from a   URL, a CFData object, or a data consumer. After creating a CGImageSource object for the 
    #     appropriate source, you can obtain images, thumbnails, image properties, and other image information using CGImageSource functions.
    #
    #   CGImageSourceCreateWithURL ==> Creates an image source that reads from a location specified by a URL.
    #
    #   CGImageSourceCreateImageAtIndex ==> Creates a CGImage object for the image data associated with the specified index in an image source.
    #     Create an image from the first item in the image source.                                                   
    
    imagesrc = CGImageSourceCreateWithURL(url, None)        
#    NSLog( "LoadImageFromPath: imagesrc is %r" % (imagesrc,) )

    theImage = CGImageSourceCreateImageAtIndex(imagesrc, 0, None);
#    NSLog( "LoadImageFromPath: theImage is %r" % (theImage,) )
    
    return theImage

def set_background(image_file):
    from AppKit import NSWorkspace, NSScreen
    from Foundation import NSURL
    file_url = NSURL.fileURLWithPath_(image_file)
    ws = NSWorkspace.sharedWorkspace()
    for screen in NSScreen.screens():
        ws.setDesktopImageURL_forScreen_options_error_(file_url, screen, {}, None)

    def export(self, canvasname, file, format='pdf', force=False, is_checksum=False):
        """
        Exports one canvas named {@code canvasname}
        """

        format = format.lower()

        chksum = None
        if os.path.isfile(file) and not force:
            existing_chksum = checksum(file) if format != 'pdf' \
                                             else checksum_pdf(file)
            new_chksum = self.compute_canvas_checksum(canvasname)

            if existing_chksum == new_chksum and existing_chksum != None:
                logging.debug('No exporting - canvas %s not changed' % 
                              canvasname)
                return False
            else:
                chksum = new_chksum

        elif format == 'pdf':
            chksum = self.compute_canvas_checksum(canvasname)

        win = self.og.windows.first()

        canvas = [c for c in self.doc.canvases() if c.name() == canvasname]
        if len(canvas) == 1:
            canvas = canvas[0]
        else:
            logging.warn('Canvas %s does not exist in %s' % 
                         (canvasname, self.schemafile))
            return False

        self.og.set(win.canvas, to=canvas)

        export_format = OmniGraffleSchema.EXPORT_FORMATS[format]
        if (export_format == None):
            self.doc.save(in_=file)
        else:
            self.doc.save(as_=export_format, in_=file)

        if not is_checksum and self.options.verbose:
            print "%s" % file

        logging.debug("Exported `%s' into `%s' as %s" % (canvasname, file, format))

        if format == 'pdf':
            # save the checksum
            url = NSURL.fileURLWithPath_(file)
            pdfdoc = PDFKit.PDFDocument.alloc().initWithURL_(url)
            attrs = NSMutableDictionary.alloc().initWithDictionary_(pdfdoc.documentAttributes())

            attrs[PDFKit.PDFDocumentSubjectAttribute] = \
                '%s%s' % (OmniGraffleSchema.PDF_CHECKSUM_ATTRIBUTE, chksum)

            pdfdoc.setDocumentAttributes_(attrs)
            pdfdoc.writeToFile_(file)

        return True

def update_appcast(oldVersion, newVersion, appcastSignature, tarballName, fileSize, minimumSystemVersion, download_url):
    
    appcastDate = strftime("%a, %d %b %Y %H:%M:%S +0000", gmtime())

    # creating this from a string is easier than manipulating NSXMLNodes...
    newItemString = """<?xml version="1.0" encoding="utf-8"?>
    <rss version="2.0" xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle"  xmlns:dc="http://purl.org/dc/elements/1.1/">
       <channel>
       <item>
            <title>Version """ + newVersion + """</title>
            <description>
    	    <h3>Changes Since """ + str(oldVersion) + """</h3>
    	        <li></li>
    	        <li></li>
            </description>
            <pubDate>""" + appcastDate + """</pubDate>
            <sparkle:minimumSystemVersion>""" + minimumSystemVersion + """</sparkle:minimumSystemVersion>
            <enclosure url=\"""" + download_url + """\" sparkle:version=\"""" + newVersion + """\" length=\"""" + fileSize + """\" type="application/octet-stream" sparkle:dsaSignature=\"""" + appcastSignature + """\" />
        </item>
        </channel>
    </rss>"""

    # read from the source directory
    appcastURL = NSURL.fileURLWithPath_(APPCAST_PATH)

    # xml doc from the current appcast
    (oldDoc, error) = NSXMLDocument.alloc().initWithContentsOfURL_options_error_(appcastURL, 0, None)
    assert oldDoc is not None, error

    # xml doc from the new appcast string
    (newDoc, error) = NSXMLDocument.alloc().initWithXMLString_options_error_(newItemString, 0, None)
    assert newDoc is not None, error

    # get an arry of the current item titles
    (oldTitles, error) = oldDoc.nodesForXPath_error_("//item/title", None)
    assert oldTitles.count > 0, "oldTitles had no elements"

    # now get the title we just created
    (newTitles, error) = newDoc.nodesForXPath_error_("//item/title", None)
    assert newTitles.count() is 1, "newTitles must have a single element"

    # easy test to avoid duplicating items
    if oldTitles.containsObject_(newTitles.lastObject()) is False:

        # get the parent node we'll be inserting to
        (parentChannel, error) = oldDoc.nodesForXPath_error_("//channel", None)
        assert parentChannel.count() is 1, "channel count must be one"
        parentChannel = parentChannel.lastObject()

        # now get the new node
        (newNodes, error) = newDoc.nodesForXPath_error_("//item", None)
        assert newNodes is not None, error

        # insert a copy of the new node
        parentChannel.addChild_(newNodes.lastObject().copy())

        # write to NSData, since pretty printing didn't work with NSXMLDocument writing
        oldDoc.XMLDataWithOptions_(NSXMLNodePrettyPrint).writeToURL_atomically_(appcastURL, True)

def renderTemplate(webView: WebView, name: str, **values):
    html = render_template(name, **values)
    frame = webView.mainFrame()
    resource_path = os.environ.get('RESOURCEPATH', os.path.dirname(__file__))
    logger.debug('resource_path = %r', resource_path)
    baseUrl = NSURL.fileURLWithPath_(
        os.path.join(resource_path, 'static', '')
    )
    frame.loadHTMLString_baseURL_(html, baseUrl)

def removePage(filename):
	filename = filename.decode('utf-8')
	pdfURL = NSURL.fileURLWithPath_(filename)
	pdfDoc = PDFDocument.alloc().initWithURL_(pdfURL)
	if pdfDoc:
		pageNum = pdfDoc.pageCount()
		if pageNum > 1:
			pdfDoc.removePageAtIndex_(0)
			pdfDoc.writeToFile_(filename)
	return

def setBackgroundOSX(fullPath):
    # generate a fileURL for the desktop picture
    file_path = NSURL.fileURLWithPath_(fullPath)
    # get shared workspace
    ws = NSWorkspace.sharedWorkspace()
    # iterate over all screens
    for screen in NSScreen.screens():
        # tell the workspace to set the desktop picture
        (result, error) = ws.setDesktopImageURL_forScreen_options_error_(
            file_path, screen, {}, None)

def set_wallpaper_image(imgs, mode='stretched'):
    """Set the given file as wallpaper."""
    if not len(imgs):
        return

    default_image = imgs[0]
    file_url = NSURL.fileURLWithPath_(default_image)
    options = {}
    ws = NSWorkspace.sharedWorkspace()
    for screen in NSScreen.screens():
      (result, error) = ws.setDesktopImageURL_forScreen_options_error_(file_url, screen, options, None)

def checksum_pdf(filepath):
    assert os.path.isfile(filepath), '%s is not a file' % filepath

    url = NSURL.fileURLWithPath_(filepath)
    pdfdoc = PDFKit.PDFDocument.alloc().initWithURL_(url)
    assert pdfdoc != None
    chksum = pdfdoc.documentAttributes()[PDFKit.PDFDocumentSubjectAttribute]

    if not chksum.startswith(OmniGraffleSchema.PDF_CHECKSUM_ATTRIBUTE):
        return None
    else:
        return chksum[len(OmniGraffleSchema.PDF_CHECKSUM_ATTRIBUTE):]

def save_dialog(directory, filename):
	panel = NSSavePanel.savePanel()
	panel.setTitle_("Save PDF booklet")
	myUrl = NSURL.fileURLWithPath_isDirectory_(directory, True)
	panel.setDirectoryURL_(myUrl)
	panel.setNameFieldStringValue_(filename)
	NSApp.activateIgnoringOtherApps_(True)
	ret_value = panel.runModal()
	if ret_value:
		return panel.filename()
	else:
		return ''