def paint_pixbuf_gdk(self, coding, img_data, x, y, width, height, options, callbacks): """ must be called from UI thread """ loader = gdk.PixbufLoader(coding) loader.write(img_data, len(img_data)) loader.close() pixbuf = loader.get_pixbuf() if not pixbuf: log.error("failed %s pixbuf=%s data len=%s" % (coding, pixbuf, len(img_data))) fire_paint_callbacks(callbacks, False) return False raw_data = pixbuf.get_pixels() rowstride = pixbuf.get_rowstride() img_data = self.process_delta(raw_data, width, height, rowstride, options) n = pixbuf.get_n_channels() if n == 3: self.do_paint_rgb24(img_data, x, y, width, height, rowstride, options, callbacks) else: assert n == 4, "invalid number of channels: %s" % n self.do_paint_rgb32(img_data, x, y, width, height, rowstride, options, callbacks) return False
def load_chunk(self, chunk): from gtk import gdk loader = gdk.PixbufLoader() loader.write(chunk.data, len(chunk.data)) # TODO: handle area-prepared etc self.image.set_from_pixbuf(loader.get_pixbuf()) loader.close()
def paint_pixbuf_gdk(self, coding, img_data, x, y, width, height, options, callbacks): """ must be called from UI thread """ if coding.startswith("png"): coding = "png" else: assert coding=="jpeg" loader = gdk.PixbufLoader(coding) loader.write(img_data, len(img_data)) loader.close() pixbuf = loader.get_pixbuf() if not pixbuf: msg = "failed to load a pixbuf from %i bytes of %s data" % (len(img_data), coding) log.error("Error: %s", msg) fire_paint_callbacks(callbacks, False, msg) return False raw_data = pixbuf.get_pixels() rowstride = pixbuf.get_rowstride() img_data = self.process_delta(raw_data, width, height, rowstride, options) n = pixbuf.get_n_channels() if n==3: self.do_paint_rgb24(img_data, x, y, width, height, rowstride, options, callbacks) else: assert n==4, "invalid number of channels: %s" % n self.do_paint_rgb32(img_data, x, y, width, height, rowstride, options, callbacks) return False
def __init__(self, vid, show_description): gtk.Widget.__init__(self) self.set_can_focus(True) self.video = vid picture = vid.get_picture() if picture: loader = gdk.PixbufLoader() loader.write(picture) self.pic = loader.get_pixbuf() loader.close() else: self.pic = None #self.font=gtk.FontSelection().get_font() self.create_pango_context() #self.font_description=pango.FontDescription('') txt = '<b>' + self.video.get_title() + '</b>\n' txt += self.get_formated_duration() + ' ' + self.video.get_uploader( ) + ' ' + self.get_formated_uploaded() if show_description: txt += '\n' + self.video.get_short_desc() else: #self.tooltip_widget=None #self.set_property('has-tooltip',True) #self.connect('query-tooltip',self.do_query_tooltip) self.set_tooltip_text(self.video.get_short_desc()) txt = txt.replace('&', '&') self.text_layout = self.create_pango_layout("") self.text_layout.set_markup(txt) self.text_layout.set_wrap(pango.WRAP_WORD_CHAR) self.text_layout.set_spacing(pango.SCALE * 3) self.connect('button-release-event', self.on_button_release) self.connect('enter-notify-event', self.on_enter) self.connect('leave-notify-event', self.on_leave)
def monitor_mcast(self): """Monitor for multicast messages""" while not self.mcast.messages.empty(): message, sender = self.mcast.messages.get() screen_width, screen_height, fullscreen, pos_x, pos_y, step_x, step_y, img = self.protocol.unpack_chunk(message) self.logger.debug("Received image at %dx%d-%dx%d (fullscreen=%s)" % (pos_x, pos_y, step_x, step_y, fullscreen)) # ignore messages received from different teacher if sender != self.teacher_addr: self.logger.info( "Ignoring multicast request from other teacher (%s instead of %s)" % (sender, self.teacher_addr)) continue try: loader = gdk.PixbufLoader(image_type="jpeg") loader.write(img) loader.close() pb = loader.get_pixbuf() gc = self.drawing.get_style().fg_gc[gtk.STATE_NORMAL] # are we in fullscreen mode ? if fullscreen == 1: width = self.screen.width height = self.screen.height if width != screen_width or height != screen_height: self.projection_window.set_size_request(screen_width, screen_height) self.drawing.set_size_request(screen_width, screen_height) if self.projection_window.is_fullscreen == False: self.projection_window.set_has_frame(False) self.projection_window.set_decorated(False) self.block_keyboard_mouse() self.projection_window.fullscreen() self.projection_window.is_fullscreen = True scaling_ratio_x = 1.0 * width / screen_width scaling_ratio_y = 1.0 * height / screen_height else: width, height = self.projection_window.get_size() if width != screen_width or height != screen_height: self.projection_window.set_size_request(screen_width, screen_height) self.drawing.set_size_request(screen_width, screen_height) if self.projection_window.is_fullscreen: self.projection_window.set_has_frame(True) self.projection_window.set_decorated(True) self.projection_window.unfullscreen() self.projection_window.is_fullscreen = False scaling_ratio_x = 1 scaling_ratio_y = 1 # drawing or scaling if scaling_ratio_x != 1 or scaling_ratio_y != 1: # scaling received stuff new_pos_x = math.ceil(pos_x * scaling_ratio_x) new_pos_y = math.ceil(pos_y * scaling_ratio_y) new_step_x = math.ceil(step_x * scaling_ratio_x) new_step_y = math.ceil(step_y * scaling_ratio_y) pb2 = pb.scale_simple(new_step_x, new_step_y, gtk.gdk.INTERP_BILINEAR) self.drawing.window.draw_pixbuf(gc, pb2, 0, 0, new_pos_x, new_pos_y, new_step_x, new_step_y) else: self.drawing.window.draw_pixbuf(gc, pb, 0, 0, pos_x, pos_y, step_x, step_y) except: self.logger.exception("Processing multicast message") gobject.timeout_add(1000, self.monitor_mcast)
def from_string(self, value, format='png'): loader = gdk.PixbufLoader(format) try: loader.write(value) loader.close() except gobject.GError, e: raise ValidationError(_("Could not load image: %s") % e)
def _pixbuf_from_stream(fp, feedback_cb=None): loader = gdk.PixbufLoader() while True: if feedback_cb is not None: feedback_cb() buf = fp.read(LOAD_CHUNK_SIZE) if buf == '': break loader.write(buf) loader.close() return loader.get_pixbuf()
def pixbuf_from_string(pixbuf_data, format='png', width=None, height=None): loader = gdk.PixbufLoader(format) loader.write(pixbuf_data) loader.close() pixbuf = loader.get_pixbuf() if width is not None or height is not None: scaled_pixbuf = pixbuf.scale_simple(width, height, gdk.INTERP_BILINEAR) if scaled_pixbuf is None: print 'Warning: could not scale image' else: pixbuf = scaled_pixbuf return pixbuf
def show_screenshot(self, client, width, height, shot): """Displays a student screenshot""" self.shot_window.resize(width, height) self.shot_label.set_text(_("Viewing display of %s") % client) self.shot_refresh.current_client = client loader = gdk.PixbufLoader(image_type="jpeg") loader.write(shot) loader.close() pb = loader.get_pixbuf() self.shot_drawing.set_from_pixbuf(pb) self.shot_window.show()
def get_pixbuf(filename): try: if os.path.splitext(filename)[1].lower() == ".ora": ora = zipfile.ZipFile(filename) data = ora.read("Thumbnails/thumbnail.png") loader = gdk.PixbufLoader("png") loader.write(data) loader.close() return loader.get_pixbuf() else: return gdk.pixbuf_new_from_file(filename) except: # filename is a directory, or just nothing image-like return
def image_surface_to_pixbuf(surf): if gtk2compat.USE_GTK3: w = surf.get_width() h = surf.get_height() return gdk.pixbuf_get_from_surface(surf, 0, 0, w, h) # GTK2. # Ugly PNG-based fudge to work around cairo.ImageSurface.get_data() # returning packed BGRA or ARGB pixels depending on endianness. png_dp = StringIO() surf.write_to_png(png_dp) pixbuf_loader = gdk.PixbufLoader() pixbuf_loader.write(png_dp.getvalue()) pixbuf_loader.close() return pixbuf_loader.get_pixbuf()
def ora_thumbnail(infile, outfile, size): """Saves an OpenRaster file's thumbnail to a PNG file, with scaling. """ # Extract a GdkPixbuf from the OpenRaster file png_data = zipfile.ZipFile(infile).read('Thumbnails/thumbnail.png') loader = gdk.PixbufLoader() loader.write(png_data) loader.close() pixbuf = loader.get_pixbuf() # Don't scale if not needed orig_w, orig_h = pixbuf.get_width(), pixbuf.get_height() if orig_w < size and orig_h < size: pixbuf.save(outfile, 'png') return # Scale and save scale_factor = float(size) / max(orig_w, orig_h) new_w, new_h = int(orig_w * scale_factor), int(orig_h * scale_factor) scaled_pixbuf = pixbuf.scale_simple(new_w, new_h, gdk.INTERP_BILINEAR) scaled_pixbuf.save(outfile, 'png')
def monitor(self): """Monitors new machines connections""" # update machine timestamp timestamp = time.time() while not self.clients_queue.empty(): action, addr, params = self.clients_queue.get() self.machines_alive[addr] = timestamp timestamp_s = time.asctime(time.localtime(timestamp)) if action == "new": # adding a new machine if addr not in self.machines: # Maquina nova gtk.gdk.threads_enter() name = params.get("name", addr) machine = self.mkmachine(name) machine.fullname = name machine.button.connect('button_press_event', self.cb_machine, machine) self.put_machine(machine) self.machines[addr] = machine self.machines_map[machine] = addr self.machines_status[addr] = "registered" # show default image machine.button.set_image(self.image_connected) machine.show_all() gtk.gdk.threads_leave() else: # do not process events from already rejected machines if self.machines_status[addr] == "rejected": continue elif self.machines_status[addr] == "pending": self.machines_status[addr] = "registered" machine = self.machines[addr] shot = params.get("shot") if shot: loader = gdk.PixbufLoader(image_type="jpeg") loader.write(shot[0]) loader.close() pb = loader.get_pixbuf() img = gtk.Image() img.set_from_pixbuf(pb) machine.button.set_image(img) name = params.get("name") if name: machine.label.set_markup(self.mkname(name)) machine.fullname = name tooltip = "%s\n" % name tooltip += "(%s)\n" % addr tooltip += _("Updated on %s") % timestamp_s self.tooltip.set_tip(machine, tooltip) elif action == "reject": machine = self.machines[addr] machine.button.set_image(self.image_disconnected) elif action == "shot": # show a student screenshot width = params["width"] height = params["height"] shot = params["shot"] self.show_screenshot(addr, width, height, shot) elif action == "raisehand": message = params["message"] # shows a raisehand request from students name = addr if addr in self.machines: name = self.machines[addr].machine self.show_message(_("Message received from %s") % name, message, timeout=0) # nuke old clients for addr in self.machines_alive: client_ts = self.machines_alive[addr] if client_ts < 0: # skip already dead clients continue timeout = int(timestamp - client_ts) if timeout > self.max_client_timeout: self.logger.warning("Error: client %s has lost connection" % addr) self.machines_alive[addr] = -1 try: machine = self.machines[addr] reject = False if self.machines_status[addr] == "rejected": reject = True self.disconnect(machine, reject=reject) except: self.logger.exception( "Attempting to disconnect idle machine") gobject.timeout_add(self.events_frequency, self.monitor)
def __init__(self): threads_enter() gobject.type_register(VideoWidget) gobject.type_register(ShowBox) gobject.type_register(Configer) gobject.type_register(DescriptionWindow) gobject.type_register(SearchBar) locale.setlocale(locale.LC_ALL, locale.getdefaultlocale()) factory = gtk.IconFactory() try: f = self.get_resource('pixmaps/bookmark.png') loader = gtk.gdk.PixbufLoader() loader.write(f.read()) f.close() factory.add(self.STOCK_BOOKMARK, gtk.IconSet(loader.get_pixbuf())) loader.close() except: raise factory.add_default() gtk.stock_add((( self.STOCK_BOOKMARK, "_Bookmarks", gtk.gdk.CONTROL_MASK, gtk.gdk.keyval_from_name('B'), "youtube-show", ), )) self.userDir = UserDir() self.config = Config(self.userDir.get_conf_file()) self.config.load() self.bookmarks = Bookmarks.Bookmarks( self.userDir.get_file('bookmarks')) self.bookmarks.load() self.caches = YoutubeConnector.CacheSaver( self.userDir.get_file('caches.txt')) self.cookies = CookieJar() self.downloader = urllib2.build_opener( urllib2.HTTPCookieProcessor(self.cookies)) self.ytsearcher = YoutubeConnector.YTSearcher(self.downloader) self.ytconnector = YoutubeConnector.YTConnector( self.downloader, self.caches) self.searching = threading.Event() self.is_fullscreen = False self.history = History() self.viewer = Viewer.Viewer() self.win = gtk.Window(gtk.WINDOW_TOPLEVEL) if not self.win: raise RuntimeError() self.win.connect('delete_event', self.cleanup) self.win.connect('destroy', self.destroy) self.win.connect('key_press_event', self.on_key_press) self.win.connect_object('window-state-event', self.on_window_state_change, self) self.build_menu_bar() self.build_tool_bar() self.showbox = ShowBox() self.showbox.connect('scroll-end-event', self.do_next_search) self.showbox.show() self.statusbar = gtk.Statusbar() self.statusbar.show() self.progressbar = gtk.ProgressBar() self.statusbar.add(self.progressbar) self.align = gtk.VBox() self.align.pack_start(self.menubar, expand=False, fill=True) self.align.pack_start(self.toolbar, expand=False, fill=True) self.align.pack_start(self.showbox, expand=True, fill=True) self.align.pack_start(self.statusbar, expand=False, fill=True) self.statusbar.push(1, 'Ready') self.apply_config() self.align.show() self.win.add(self.align) self.win.set_title("youtube-show") theme = gtk.icon_theme_get_for_screen(gtk.gdk.screen_get_default()) try: icon = theme.load_icon('youtube_show', 48, 0) self.win.set_icon(icon) except: try: with self.get_resource('pixmaps/youtube-show.png') as iconfile: loader = gdk.PixbufLoader() loader.write(iconfile.read()) self.win.set_icon(loader.get_pixbuf()) loader.close() except: pass w, h = self.config['size'] if w > -1 and h > -1: self.win.resize(w, h) else: self.win.resize(500, 600) self.win.show() threads_leave()