Esempio n. 1
0
def getMimeType (filepath):
    mimetype, accuracy= KMimeType.findByFileContent (filepath)
    if accuracy<50:
        # try harder?
        # BUG?: (in KMimeType) gets confused by filenames with #'s
        # mimetype, accuracy= KMimeType.findByUrl (KUrl (utils.path2qurl (filepath)), 0, False, True)
        mimetype, accuracy= KMimeType.findByUrl (KUrl (utils.path2qurl (filepath)))

    return str (mimetype.name ())
Esempio n. 2
0
def from_mime_type_or_extension(mimeType, extension):
    """ Return a file type object matching the given MIME type and/or extension. """
    if not mimeType and not extension:
        raise ValueError("At least the MIME type or extension should be specified")
    elif not mimeType:
        type, confidence = KMimeType.findByPath("foo" + extension, 0, True)
        return KDEType(type)
    else:
        type = KMimeType.mimeType(mimeType)
        return KDEType(type)
    def kioFiles(self, itemlist):
        if type(itemlist) != list:
            urlList = []
            for item in itemlist:
                urlList.append(dict(url=item.url().url(), isDir=item.isDir()))
            self.cache[self.cacheUrl] = urlList

        urls = []

        for ifile in itemlist:
            if type(ifile) == dict:
                url = KUrl(ifile["url"])
                isDir = ifile["isDir"]
            else:
                url = ifile.url()
                isDir = ifile.isDir()

            path = url.url()
            if isDir and not path.endswith("/"):
                path += "/"

            if self.includeFilters:
                matched = False
                i = 0
                while not matched and i < len(self.includeFilters):
                    if self.includeFilters[i].search(path):
                        matched = True
                    i += 1
                if not matched:
                    continue

            if self.excludeFilters:
                matched = False
                for excludeFilter in self.excludeFilters:
                    if excludeFilter.search(path):
                        matched = True
                        break
                if matched:
                    continue

            if isDir:
                if self.recursion < self.maxRecursion:
                    self.dirStack.append((self.recursion + 1, url))
            else:
                mime = KMimeType.findByUrl(url)[0]
                if self.validMime(mime):
                    urls.append(url)

        urls = sorted(urls, lambda a, b: -1 if len(a.url()) < len(b.url()) else 1)

        for url in urls:
            self.fileFound.emit(url)
    def addFileUrl(self, url, reason=None):
        if url not in self.urls:
            mime = KMimeType.findByUrl(url)[0]
            path = url.url()
            filename = url.fileName()

            item = QListWidgetItem()
            if self.project and path.startswith(self.project):
                path = path[len(self.project):]
                item.setWhatsThis(path)
                item.setText("<b>%s</b>: <i>%s</i>" % (filename, path))
            else:
                item.setWhatsThis(filename)
                item.setText("<b>%s</b>" % filename)
            if reason:
                item.setToolTip(reason)
            item.setIcon(QIcon(self.iconLoader.loadMimeTypeIcon(mime.iconName(), KIconLoader.Small)))
            self.listUrl.addItem(item)

            if url.fileName().find(self.txtFilter.text()) < 0:
                self.listUrl.setItemHidden(item, True)
            self.urls.append(url)

            self.refreshFilter()
Esempio n. 5
0
def from_file(path):
    """ Try to guess the type of a file. """
    type, confidence = KMimeType.findByPath(path)
    return KDEType(type)