Example #1
0
    def run(self):
        while not self.killed:
            try:
                frame = self.inqueue.get(True, 0.1)
            except queue.Empty:
                pass
            else:
                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                wid, hei = self.vid_size

                # ~ frame = cv2.resize(  # faster at BILINEAR scaling
                # ~ frame, None, (wid, hei),
                # ~ interpolation=cv2.INTER_LINEAR
                # ~ )

                bytes1 = frame.tobytes()
                bytes2 = GLib.Bytes(bytes1)

                pb = GdkPixbuf.Pixbuf.new_from_bytes(bytes2,
                                                     GdkPixbuf.Colorspace.RGB,
                                                     False, 8, WIDTH, HEIGHT,
                                                     WIDTH * 3)
                pb = pb.scale_simple(  # Faster at NEAREST scaling
                    wid, hei, GdkPixbuf.InterpType.BILINEAR)
                self.outqueue.put(pb)
Example #2
0
    def receive_data(self, s):
        save_path = prefs.get_save_path()

        path = os.path.join(save_path, s.relative_path)
        if path != self.current_path:
            if self.current_stream:
                self.current_stream.close()
                self.current_stream = None
                self.current_gfile = None

            self.current_path = path

        if s.file_type == FileType.DIRECTORY:
            os.makedirs(path, exist_ok=True)
        elif s.file_type == FileType.SYMBOLIC_LINK:
            absolute_symlink_target_path = os.path.join(
                save_path, s.symlink_target)
            make_symbolic_link(self.op, path, absolute_symlink_target_path)
        else:
            if not self.current_gfile:
                self.current_gfile = Gio.File.new_for_path(path)

                flags = Gio.FileCreateFlags.REPLACE_DESTINATION
                self.current_stream = self.current_gfile.replace(
                    None, False, flags, None)

            length = len(s.chunk)
            if length == 0:
                return

            self.current_stream.write_bytes(GLib.Bytes(s.chunk), None)
            self.op.progress_tracker.update_progress(length)
Example #3
0
    def _on_epub_scheme(self, request):
        """Callback function for epub scheme requests

        Finish a WebKit2.URISchemeRequest by setting the contents of
        the request and its mime type.

        Args:
            request (WebKit2.URISchemeRequest)
        """
        if not self.doc:
            return

        uri = request.get_uri()

        try:
            path, fragment = self._get_path_fragment(uri)
        except BookError as e:
            error_str = e.args[1]
            request.finish_error(GLib.Error(error_str))
            return

        if self.doc.is_page(path):
            self.set_chapter_path_fragment(path, fragment)
            return

        resource_content = self.doc.get_resource_content(path)
        resource_gbytes = GLib.Bytes(resource_content)
        stream = Gio.MemoryInputStream.new_from_bytes(resource_gbytes)
        stream_length = resource_gbytes.get_size()
        mime = self.doc.get_resource_mime(path)

        request.finish(stream, stream_length, mime)
Example #4
0
 def get_message(self, source_object, res, *user_data):
     """Callback function to read network data, split it into
     WeeChat messages that are passed on to the application.
     """
     try:
         gbytes = self.input.read_bytes_finish(res)
     except GLib.Error as err:
         self.handle_network_error(err)
         return
     if gbytes is None:
         # Error, try again
         self.input.read_bytes_async(
             4096, 0, self.cancel_network_reads, self.get_message)
         return
     bytes_received = gbytes.get_size()
     if bytes_received <= 0:
         # Empty message or error, try another read
         print("Empty message error")
         return
     self.message_buffer = self.message_buffer+gbytes.get_data()
     while len(self.message_buffer) >= 4:
         length = struct.unpack('>i', self.message_buffer[0:4])[0]
         if length <= len(self.message_buffer):
             self.emit("messageFromWeechat", GLib.Bytes(
                 self.message_buffer[0:length]))
             self.message_buffer = self.message_buffer[length:]
         else:
             break
     self.input.read_bytes_async(
         4096, 0, self.cancel_network_reads, self.get_message)
Example #5
0
 def add(prefix, content, data, suffix):
     """
         Add info to store
         @param prefix as str
         @param content as str
         @param data as bytes
         @param suffix as str
     """
     filepath = "%s/%s_%s" % (InfoCache._INFO_PATH, escape(prefix), suffix)
     if content is not None:
         f = Gio.File.new_for_path(filepath + ".txt")
         fstream = f.replace(None, False,
                             Gio.FileCreateFlags.REPLACE_DESTINATION, None)
         if fstream is not None:
             fstream.write(content, None)
             fstream.close()
     if data is None:
         f = Gio.File.new_for_path(filepath + ".jpg")
         fstream = f.replace(None, False,
                             Gio.FileCreateFlags.REPLACE_DESTINATION, None)
         fstream.close()
     else:
         bytes = GLib.Bytes(data)
         stream = Gio.MemoryInputStream.new_from_bytes(bytes)
         bytes.unref()
         pixbuf = GdkPixbuf.Pixbuf.new_from_stream_at_scale(
             stream, ArtSize.ARTIST, -1, True, None)
         stream.close()
         pixbuf.savev(
             filepath + ".jpg", "jpeg", ["quality"],
             [str(Lp().settings.get_value("cover-quality").get_int32())])
Example #6
0
    def redraw_rect(self, widget, cairo_ctx):
        result, r = Gdk.cairo_get_clip_rectangle(cairo_ctx)
        if result:
            x, y, w, h = r.x, r.y, r.width, r.height
        else:
            print("Skipping drawing because entire context clipped")
            return

        try:
            buf = self.image.image_buffer(x, y)
        except MemoryError as err:
            # suppress these errors
            return

        pixbuf = GdkPixbuf.Pixbuf.new_from_bytes(
            GLib.Bytes(buf),
            GdkPixbuf.Colorspace.RGB,
            False,
            8,
            min(self.width - x, w),
            min(self.height - y, h),
            self.width * 3)
        Gdk.cairo_set_source_pixbuf(cairo_ctx, pixbuf.copy(), x, y)
        cairo_ctx.paint()

        if self.selection_rect:
            cairo_ctx.set_source_rgb(1.0, 1.0, 1.0)
            cairo_ctx.set_line_width(T.SELECTION_LINE_WIDTH)
            cairo_ctx.rectangle(*self.selection_rect)
            cairo_ctx.stroke()
Example #7
0
 def pixbuf_from_tags(self, uri, size):
     """
         Return cover from tags
         @param uri as str
         @param size as int
     """
     pixbuf = None
     if uri.startswith("http:") or uri.startswith("https:"):
         return
     try:
         info = self.get_info(uri)
         exist = False
         if info is not None:
             (exist, sample) = info.get_tags().get_sample_index("image", 0)
             # Some file store it in a preview-image tag
             if not exist:
                 (exist, sample) = info.get_tags().get_sample_index(
                     "preview-image", 0)
         if exist:
             (exist, mapflags) = sample.get_buffer().map(Gst.MapFlags.READ)
         if exist:
             bytes = GLib.Bytes(mapflags.data)
             stream = Gio.MemoryInputStream.new_from_bytes(bytes)
             bytes.unref()
             pixbuf = GdkPixbuf.Pixbuf.new_from_stream_at_scale(
                 stream, size, size, False, None)
             stream.close()
     except Exception as e:
         print("AlbumArt::pixbuf_from_tags():", e)
     return pixbuf
Example #8
0
def connection_from_dict(data):
    con = NM.SimpleConnection.new()
    for setting_name, setting_data in data.items():
        typ = NM.Setting.lookup_type(setting_name).pytype
        setting = typ()
        for k, v in setting_data.items():
            if not v:
                continue

            if k == 'mac-address':
                v = ':'.join("%02X" % x for x in v)
            elif k == 'ssid':
                if isinstance(v, str):
                    v = v.encode()
                v = GLib.Bytes(v)
            elif k == 'addresses':
                # setting addresses via the property doesn't seem to work
                for x in v:
                    setting.add_address(address_from_str(x))
                v = None

            if not v:
                continue
            try:
                setting.set_property(k, v)
            except TypeError as e:
                raise TypeError("Failed to set propery {}".format(k)) from e
        con.add_setting(setting)
    return con
Example #9
0
    def remote_load_request(self, request: RequestFromScrapy):
        # WebKitGTK does not support setting headers or method when loading
        # request. Instead, make the request and set it as the content.
        remote_req = RequestFromBrowser(
            url=request.url,
            method=request.method,
            headers=request.headers,
            body=request.body,
            is_first_request=True,
            cookiejarkey=self._options.get('cookiejarkey'))
        response = yield self._downloader.callRemote('make_request',
                                                     remote_req)

        # Scrapy's Headers object keeps headers in title case.
        ctype = response.headers.get(b'Content-Type')
        if ctype:
            mime_type, mime_type_params = cgi.parse_header(ctype[0].decode())
            enconding = mime_type_params.get('charset')
        else:
            mime_type = None
            enconding = None

        load_finished = self._load_finished(self._webview)

        self._webview.load_bytes(GLib.Bytes(response.body), mime_type,
                                 enconding, request.url)

        yield load_finished

        # TODO: report load errors.
        return (True, response.status, response.headers, None)
 def __add_pixbuf(self, uri, loaded, content, callback, *args):
     """
         Add uri to the view and load callback
         @param uri as str
         @param loaded as bool
         @param content as bytes
         @param callback as function
     """
     if self.__cancellable.is_cancelled():
         return
     try:
         if loaded:
             scale_factor = self.get_scale_factor()
             bytes = GLib.Bytes(content)
             stream = Gio.MemoryInputStream.new_from_bytes(bytes)
             if stream is not None:
                 big = GdkPixbuf.Pixbuf.new_from_stream_at_scale(
                     stream, ArtSize.BIG * scale_factor,
                     ArtSize.BIG * scale_factor, True, None)
                 stream.close()
             image = Gtk.Image()
             image.get_style_context().add_class("cover-frame")
             image.set_property("halign", Gtk.Align.CENTER)
             image.set_property("valign", Gtk.Align.CENTER)
             self.__contents[image] = content
             surface = Gdk.cairo_surface_create_from_pixbuf(
                 big, scale_factor, None)
             image.set_from_surface(surface)
             image.show()
             self.__view.add(image)
     except Exception as e:
         Logger.error("ArtworkSearch::__add_pixbuf: %s" % e)
     callback(*args)
Example #11
0
 def __save_artwork_tags(self, data, album):
     """
         Save artwork in tags
         @param data as bytes
         @param album as Album
     """
     if album.is_web:
         return
     # https://bugzilla.gnome.org/show_bug.cgi?id=747431
     bytes = GLib.Bytes(data)
     stream = Gio.MemoryInputStream.new_from_bytes(bytes)
     bytes.unref()
     pixbuf = GdkPixbuf.Pixbuf.new_from_stream_at_scale(
         stream, ArtSize.MONSTER, ArtSize.MONSTER, True, None)
     stream.close()
     pixbuf.savev(
         "%s/lollypop_cover_tags.jpg" % self._CACHE_PATH, "jpeg",
         ["quality"],
         [str(Lp().settings.get_value("cover-quality").get_int32())])
     f = Lio.File.new_for_path("%s/lollypop_cover_tags.jpg" %
                               self._CACHE_PATH)
     if f.query_exists():
         dbus_helper = DBusHelper()
         dbus_helper.call("CanSetCover", None, self.__on_save_artwork_tags,
                          album.id)
Example #12
0
 def show_preview(self):
     if self.preview_image != None:
         byte_in = GLib.Bytes(self.preview_image.tobytes())
         input_in = Gio.MemoryInputStream.new_from_bytes(byte_in)
         pixbuf = GdkPixbuf.Pixbuf.new_from_stream_at_scale(
             input_in, self.preview_size, self.preview_size, True)
         self.builder.get_object('image2').set_from_pixbuf(pixbuf)
Example #13
0
 def load_catalog_clicked(self, button=None):
     scale = self.builder.get_object('scale1')
     size = scale.get_value()
     self.catalog_store.clear()
     self.cursor.execute(
         "SELECT p.id, barcode, p.name, ext_name, description, "
         "COALESCE(price, 0.00), image FROM products AS p "
         "LEFT JOIN products_markup_prices AS pmp "
         "ON pmp.product_id = p.id "
         "LEFT JOIN customer_markup_percent AS cmp "
         "ON cmp.id = pmp.markup_id "
         "WHERE (catalog, standard) = (True, True) "
         "ORDER BY catalog_order")
     for row in self.cursor.fetchall():
         p_id = row[0]
         barcode = row[1]
         name = row[2]
         ext_name = row[3]
         description = row[4]
         price = row[5]
         image_bytes = row[6]
         if image_bytes == None:
             pixbuf = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, True,
                                           8, size, size)
         else:
             byte_in = GLib.Bytes(image_bytes.tobytes())
             input_in = Gio.MemoryInputStream.new_from_bytes(byte_in)
             pixbuf = GdkPixbuf.Pixbuf.new_from_stream_at_scale(
                 input_in, size, size, True)
         self.catalog_store.append(
             [p_id, barcode, name, ext_name, description, price, pixbuf])
Example #14
0
 def set_content(self, prefix, content, image_url, suffix):
     """
         populate widget with content
         @param prefix as str
         @param content as str
         @param image url as str
         @param suffix as str
         @thread safe
     """
     try:
         data = None
         stream = None
         if content is not None:
             if image_url is not None:
                 f = Lio.File.new_for_uri(image_url)
                 (status, data, tag) = f.load_contents(self.__cancel)
                 if status:
                     bytes = GLib.Bytes(data)
                     stream = Gio.MemoryInputStream.new_from_bytes(bytes)
                     bytes.unref()
                 else:
                     data = None
             InfoCache.add(prefix, content, data, suffix)
         GLib.idle_add(self.__set_content, content, stream)
     except Exception as e:
         print("InfoContent::set_content: %s" % e)
Example #15
0
 def add_artist_artwork(self, artist, data, is_web=False):
     """
         Add artist artwork to store
         @param artist as str
         @param data as bytes
         @param is_web as bool
         @thread safe
     """
     self.uncache_artist_artwork(artist)
     if is_web:
         filepath = "%s/web_%s.jpg" % (self._INFO_PATH, escape(artist))
     else:
         filepath = "%s/%s.jpg" % (self._INFO_PATH, escape(artist))
     if data is None:
         f = Gio.File.new_for_path(filepath)
         fstream = f.replace(None, False,
                             Gio.FileCreateFlags.REPLACE_DESTINATION, None)
         fstream.close()
     else:
         bytes = GLib.Bytes(data)
         stream = Gio.MemoryInputStream.new_from_bytes(bytes)
         pixbuf = GdkPixbuf.Pixbuf.new_from_stream(stream, None)
         stream.close()
         pixbuf.savev(filepath, "jpeg", ["quality"], ["100"])
     GLib.idle_add(self.emit, "artist-artwork-changed", artist)
Example #16
0
    def on_epub_scheme(self, request):
        """Callback function for epub scheme requests

        Finish a WebKit2.URISchemeRequest by setting the contents of the request
        and its mime type.

        Args:
            request (WebKit2.URISchemeRequest)
        """
        if not self.doc:
            return

        uri = request.get_uri()
        logger.info('Resource request:' + uri)
        try:
            path, fragment = self.get_path_fragment(uri)
            if self.jump_to_path_fragment(path, fragment):
                return
        except BookError as e:
            error_str = str(e)
            logger.error('Could not get resource:' + error_str)
            request.finish_error(GLib.Error(error_str))
        else:
            bytes = self.doc.get_resource(path)
            gbytes = GLib.Bytes(bytes)
            stream = Gio.MemoryInputStream.new_from_bytes(gbytes)
            stream_length = gbytes.get_size()
            mime = self.doc.get_resource_mime(path)

            request.finish(stream, stream_length, mime)
Example #17
0
    def receive_data(self, s):
        save_path = prefs.get_save_path()

        path = os.path.join(save_path, s.relative_path)
        if path != self.current_path:
            self.close_current_file()
            self.current_path = path
            self.current_mode = s.file_mode
            self.current_mtime = s.time.mtime
            self.current_mtime_usec = s.time.mtime_usec

        if not self.current_gfile:
            self.current_gfile = Gio.File.new_for_path(path)

        if s.file_type == FileType.DIRECTORY:
            os.makedirs(path,
                        mode=s.file_mode if (s.file_mode > 0) else 0o777,
                        exist_ok=True)
        elif s.file_type == FileType.SYMBOLIC_LINK:
            make_symbolic_link(self.op, path, s.symlink_target)
        else:
            if self.current_stream == None:
                flags = Gio.FileCreateFlags.REPLACE_DESTINATION
                self.current_stream = self.current_gfile.replace(
                    None, False, flags, None)

            if not s.chunk:
                return

            self.current_stream.write_bytes(GLib.Bytes(s.chunk), None)
            self.op.progress_tracker.update_progress(len(s.chunk))
Example #18
0
    def _do_paint_rgb(self, cairo_format, has_alpha, img_data, x, y, width,
                      height, rowstride, options):
        """ must be called from UI thread """
        log(
            "cairo._do_paint_rgb(%s, %s, %s %s, %s, %s, %s, %s, %s, %s) set_image_surface_data=%s, use pixbuf=%s",
            FORMATS.get(cairo_format, cairo_format), has_alpha, len(img_data),
            type(img_data), x, y, width, height, rowstride, options,
            set_image_surface_data, CAIRO_USE_PIXBUF)
        rgb_format = options.strget(b"rgb_format", "RGB")
        if set_image_surface_data and not CAIRO_USE_PIXBUF:
            if (cairo_format==cairo.FORMAT_RGB24 and rgb_format in ("RGB", "BGR")) or \
                (cairo_format==cairo.FORMAT_ARGB32 and rgb_format in ("BGRX", "BGRA")):
                img_surface = cairo.ImageSurface(cairo_format, width, height)
                set_image_surface_data(img_surface, rgb_format, img_data,
                                       width, height, rowstride)
                self.cairo_paint_surface(img_surface, x, y, options)
                return True

        if rgb_format in ("RGB", "RGBA", "RGBX"):
            data = GLib.Bytes(img_data)
            pixbuf = GdkPixbuf.Pixbuf.new_from_bytes(data,
                                                     GdkPixbuf.Colorspace.RGB,
                                                     has_alpha, 8, width,
                                                     height, rowstride)
            self.cairo_paint_pixbuf(pixbuf, x, y, options)
            return True

        img_data = memoryview(img_data)
        self.nasty_rgb_via_png_paint(cairo_format, has_alpha, img_data, x, y,
                                     width, height, rowstride, rgb_format)
        return True
Example #19
0
class AppRootView(View['AppRootPresenter', None]):
    APP_ICON = GdkPixbuf.Pixbuf.new_from_stream(
        Gio.MemoryInputStream.new_from_bytes(
            GLib.Bytes(
                pkg_resources.resource_stream(
                    'opendrop.res', 'images/icon_256x256.png').read())))

    def _do_init(self) -> None:
        Gtk.Window.set_default_icon(self.APP_ICON)

        _, self._main_menu_window = self.new_component(
            main_menu_cs.factory(model=self.presenter.main_menu_model))

        self._ift_window_cid = None
        self._conan_window_cid = None

        self.presenter.view_ready()

    def start_ift(self, session: IFTSession) -> None:
        assert self._ift_window_cid is None

        self._ift_window_cid, ift_window = self.new_component(
            ift_root_cs.factory(session=session))

        self._main_menu_window.hide()
        ift_window.show()

    def _end_ift(self) -> None:
        assert self._ift_window_cid is not None
        self.remove_component(self._ift_window_cid)
        self._ift_window_cid = None

    def start_conan(self, session: ConanSession) -> None:
        assert self._conan_window_cid is None

        self._conan_window_cid, conan_window = self.new_component(
            conan_root_cs.factory(session=session))

        self._main_menu_window.hide()
        conan_window.show()

    def _end_conan(self) -> None:
        assert self._conan_window_cid is not None
        self.remove_component(self._conan_window_cid)
        self._conan_window_cid = None

    def return_to_main_menu(self) -> None:
        if self._ift_window_cid is not None:
            self._end_ift()

        if self._conan_window_cid is not None:
            self._end_conan()

        self._main_menu_window.show()

    def hide_all_windows(self) -> None:
        self._main_menu_window.hide()
        self._ift_window.hide()
Example #20
0
    def __set_artwork(self):
        """
            Set artist artwork
        """
        artwork_height = 0
        if Lp().settings.get_value("artist-artwork"):
            if len(self._artist_ids) == 1 and\
                    Lp().settings.get_value("artist-artwork"):
                artist = Lp().artists.get_name(self._artist_ids[0])
                size = ArtSize.ARTIST_SMALL * 2 * self.__scale_factor
                for suffix in ["lastfm", "spotify", "wikipedia"]:
                    uri = InfoCache.get_artwork(artist, suffix, size)
                    if uri is not None:
                        f = Gio.File.new_for_path(uri)
                        (status, data, tag) = f.load_contents(None)
                        if not status:
                            continue
                        bytes = GLib.Bytes(data)
                        stream = Gio.MemoryInputStream.new_from_bytes(bytes)
                        bytes.unref()
                        pixbuf = GdkPixbuf.Pixbuf.new_from_stream_at_scale(
                                                                       stream,
                                                                       size,
                                                                       size,
                                                                       True,
                                                                       None)
                        stream.close()
                        surface = Gdk.cairo_surface_create_from_pixbuf(
                                            pixbuf, self.__scale_factor, None)
                        self.__artwork.set_from_surface(surface)
                        artwork_height = ArtSize.ARTIST_SMALL * 2
                        self.__artwork.get_style_context().remove_class(
                                                                "artwork-icon")
                        self.__artwork.show()
                        self.__artwork_box.show()
                        break
            # Add a default icon
            if len(self._artist_ids) == 1 and artwork_height == 0:
                self.__artwork.set_from_icon_name(
                                            "avatar-default-symbolic",
                                            Gtk.IconSize.DND)
                artwork_height = 32
                self.__artwork.get_style_context().add_class("artwork-icon")
                self.__artwork.show()
                self.__artwork_box.show()

        # Create an self.__empty widget with header height
        ctx = self.__label.get_pango_context()
        layout = Pango.Layout.new(ctx)
        layout.set_text("a", 1)
        # Font scale 2
        font_height = int(layout.get_pixel_size()[1]) * 2

        if artwork_height > font_height:
            self.__empty.set_property("height-request", artwork_height)
        else:
            self.__empty.set_property("height-request", font_height)
Example #21
0
 def get_pixbuf_from_frame(self, frame):
     height, width, channels = frame.shape
     return GdkPixbuf.Pixbuf.new_from_bytes(
         data=GLib.Bytes(frame.tobytes()),
         colorspace=0,
         has_alpha=True,
         bits_per_sample=8,
         width=width,
         height=height,
         rowstride = width*4)
Example #22
0
    def parse_doc(self, uri):
        data = None
        import urllib.request
        with urllib.request.urlopen(uri) as response:
            data = response.read()

        input_stream = Gio.MemoryInputStream.new_from_bytes(GLib.Bytes(data))
        document = Poppler.Document.new_from_stream(input_stream, -1, None,
                                                    None)
        return document
Example #23
0
    def add_bytes(self, _bytes):
        try:
            self.loader.write_bytes(GLib.Bytes(_bytes))
        except GLib.Error:
            try:
                self.loader.close()
            except:
                pass

            self.emit("error")
Example #24
0
 def print_pdf_clicked(self, button):
     import printing
     print_op = printing.Operation()
     print_op.set_parent(self.window)
     pdf_data = Gio.MemoryInputStream.new_from_bytes(GLib.Bytes(self.bytes))
     print_op.set_bytes_to_print(pdf_data)
     if self.landscape:
         setup = Gtk.PageSetup()
         setup.set_orientation(Gtk.PageOrientation.LANDSCAPE)
         print_op.set_default_page_setup(setup)
     print_op.print_dialog()
Example #25
0
 def get_image(self, name):
     # get the data back: decode b64 and uncompress the pixels
     data = self.images[name]["pixels"]
     data = base64.b64decode(data)
     data = zlib.decompress(data)
     pb = GdkPixbuf.Pixbuf.new_from_bytes(
         GLib.Bytes(data), GdkPixbuf.Colorspace.RGB,
         self.images[name]["has_alpha"],
         self.images[name]["bits_per_sample"], self.images[name]["width"],
         self.images[name]["height"], self.images[name]["rowstride"])
     return pb
Example #26
0
def make_launcher(filename, dropins_dir=DROPINS_DIR):
    dropins = find_dropins(filename, dropins_dir)
    if not dropins:
        return Gio.DesktopAppInfo.new_from_filename(filename)

    desktop_entry = load_desktop_entry_with_dropins(filename, dropins)

    data = GLib.Bytes(ini_to_string(desktop_entry).encode('utf-8'))
    keyfile = GLib.KeyFile()
    keyfile.load_from_bytes(data, 0)
    return Gio.DesktopAppInfo.new_from_keyfile(keyfile)
Example #27
0
 def create_pixbuf(self, width, height):
     pixbuf = GdkPixbuf.Pixbuf.new_from_bytes(
         data=GLib.Bytes(self.memory),
         colorspace=GdkPixbuf.Colorspace.RGB,
         has_alpha=False,
         bits_per_sample=8,
         width=self.interface.size[0],
         height=self.interface.size[1],
         rowstride=self.memory_stride,
     )
     return pixbuf.scale_simple(width, height,
                                GdkPixbuf.InterpType.BILINEAR)
Example #28
0
    def _handle_data_from_javascript(self, request):
        assert request.get_scheme() == 'mathpaste-gtk-data'
        assert request.get_uri().startswith('mathpaste-gtk-data://')

        data_part_of_uri = request.get_uri()[len('mathpaste-gtk-data://'):]
        id_, encoded_uri_component = data_part_of_uri.split(',', 1)
        json_string = urllib.parse.unquote(encoded_uri_component)
        python_object = json.loads(json_string)
        self._callback_dict.pop(int(id_))(python_object)

        empty_gstream = Gio.MemoryInputStream.new_from_bytes(GLib.Bytes(b''))
        request.finish(empty_gstream, 0)
Example #29
0
    def __init__(self, image_base64):
        Result.__init__(self)

        self.get_style_context().add_class('resultimageview')

        self.image_base64 = image_base64
        image_bytes = GLib.Bytes(base64.b64decode(self.image_base64))
        image_stream = Gio.MemoryInputStream.new_from_bytes(image_bytes)
        self.pixbuf = GdkPixbuf.Pixbuf.new_from_stream(image_stream)

        self.image = Gtk.Image.new_from_pixbuf(self.pixbuf)
        self.centerbox.set_center_widget(self.image)
        self.show_all()
Example #30
0
    def save_album_artwork(self, data, album_id):
        """
            Save data for album id
            @param data as bytes
            @param album id as int
        """
        try:
            album = Album(album_id)
            arturi = None
            save_to_tags = Lp().settings.get_value("save-to-tags")
            uri_count = Lp().albums.get_uri_count(album.uri)
            filename = self.get_album_cache_name(album) + ".jpg"
            if save_to_tags:
                helper = TaskHelper()
                helper.run(self.__save_artwork_tags, data, album)

            store_path = self._STORE_PATH + "/" + filename
            if album.uri == "" or is_readonly(album.uri):
                arturi = GLib.filename_to_uri(store_path)
            # Many albums with same path, suffix with artist_album name
            elif uri_count > 1:
                arturi = album.uri + "/" + filename
                favorite_uri = album.uri + "/" + self.__favorite
                favorite = Gio.File.new_for_uri(favorite_uri)
                if favorite.query_exists():
                    favorite.trash()
            else:
                arturi = album.uri + "/" + self.__favorite
            # Save cover to uri
            dst = Gio.File.new_for_uri(arturi)
            if not save_to_tags or dst.query_exists():
                bytes = GLib.Bytes(data)
                stream = Gio.MemoryInputStream.new_from_bytes(bytes)
                bytes.unref()
                pixbuf = GdkPixbuf.Pixbuf.new_from_stream_at_scale(
                                                               stream,
                                                               ArtSize.MONSTER,
                                                               ArtSize.MONSTER,
                                                               True,
                                                               None)
                stream.close()
                pixbuf.savev(store_path, "jpeg", ["quality"],
                             [str(Lp().settings.get_value(
                                                "cover-quality").get_int32())])
                dst = Gio.File.new_for_uri(arturi)
                src = Gio.File.new_for_path(store_path)
                src.move(dst, Gio.FileCopyFlags.OVERWRITE, None, None)
                self.clean_album_cache(album)
                GLib.idle_add(self.album_artwork_update, album.id)
        except Exception as e:
            print("Art::save_album_artwork(): %s" % e)