class JAMediaLector(Gtk.Plug): """ JAMediaLector: Lector pdf y de archivos de texto. Implementado sobre: python 2.7.3 y Gtk 3 Es un Gtk.Plug para embeber en cualquier contenedor dentro de otra aplicacion. Para ello, es necesario crear en la aplicacion donde será enbebido JAMediaLector, un socket: import JAMediaLector from JAMediaLector.JAMediaLector import JAMediaLector self.socket = Gtk.Socket() self.add(self.socket) self.jamedialector = JAMediaLector() socket.add_id(self.jamedialector.get_id() y luego proceder de la siguiente forma: GLib.idle_add(self.setup_init) def setup_init(self): self.jamedialector.setup_init() # self.jamediaplayer.pack_standar() # Esta última linea no debe ir cuando se embebe NOTA: Tambien se puede ejecutar JAMediaLector directamente mediante python JAMediaLector.py """ __gsignals__ = { "salir":(GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, [])} def __init__(self): """ JAMediaLector: Gtk.Plug para embeber en otra aplicación. """ Gtk.Plug.__init__(self, 0L) self.toolbar_box = None self.toolbar = None self.toolbar_config = None self.toolballector = None self.toolbartray = None self.visor = None self.previewcontainer = None self.toolbarpaginas = None self.textview = None self.toolbar_salir = None self.controlespdf = None self.controlestexto = None self.controles_dinamicos = None self.documento = None self.npaginas = None self.indexpaginaactiva = None self.pagina = None self.show_all() self.connect("embedded", self.embed_event) def setup_init(self): """ Se crea la interfaz grafica, se setea todo y se empaqueta todo. """ ### Contenedor secundario para toda la interfaz. basebox = Gtk.Box(orientation = Gtk.Orientation.VERTICAL) ### Contenedor para todas las toolbars. self.toolbar_box = Gtk.Box(orientation = Gtk.Orientation.VERTICAL) ### Panel para lector y barra de navegación de páginas. hpanel = Gtk.HPaned() self.toolbar = Toolbar() self.toolbar_salir = ToolbarSalir() self.toolbar_config = ToolbarConfig() self.toolbarlector = ToolbarLector() self.toolbartry = ToolbarTry() ### Empaquetado de las tres toolbars superiores de la aplicacion. self.toolbar_box.pack_start(self.toolbar, False, False, 0) self.toolbar_box.pack_start(self.toolbar_salir, False, False, 0) self.toolbar_box.pack_start(self.toolbar_config, False, False, 0) self.visor = DrawingLector() self.previewcontainer = PreviewContainer() self.toolbarpaginas = ToolbarPaginas() self.textview = TextView() # Izquierda vbox = Gtk.Box(orientation = Gtk.Orientation.VERTICAL) scroll = Gtk.ScrolledWindow() scroll.set_policy( Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scroll.add_with_viewport(self.visor) vbox.pack_start(self.toolbarlector, False, False, 0) vbox.pack_start(scroll, True, True, 0) self.controlespdf = [self.toolbarlector, scroll] scroll = Gtk.ScrolledWindow() scroll.set_policy( Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scroll.add_with_viewport(self.textview) vbox.pack_start(scroll, True, True, 0) self.controlestexto = [scroll] hpanel.pack1(vbox, resize = True, shrink = True) ### Derecha self.derecha_vbox = Gtk.Box(orientation = Gtk.Orientation.VERTICAL) scroll = Gtk.ScrolledWindow() scroll.set_policy( Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scroll.add_with_viewport(self.previewcontainer) self.derecha_vbox.pack_start(self.toolbarpaginas, False, False, 0) self.derecha_vbox.pack_start(scroll, True, True, 0) self.controlespdf.append(self.derecha_vbox) hpanel.pack2(self.derecha_vbox, resize = False, shrink = False) basebox.pack_start(self.toolbar_box, False, False, 0) basebox.pack_start(hpanel, True, True, 0) basebox.pack_start(self.toolbartry, False, False, 0) self.controles_dinamicos = [ self.toolbar_box, self.derecha_vbox, self.toolbartry] self.add(basebox) self.show_all() self.toolbar_salir.hide() self.toolbar.abrir.hide() # Solo cuando no esta embebido self.toolbar_config.hide() self.toolbarlector.connect('original', self.visor.original) self.toolbarlector.connect('alejar', self.visor.alejar) self.toolbarlector.connect('acercar', self.visor.acercar) #self.toolbarlector.connect('rotar_izquierda', self.visor.acercar) #self.toolbarlector.connect('rotar_derecha', self.visor.acercar) self.toolbarpaginas.connect('activar', self.activar) self.previewcontainer.connect('nueva_seleccion', self.nueva_pagina) self.visor.connect("button_press_event", self.clicks_en_pantalla) self.toolbar.connect('abrir', self.show_filechooser) self.toolbar.connect('config', self.mostrar_config) self.toolbar.connect('salir', self.confirmar_salir) self.toolbar_salir.connect('salir', self.emit_salir) map(self.ocultar, self.controlestexto) map(self.ocultar, self.controlespdf) def pack_standar(self): """ Para empaquetar el botón abrir. """ self.toolbar.abrir.show() def mostrar_config(self, widget): """ Muestra u oculta las opciones de configuracion (toolbar_config). """ map(self.ocultar, [self.toolbar_salir]) if self.toolbar_config.get_visible(): self.toolbar_config.hide() else: self.toolbar_config.show_all() def clicks_en_pantalla(self, widget, event): """ Hace fullscreen y unfullscreen sobre la ventana principal cuando el usuario hace doble click en el visor. """ if event.type.value_name == "GDK_2BUTTON_PRESS": ventana = self.get_toplevel() screen = ventana.get_screen() w,h = ventana.get_size() ww, hh = (screen.get_width(), screen.get_height()) if ww == w and hh == h: ventana.unfullscreen() else: ventana.fullscreen() def do_motion_notify_event(self, event): """ Cuando se mueve el mouse sobre la ventana. """ if self.toolbar_config.ocultar_controles: x, y = (int(event.x), int(event.y)) rect = self.get_allocation() xx, yy, ww, hh = (rect.x, rect.y, rect.width, rect.height) arriba = range(0, self.toolbar_box.get_allocation().height) derecha = range(ww - self.derecha_vbox.get_allocation().width, ww) if y in arriba or x in derecha: map(self.mostrar, self.controles_dinamicos) else: map(self.ocultar, self.controles_dinamicos) #map(self.ocultar, [self.toolbar_config, self.toolbar_salir]) else: map(self.mostrar, self.controles_dinamicos) def ocultar(self, objeto): """ Esta funcion es llamada desde self.ocultar_controles() """ if objeto.get_visible(): objeto.hide() def mostrar(self, objeto): """ Esta funcion es llamada desde self.ocultar_controles() """ if not objeto.get_visible(): objeto.show() def show_filechooser(self, widget): selector = Selector_de_Archivos(self) selector.connect('archivos-seleccionados', self.cargar_archivo) def cargar_archivo(self, widget, archivo): """ Recibe un archivo desde el filechooser para abrir en el lector. """ self.abrir( archivo) def limpiar(self): self.toolbartry.label.set_text("") self.documento = None self.previewcontainer.limpiar() self.load_pagina(None) self.textview.get_buffer().set_text("") map(self.ocultar, self.controlestexto) map(self.ocultar, self.controlespdf) def abrir(self, archivo): """ Abre un Archivo. """ descripcion = JAMF.describe_uri(archivo) if descripcion: if descripcion[2]: # Es un Archivo tipo = JAMF.describe_archivo(archivo) if 'pdf' in tipo: self.toolbartry.label.set_text(archivo) archivo = "file://%s" % (archivo) map(self.ocultar, self.controlestexto) map(self.mostrar, self.controlespdf) self.documento = Poppler.Document.new_from_file(archivo, None) self.npaginas = self.documento.get_n_pages() #thread = threading.Thread( target=self.llenar_preview ) #thread.start() self.previewcontainer.llenar(self.documento) elif 'text' in tipo: self.toolbartry.label.set_text(archivo) map(self.ocultar, self.controlespdf) map(self.mostrar, self.controlestexto) arch = open(archivo, "r") lineas = arch.readlines() arch.close() texto = "" for linea in lineas: texto += linea self.textview.get_buffer().set_text(texto) else: self.toolbartry.label.set_text("") self.documento = None self.previewcontainer.limpiar() self.load_pagina(None) self.textview.get_buffer().set_text("") #def llenar_preview(self): # """ Thread para cargar las páginas en preview. """ # self.previewcontainer.llenar(self.documento) def nueva_pagina(self, widget, indice): """ Cuando se selecciona una nueva pagina """ self.load_pagina(indice) def load_pagina(self, indice): """ Carga una página del Archivo pdf abierto actualmente. """ if indice != None: self.indexpaginaactiva = indice self.pagina = self.documento.get_page(self.indexpaginaactiva) self.visor.set_pagina(self.pagina) self.toolbarpaginas.set_pagina(self.indexpaginaactiva+1, self.npaginas) else: self.indexpaginaactiva = None self.pagina = None self.visor.set_pagina(None) self.toolbarpaginas.set_pagina(None, None) def activar(self, widget, senial): """ Cuando se pasa de pagina. """ if senial == 'atras': if self.indexpaginaactiva > 0: self.previewcontainer.seleccionar(self.indexpaginaactiva-1) else: self.previewcontainer.seleccionar(self.npaginas-1) elif senial == 'siguiente': if self.indexpaginaactiva < self.npaginas-1: self.previewcontainer.seleccionar(self.indexpaginaactiva+1) else: self.previewcontainer.seleccionar(0) def embed_event(self, widget): """ No hace nada por ahora. """ print "JAMediaLector => OK" def confirmar_salir(self, widget = None, senial = None): """ Recibe salir y lo pasa a la toolbar de confirmación. """ map(self.ocultar, [self.toolbar_config]) self.toolbar_salir.run("JAMediaLector") def emit_salir(self, widget = None, senial = None): """ Emite salir para que cuando esta embebida, la aplicacion decida que hacer, si salir, o cerrar solo JAMediaLector. """ self.emit('salir')
class Ventana(Gtk.Window): """ Ventana Principal de JAMexplorer. """ __gtype_name__ = 'JAMediaExplorer' def __init__(self): super(Ventana, self).__init__() self.set_title("JAMediaExplorer") self.set_icon_from_file( os.path.join(ICONOS, "JAMediaExplorer.svg")) self.set_resizable(True) self.set_size_request(640, 480) self.set_position(Gtk.WindowPosition.CENTER) self.set_border_width(3) vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.toolbar = Toolbar() self.toolbar_accion = ToolbarAccion() self.toolbar_salir = ToolbarSalir() self.navegador = Navegador() self.toolbar_try = ToolbarTry() switchbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) switchbox.pack_start(self.navegador, True, True, 0) vbox.pack_start(self.toolbar, False, True, 0) vbox.pack_start(self.toolbar_accion, False, True, 0) vbox.pack_start(self.toolbar_salir, False, True, 0) vbox.pack_start(switchbox, True, True, 0) vbox.pack_start(self.toolbar_try, False, True, 0) self.add(vbox) #self.socketimagenes = Gtk.Socket() #self.socketimagenes.show() #switchbox.pack_start(self.socketimagenes, True, True, 0) #self.jamimagenes = JAMImagenes() #self.socketimagenes.add_id(self.jamimagenes.get_id()) #self.socketjamedia = Gtk.Socket() #self.socketjamedia.show() #switchbox.pack_start(self.socketjamedia, True, True, 0) #self.jamediaplayer = JAMediaPlayer() #self.socketjamedia.add_id(self.jamediaplayer.get_id()) #self.socketjamedialector = Gtk.Socket() #self.socketjamedialector.show() #switchbox.pack_start(self.socketjamedialector, True, True, 0) #self.jamedialector = JAMediaLector() #self.socketjamedialector.add_id(self.jamedialector.get_id()) #self.sockets = [ # self.socketimagenes, # self.socketjamedia, # self.socketjamedialector] self.objetos_no_visibles_en_switch = [ self.toolbar, self.toolbar_accion, self.toolbar_salir, self.navegador, self.toolbar_try] self.show_all() self.realize() self.toolbar_accion.hide() self.toolbar_salir.hide() self.toolbar.connect('salir', self.__confirmar_salir) self.toolbar.connect('accion_ver', self.__set_accion) self.toolbar_accion.connect('borrar', self.__ejecutar_borrar) self.toolbar_salir.connect('salir', self.__salir) self.connect("delete-event", self.__salir) self.navegador.connect('info', self.__get_info) #self.navegador.connect('cargar', self.switch) self.navegador.connect('borrar', self.__set_borrar) #self.jamimagenes.connect('salir', self.get_explorador) #self.jamediaplayer.connect('salir', self.get_explorador) #self.jamedialector.connect('salir', self.get_explorador) #GLib.idle_add(self.setup_init) #def setup_init(self): # self.jamediaplayer.setup_init() # self.jamedialector.setup_init() # map(self.ocultar, self.sockets) def __set_accion(self, widget, accion, valor): """ Cuando se hace click en ver ocultos del menu. """ self.get_toplevel().set_sensitive(False) self.navegador.notebookdirectorios.recargar(valor) self.get_toplevel().set_sensitive(True) def __ejecutar_borrar(self, widget, direccion, modelo, iter_): """ Ejecuta borrar un archivo o directorio. """ self.get_toplevel().set_sensitive(False) from JAMediaObjects.JAMFileSystem import borrar if borrar(direccion): modelo.remove(iter_) self.navegador.notebookdirectorios.copiando = False self.navegador.notebookdirectorios.cortando = False self.get_toplevel().set_sensitive(True) def __set_borrar(self, widget, direccion, modelo, iter_): """ Setea borrar un archivo en toolbaraccion. """ self.toolbar_salir.hide() self.toolbar_accion.set_accion(direccion, modelo, iter_) def __confirmar_salir(self, widget=None, senial=None): """ Recibe salir y lo pasa a la toolbar de confirmación. """ self.toolbar_accion.hide() self.toolbar_salir.run("JAMediaExplorer") def __ocultar(self, objeto): if objeto.get_visible(): objeto.hide() def __mostrar(self, objeto): if not objeto.get_visible(): objeto.show() def __get_items(self, directorio, tipo): if not os.path.exists(directorio) \ or not os.path.isdir(directorio): return [] items = [] for archivo in os.listdir(directorio): from JAMediaObjects.JAMFileSystem import describe_archivo path = os.path.join(directorio, archivo) descripcion = describe_archivo(path) if tipo in descripcion and not 'iso' in descripcion: items.append([archivo, path]) return items def __get_info(self, widget, path): """ Recibe el path seleccionado en la estructura de directorios, obtiene información sobre el mismo y la pasa a infowidget para ser mostrada. """ if not path: return if not os.path.exists(path): return from JAMediaObjects.JAMFileSystem import get_tamanio from JAMediaObjects.JAMFileSystem import describe_archivo from JAMediaObjects.JAMFileSystem import describe_uri from JAMediaObjects.JAMFileSystem import describe_acceso_uri self.toolbar_try.label.set_text(path) # FIXME: Falla si se movió y no se actualiza unidad, directorio, archivo, enlace = describe_uri(path) lectura, escritura, ejecucion = describe_acceso_uri(path) texto = "" typeinfo = "" if enlace: texto = "Enlace.\n" else: if directorio: texto = "Directorio.\n" elif archivo: texto = "Archivo.\n" texto += "Tipo:\n" for dato in describe_archivo(path).split(";"): texto += "\t%s\n" % (dato.strip()) typeinfo += dato texto += "Tamaño:\n" texto += "\t%s bytes\n" % (get_tamanio(path)) texto += "Permisos: \n" texto += "\tLactura: %s\n" % (lectura) texto += "\tEscritura: %s\n" % (escritura) texto += "\tEjecución: %s\n" % (ejecucion) self.navegador.infowidget.set_info(texto, typeinfo) def __salir(self, widget=None, senial=None): notebook = self.navegador.notebookdirectorios paginas = notebook.get_n_pages() for indice in range(paginas): pags = notebook.get_children() pags[indice].get_child().new_handle(False) import sys sys.exit(0) Gtk.main_quit()
class JAMediaLector(Gtk.Plug): """ JAMediaLector: Lector pdf y de archivos de texto. Implementado sobre: python 2.7.3 y Gtk 3 Es un Gtk.Plug para embeber en cualquier contenedor dentro de otra aplicacion. Para ello, es necesario crear en la aplicacion donde será enbebido JAMediaLector, un socket: import JAMediaLector from JAMediaLector.JAMediaLector import JAMediaLector self.socket = Gtk.Socket() self.add(self.socket) self.jamedialector = JAMediaLector() socket.add_id(self.jamedialector.get_id() y luego proceder de la siguiente forma: GLib.idle_add(self.setup_init) def setup_init(self): self.jamedialector.setup_init() # self.jamediaplayer.pack_standar() # Esta última linea no debe ir cuando se embebe NOTA: Tambien se puede ejecutar JAMediaLector directamente mediante python JAMediaLector.py """ __gsignals__ = {"salir": (GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, [])} def __init__(self): """ JAMediaLector: Gtk.Plug para embeber en otra aplicación. """ Gtk.Plug.__init__(self, 0L) self.toolbar_box = None self.toolbar = None self.toolbar_config = None self.toolballector = None self.toolbartray = None self.visor = None self.previewcontainer = None self.toolbarpaginas = None self.textview = None self.toolbar_salir = None self.controlespdf = None self.controlestexto = None self.controles_dinamicos = None self.documento = None self.npaginas = None self.indexpaginaactiva = None self.pagina = None self.show_all() self.connect("embedded", self.embed_event) def setup_init(self): """ Se crea la interfaz grafica, se setea todo y se empaqueta todo. """ ### Contenedor secundario para toda la interfaz. basebox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) ### Contenedor para todas las toolbars. self.toolbar_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) ### Panel para lector y barra de navegación de páginas. hpanel = Gtk.HPaned() self.toolbar = Toolbar() self.toolbar_salir = ToolbarSalir() self.toolbar_config = ToolbarConfig() self.toolbarlector = ToolbarLector() self.toolbartry = ToolbarTry() ### Empaquetado de las tres toolbars superiores de la aplicacion. self.toolbar_box.pack_start(self.toolbar, False, False, 0) self.toolbar_box.pack_start(self.toolbar_salir, False, False, 0) self.toolbar_box.pack_start(self.toolbar_config, False, False, 0) self.visor = DrawingLector() self.previewcontainer = PreviewContainer() self.toolbarpaginas = ToolbarPaginas() self.textview = TextView() # Izquierda vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scroll.add_with_viewport(self.visor) vbox.pack_start(self.toolbarlector, False, False, 0) vbox.pack_start(scroll, True, True, 0) self.controlespdf = [self.toolbarlector, scroll] scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scroll.add_with_viewport(self.textview) vbox.pack_start(scroll, True, True, 0) self.controlestexto = [scroll] hpanel.pack1(vbox, resize=True, shrink=True) ### Derecha self.derecha_vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scroll.add_with_viewport(self.previewcontainer) self.derecha_vbox.pack_start(self.toolbarpaginas, False, False, 0) self.derecha_vbox.pack_start(scroll, True, True, 0) self.controlespdf.append(self.derecha_vbox) hpanel.pack2(self.derecha_vbox, resize=False, shrink=False) basebox.pack_start(self.toolbar_box, False, False, 0) basebox.pack_start(hpanel, True, True, 0) basebox.pack_start(self.toolbartry, False, False, 0) self.controles_dinamicos = [ self.toolbar_box, self.derecha_vbox, self.toolbartry ] self.add(basebox) self.show_all() self.toolbar_salir.hide() self.toolbar.abrir.hide() # Solo cuando no esta embebido self.toolbar_config.hide() self.toolbarlector.connect('original', self.visor.original) self.toolbarlector.connect('alejar', self.visor.alejar) self.toolbarlector.connect('acercar', self.visor.acercar) #self.toolbarlector.connect('rotar_izquierda', self.visor.acercar) #self.toolbarlector.connect('rotar_derecha', self.visor.acercar) self.toolbarpaginas.connect('activar', self.activar) self.previewcontainer.connect('nueva_seleccion', self.nueva_pagina) self.visor.connect("button_press_event", self.clicks_en_pantalla) self.toolbar.connect('abrir', self.show_filechooser) self.toolbar.connect('config', self.mostrar_config) self.toolbar.connect('salir', self.confirmar_salir) self.toolbar_salir.connect('salir', self.emit_salir) map(self.ocultar, self.controlestexto) map(self.ocultar, self.controlespdf) def pack_standar(self): """ Para empaquetar el botón abrir. """ self.toolbar.abrir.show() def mostrar_config(self, widget): """ Muestra u oculta las opciones de configuracion (toolbar_config). """ map(self.ocultar, [self.toolbar_salir]) if self.toolbar_config.get_visible(): self.toolbar_config.hide() else: self.toolbar_config.show_all() def clicks_en_pantalla(self, widget, event): """ Hace fullscreen y unfullscreen sobre la ventana principal cuando el usuario hace doble click en el visor. """ if event.type.value_name == "GDK_2BUTTON_PRESS": ventana = self.get_toplevel() screen = ventana.get_screen() w, h = ventana.get_size() ww, hh = (screen.get_width(), screen.get_height()) if ww == w and hh == h: ventana.unfullscreen() else: ventana.fullscreen() def do_motion_notify_event(self, event): """ Cuando se mueve el mouse sobre la ventana. """ if self.toolbar_config.ocultar_controles: x, y = (int(event.x), int(event.y)) rect = self.get_allocation() xx, yy, ww, hh = (rect.x, rect.y, rect.width, rect.height) arriba = range(0, self.toolbar_box.get_allocation().height) derecha = range(ww - self.derecha_vbox.get_allocation().width, ww) if y in arriba or x in derecha: map(self.mostrar, self.controles_dinamicos) else: map(self.ocultar, self.controles_dinamicos) #map(self.ocultar, [self.toolbar_config, self.toolbar_salir]) else: map(self.mostrar, self.controles_dinamicos) def ocultar(self, objeto): """ Esta funcion es llamada desde self.ocultar_controles() """ if objeto.get_visible(): objeto.hide() def mostrar(self, objeto): """ Esta funcion es llamada desde self.ocultar_controles() """ if not objeto.get_visible(): objeto.show() def show_filechooser(self, widget): selector = Selector_de_Archivos(self) selector.connect('archivos-seleccionados', self.cargar_archivo) def cargar_archivo(self, widget, archivo): """ Recibe un archivo desde el filechooser para abrir en el lector. """ self.abrir(archivo) def limpiar(self): self.toolbartry.label.set_text("") self.documento = None self.previewcontainer.limpiar() self.load_pagina(None) self.textview.get_buffer().set_text("") map(self.ocultar, self.controlestexto) map(self.ocultar, self.controlespdf) def abrir(self, archivo): """ Abre un Archivo. """ descripcion = JAMF.describe_uri(archivo) if descripcion: if descripcion[2]: # Es un Archivo tipo = JAMF.describe_archivo(archivo) if 'pdf' in tipo: self.toolbartry.label.set_text(archivo) archivo = "file://%s" % (archivo) map(self.ocultar, self.controlestexto) map(self.mostrar, self.controlespdf) self.documento = Poppler.Document.new_from_file( archivo, None) self.npaginas = self.documento.get_n_pages() #thread = threading.Thread( target=self.llenar_preview ) #thread.start() self.previewcontainer.llenar(self.documento) elif 'text' in tipo: self.toolbartry.label.set_text(archivo) map(self.ocultar, self.controlespdf) map(self.mostrar, self.controlestexto) arch = open(archivo, "r") lineas = arch.readlines() arch.close() texto = "" for linea in lineas: texto += linea self.textview.get_buffer().set_text(texto) else: self.toolbartry.label.set_text("") self.documento = None self.previewcontainer.limpiar() self.load_pagina(None) self.textview.get_buffer().set_text("") #def llenar_preview(self): # """ Thread para cargar las páginas en preview. """ # self.previewcontainer.llenar(self.documento) def nueva_pagina(self, widget, indice): """ Cuando se selecciona una nueva pagina """ self.load_pagina(indice) def load_pagina(self, indice): """ Carga una página del Archivo pdf abierto actualmente. """ if indice != None: self.indexpaginaactiva = indice self.pagina = self.documento.get_page(self.indexpaginaactiva) self.visor.set_pagina(self.pagina) self.toolbarpaginas.set_pagina(self.indexpaginaactiva + 1, self.npaginas) else: self.indexpaginaactiva = None self.pagina = None self.visor.set_pagina(None) self.toolbarpaginas.set_pagina(None, None) def activar(self, widget, senial): """ Cuando se pasa de pagina. """ if senial == 'atras': if self.indexpaginaactiva > 0: self.previewcontainer.seleccionar(self.indexpaginaactiva - 1) else: self.previewcontainer.seleccionar(self.npaginas - 1) elif senial == 'siguiente': if self.indexpaginaactiva < self.npaginas - 1: self.previewcontainer.seleccionar(self.indexpaginaactiva + 1) else: self.previewcontainer.seleccionar(0) def embed_event(self, widget): """ No hace nada por ahora. """ print "JAMediaLector => OK" def confirmar_salir(self, widget=None, senial=None): """ Recibe salir y lo pasa a la toolbar de confirmación. """ map(self.ocultar, [self.toolbar_config]) self.toolbar_salir.run("JAMediaLector") def emit_salir(self, widget=None, senial=None): """ Emite salir para que cuando esta embebida, la aplicacion decida que hacer, si salir, o cerrar solo JAMediaLector. """ self.emit('salir')
class Ventana(gtk.Window): """ JAMediaTube. """ def __init__(self): super(Ventana, self).__init__() self.set_title("JAMediaTube") self.set_icon_from_file( os.path.join(JAMediaObjectsPath, "Iconos", "JAMediaTube.png")) self.set_resizable(True) self.set_size_request(640, 480) self.set_border_width(2) self.set_position(gtk.WIN_POS_CENTER) self.box_tube = None self.toolbar = None self.toolbar_busqueda = None self.toolbar_descarga = None self.toolbar_salir = None self.alerta_busqueda = None self.paneltube = None self.socketjamedia = gtk.Socket() self.jamedia = None self.pistas = [] self.videos_temp = [] self.__setup_init() def __setup_init(self): """ Crea y Empaqueta todo. """ from JAMediaTube.Widgets import Toolbar from JAMediaTube.Widgets import Toolbar_Busqueda from JAMediaTube.Widgets import Toolbar_Descarga from JAMediaTube.Widgets import Alerta_Busqueda from JAMediaTube.PanelTube import PanelTube from JAMediaObjects.JAMediaWidgets import ToolbarSalir boxbase = gtk.VBox() self.box_tube = gtk.VBox() self.toolbar = Toolbar() self.toolbar_busqueda = Toolbar_Busqueda() self.toolbar_descarga = Toolbar_Descarga() self.toolbar_salir = ToolbarSalir() self.alerta_busqueda = Alerta_Busqueda() self.paneltube = PanelTube() self.box_tube.pack_start(self.toolbar, False, False, 0) self.box_tube.pack_start(self.toolbar_salir, False, False, 0) self.box_tube.pack_start(self.toolbar_busqueda, False, False, 0) self.box_tube.pack_start(self.toolbar_descarga, False, False, 0) self.box_tube.pack_start(self.alerta_busqueda, False, False, 0) self.box_tube.pack_start(self.paneltube, True, True, 0) boxbase.pack_start(self.box_tube, True, True, 0) boxbase.pack_start(self.socketjamedia, True, True, 0) self.add(boxbase) from JAMediaTube.Widgets import Tube_Player self.jamedia = Tube_Player() self.socketjamedia.add_id(self.jamedia.get_id()) self.show_all() self.realize() self.paneltube.set_vista_inicial() # oculta las toolbarsaccion gobject.idle_add(self.__setup_init2) def __setup_init2(self): """ Inicializa la aplicación a su estado fundamental. """ self.jamedia.setup_init() self.jamedia.pack_standar() self.jamedia.pack_efectos() self.jamedia.switch_reproductor( None, "JAMediaReproductor") self.__cancel_toolbar() self.paneltube.cancel_toolbars_flotantes() map(self.__ocultar, [ self.toolbar_descarga, self.alerta_busqueda]) if self.pistas: self.jamedia.set_nueva_lista(self.pistas) self.__switch(None, 'jamedia') else: self.__switch(None, 'jamediatube') self.paneltube.encontrados.drag_dest_set( gtk.DEST_DEFAULT_ALL, target, gtk.gdk.ACTION_MOVE) self.paneltube.encontrados.connect( "drag-drop", self.__drag_drop) self.paneltube.encontrados.drag_dest_add_uri_targets() self.paneltube.descargar.drag_dest_set( gtk.DEST_DEFAULT_ALL, target, gtk.gdk.ACTION_MOVE) self.paneltube.descargar.connect( "drag-drop", self.__drag_drop) self.paneltube.descargar.drag_dest_add_uri_targets() self.connect("delete-event", self.__salir) self.toolbar.connect('salir', self.__confirmar_salir) self.toolbar_salir.connect( 'salir', self.__salir) self.toolbar.connect( 'switch', self.__switch, 'jamedia') self.jamedia.connect( 'salir', self.__switch, 'jamediatube') self.toolbar_busqueda.connect( "comenzar_busqueda", self.__comenzar_busqueda) self.paneltube.connect('download', self.__run_download) self.paneltube.connect('open_shelve_list', self.__open_shelve_list) self.toolbar_descarga.connect('end', self.__run_download) self.paneltube.connect("cancel_toolbar", self.__cancel_toolbar) def __cancel_toolbar(self, widget=None): self.toolbar_salir.cancelar() def __open_shelve_list(self, widget, shelve_list, toolbarwidget): """ Carga una lista de videos almacenada en un archivo shelve en el area del panel correspondiente según que toolbarwidget haya lanzado la señal. """ self.paneltube.set_sensitive(False) self.toolbar_busqueda.set_sensitive(False) destino = False if toolbarwidget == self.paneltube.toolbar_encontrados: destino = self.paneltube.encontrados elif toolbarwidget == self.paneltube.toolbar_descargar: destino = self.paneltube.descargar objetos = destino.get_children() for objeto in objetos: objeto.get_parent().remove(objeto) objeto.destroy() gobject.idle_add(self.__add_videos, shelve_list, destino) def __run_download(self, widget): """ Comienza descarga de un video. """ if self.toolbar_descarga.estado: return videos = self.paneltube.descargar.get_children() if videos: videos[0].get_parent().remove(videos[0]) self.toolbar_descarga.download(videos[0]) else: self.toolbar_descarga.hide() def __drag_drop(self, destino, drag_context, x, y, n): """ Ejecuta drop sobre un destino. """ videoitem = gtk.drag_get_source_widget(drag_context) if videoitem.get_parent() == destino: return else: # E try siguiente es para evitar problemas cuando: # El drag termina luego de que el origen se ha # comenzado a descargar y por lo tanto, no tiene padre. try: videoitem.get_parent().remove(videoitem) destino.pack_start(videoitem, False, False, 1) except: return if destino == self.paneltube.descargar: text = TipDescargas elif destino == self.paneltube.encontrados: text = TipEncontrados videoitem.set_tooltip_text(text) def __comenzar_busqueda(self, widget, palabras): """ Muestra la alerta de busqueda y lanza secuencia de busqueda y agregado de videos al panel. """ self.paneltube.set_sensitive(False) self.toolbar_busqueda.set_sensitive(False) self.__cancel_toolbar() self.paneltube.cancel_toolbars_flotantes() map(self.__mostrar, [self.alerta_busqueda]) self.alerta_busqueda.label.set_text( "Buscando: %s" % (palabras)) objetos = self.paneltube.encontrados.get_children() for objeto in objetos: objeto.get_parent().remove(objeto) objeto.destroy() gobject.timeout_add(300, self.__lanzar_busqueda, palabras) def __lanzar_busqueda(self, palabras): """ Lanza la Búsqueda y comienza secuencia que agrega los videos al panel. """ # FIXME: Reparar (Si no hay conexión) import JAMediaObjects.JAMediaYoutube as YT for video in YT.Buscar(palabras): self.videos_temp.append(video) gobject.idle_add(self.__add_videos, self.videos_temp, self.paneltube.encontrados) return False def __add_videos(self, videos, destino): """ Se crean los video_widgets de videos y se agregan al panel, segun destino. """ if len(self.videos_temp) < 1: # self.videos_temp contiene solo los videos # encontrados en las búsquedas, no los que se cargan # desde un archivo. map(self.__ocultar, [self.alerta_busqueda]) if not videos: self.paneltube.set_sensitive(True) self.toolbar_busqueda.set_sensitive(True) return False video = videos[0] from JAMediaTube.Widgets import WidgetVideoItem videowidget = WidgetVideoItem(video) text = TipEncontrados if destino == self.paneltube.encontrados: text = TipEncontrados elif destino == self.paneltube.descargar: text = TipDescargas videowidget.set_tooltip_text(text) videowidget.show_all() videowidget.drag_source_set( gtk.gdk.BUTTON1_MASK, target, gtk.gdk.ACTION_MOVE) # FIXME: Enlentece la aplicación ya que exige procesamiento. #archivo = "/tmp/preview%d" % time.time() #fileimage, headers = urllib.urlretrieve( # video["previews"][0][0], archivo) #pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(fileimage, # 50, 50) #videowidget.drag_source_set_icon_pixbuf(pixbuf) #commands.getoutput('rm %s' % (archivo)) videos.remove(video) destino.pack_start(videowidget, False, False, 1) texto = "Encontrado: %s" % (video["titulo"]) if len(texto) > 50: texto = str(texto[0:50]) + " . . . " self.alerta_busqueda.label.set_text(texto) #self.alerta_busqueda.label.set_text( # "Encontrado: %s" % (video["titulo"])) #self.get_property('window').invalidate_rect( # self.get_allocation(), True) #self.get_property('window').process_updates(True) gobject.idle_add(self.__add_videos, videos, destino) def set_pistas(self, pistas): """ Cuando se ejecuta pasandole un archivo. """ self.pistas = pistas def __switch(self, widget, valor): """ Cambia entre la vista de descargas y la de reproduccion. """ if valor == 'jamediatube': map(self.__ocultar, [self.socketjamedia]) map(self.__mostrar, [self.box_tube]) elif valor == 'jamedia': map(self.__ocultar, [self.box_tube]) map(self.__mostrar, [self.socketjamedia]) def __ocultar(self, objeto): if objeto.get_visible(): objeto.hide() def __mostrar(self, objeto): if not objeto.get_visible(): objeto.show() def __confirmar_salir(self, widget=None, senial=None): """ Recibe salir y lo pasa a la toolbar de confirmación. """ self.paneltube.cancel_toolbars_flotantes() self.toolbar_salir.run("JAMediaTube") def __salir(self, widget=None, senial=None): # FIXME: Hay que Mejorar esta forma de salir. import commands import sys commands.getoutput('killall mplayer') sys.exit(0)
class JAMediaAudioWidget(JAMediaVideoWidget): """ Plug - Interfaz para Webcam con grabación de audio. """ def __init__(self): """ JAMediaAudioWidget: Gtk.Plug para embeber en otra aplicacion. """ JAMediaVideoWidget.__init__(self) self.toolbar_salir = None self.toolbar = None self.pantalla = None self.balance_widget = None self.controles_dinamicos = [] self.jamediawebcam = None self.box_config = None self.widget_efectos = None self.widget_visualizadores_de_audio = None self.hbox_efectos_en_pipe = None self.show_all() def setup_init(self): """ Se crea la interfaz grafica, se setea y se empaqueta todo. """ from JAMediaObjects.JAMediaWidgets import WidgetsGstreamerAudioVisualizador from JAMediaObjects.JAMediaGstreamer.JAMediaAudio import JAMediaAudio from Widgets import ToolbarGrabarAudio # Widgets Base: - vbox - toolbars - panel basebox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.toolbar_salir = ToolbarSalir() self.toolbar = ToolbarGrabarAudio() hpanel = Gtk.HPaned() basebox.pack_start(self.toolbar_salir, False, True, 0) basebox.pack_start(self.toolbar, False, True, 0) basebox.pack_start(hpanel, True, True, 0) self.add(basebox) # Panel lado Izquierdo: vbox - pantalla - hbox_efectos_aplicados vbox_izq_panel = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.pantalla = Visor() eventbox = Gtk.EventBox() eventbox.modify_bg(0, get_color("NEGRO")) self.hbox_efectos_en_pipe = Gtk.Box( orientation=Gtk.Orientation.HORIZONTAL) self.hbox_efectos_en_pipe.set_size_request(-1, get_pixels(0.5)) scroll = Gtk.ScrolledWindow() scroll.set_policy( Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER) scroll.add_with_viewport(eventbox) eventbox.add(self.hbox_efectos_en_pipe) vbox_izq_panel.pack_start(self.pantalla, True, True, 0) vbox_izq_panel.pack_start(scroll, False, False, 0) hpanel.pack1(vbox_izq_panel, resize=True, shrink=True) # Panel lado Derecho: eventbox - vbox - scroll # - balance_widget - widget_efectos self.box_config = Gtk.EventBox() self.box_config.set_size_request(get_pixels(5.0), -1) vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.widget_visualizadores_de_audio = WidgetsGstreamerAudioVisualizador() scroll = Gtk.ScrolledWindow() scroll.set_policy( Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER) scroll.add_with_viewport(self.widget_visualizadores_de_audio) self.balance_widget = ToolbarBalanceConfig() vbox.pack_start(self.balance_widget, False, True, 0) vbox.pack_start(scroll, False, True, 0) scroll = Gtk.ScrolledWindow() scroll.set_policy( Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) scroll.add_with_viewport(vbox) self.box_config.add(scroll) self.widget_efectos = WidgetsGstreamerEfectos() vbox.pack_start(self.widget_efectos, False, True, 0) hpanel.pack2(self.box_config, resize=False, shrink=False) self.show_all() self.realize() from gi.repository import GdkX11 xid = self.pantalla.get_property('window').get_xid() self.jamediawebcam = JAMediaAudio(xid) self.controles_dinamicos = [ self.toolbar_salir, self.box_config, ] map(self.ocultar, self.controles_dinamicos) self.jamediawebcam.connect('estado', self.set_estado) self.pantalla.connect("button_press_event", self.clicks_en_pantalla) self.toolbar.connect("rotar", self.set_rotacion) self.toolbar.connect("accion", self.set_accion) self.toolbar.connect('salir', self.confirmar_salir) self.balance_widget.connect('valor', self.set_balance) self.widget_efectos.connect("click_efecto", self.click_efecto) self.widget_efectos.connect('configurar_efecto', self.configurar_efecto) self.widget_visualizadores_de_audio.connect( "click_efecto", self.click_visualizador) #self.widget_visualizadores_de_audio.connect( # 'configurar_efecto', self.configurar_visualizador) self.toolbar_salir.connect('salir', self.emit_salir) def set_accion(self, widget, senial): """ Cuando se hace click en grabar o en configurar. """ if senial == 'grabar': if self.jamediawebcam.estado != "GrabandoAudio": self.jamediawebcam.grabar() else: self.jamediawebcam.stop_grabar() elif senial == 'configurar': if self.box_config.get_visible(): self.box_config.hide() else: self.box_config.show() GLib.idle_add(self.update_balance_toolbars) elif senial == 'Reset': self.reset() def cargar_visualizadores(self, efectos): """ Agrega los widgets con efectos a la paleta de configuración. """ self.widget_visualizadores_de_audio.cargar_efectos(efectos) #def configurar_visualizador(self, widget, nombre_efecto, propiedad, valor): # """Configura un efecto en el pipe, si no está en eĺ, lo agrega.""" # self.jamediawebcam.configurar_visualizador(nombre_efecto, propiedad, valor) def click_visualizador(self, widget, nombre_efecto): if self.jamediawebcam.estado != "GrabandoAudio": self.jamediawebcam.set_visualizador(nombre_efecto) # FIXME: Agregar seleccionar visualizador actual def confirmar_salir(self, widget=None, senial=None): """ Recibe salir y lo pasa a la toolbar de confirmación. """ self.toolbar_salir.run("Menú Audio.")
class JAMediaPlayer(gtk.Plug): """ JAMedia: Interfaz grafica de: JAMediaReproductor y MplayerReproductor. Implementado sobre: python 2.7.3 y Gtk 3 Es un Gtk.Plug para embeber todo el reproductor en cualquier contenedor dentro de otra aplicacion. Para ello, es necesario crear en la aplicacion donde sera enbebida JAMedia, un socket: import JAMedia from JAMedia.JAMedia import JAMediaPlayer self.socket = Gtk.Socket() self.add(self.socket) self.jamediaplayer = JAMediaPlayer() socket.add_id(self.jamediaplayer.get_id() y luego proceder de la siguiente forma: gobject.idle_add(self.setup_init) def setup_init(self): self.jamediaplayer.setup_init() # Empaqueta las listas standar de JAMedia # self.jamediaplayer.pack_standar() # self.jamediaplayer.pack_efectos() NOTA: Tambien se puede ejecutar JAMedia directamente mediante python JAMedia.py """ __gtype_name__ = 'JAMediaPlayer' __gsignals__ = { "salir": (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, [])} def __init__(self): """ JAMedia: gtk.Plug para embeber en otra aplicacion. """ gtk.Plug.__init__(self, 0L) self.pantalla = None # visor para gstreamer self.barradeprogreso = None # progreso de reproducción self.volumen = None # volumen de audio self.lista_de_reproduccion = None # lista de reproducción self.controlesrepro = None # controles de reproducción self.toolbar = None # toolbar principal self.toolbar_list = None # Para el nombre de la lista . . . self.toolbar_config = None # control de balance y gamma self.widget_efectos = None # efectos gráficos self.toolbar_accion = None # para confirmar acciones ejem: salir self.toolbar_grabar = None # informa sobre grabacion en progreso self.toolbar_info = None # rotar, ocultar controles, etc self.toolbaraddstream = None # agregar un stream self.toolbar_salir = None # confirmar salir self.derecha_vbox = None # Contiene todos los widgets de la derecha self.hbox_efectos_en_pipe = None # informa sobre efectos que se aplican self.vbox_config = None # contiene balance y efectos self.scroll_config = None # contiene self.vbox_config # FIXME: Quitarlo, solo mantiene el gris de fondo para los botones en controles de reproducción. self.evnt_box_lista_reproduccion = None # contiene self.vbox_lista_reproduccion self.scroll_list = None # contiene self.lista_de_reproduccion self.controles_dinamicos = None # controles que se ocultan o muestran segun config self.mplayerreproductor = None # mplayer self.jamediareproductor = None # Gstreamer 1.0 self.mplayergrabador = None # grabador mplayer self.jamediagrabador = None # grabador Gstreamer 1.0 self.player = None # reproductor actual mplayer o Gstreamer 1.0 self.grabador = None # grabador actual mplayer o Gstreamer 1.0 self.cursor_root = None # cursor de aplicacion que embebe a jamedia. self.jamedia_cursor = None # cursor de jamedia self.mouse_in_visor = False # flag, el mouse se oculta sobre el visor self.show_all() self.connect("embedded", self.__embed_event) def setup_init(self): """ Se crea la interfaz grafica, se setea y se empaqueta todo. """ self.get_toplevel().set_sensitive(False) from JAMediaObjects.JAMediaWidgets import Visor from JAMediaObjects.JAMediaWidgets import BarraProgreso from JAMediaObjects.JAMediaWidgets import ControlVolumen from JAMediaObjects.JAMediaWidgets import Lista from JAMediaObjects.JAMediaWidgets import ToolbarReproduccion from JAMediaObjects.JAMediaWidgets import WidgetsGstreamerEfectos from JAMediaObjects.JAMediaWidgets import ToolbarAccion from JAMediaObjects.JAMediaWidgets import ToolbarSalir from Widgets import Toolbar from Widgets import ToolbarConfig from Widgets import ToolbarGrabar from Widgets import ToolbarInfo from Widgets import ToolbarAddStream self.pantalla = Visor() self.barradeprogreso = BarraProgreso() self.volumen = ControlVolumen() self.lista_de_reproduccion = Lista() self.controlesrepro = ToolbarReproduccion() self.toolbar = Toolbar() self.toolbar_config = ToolbarConfig() self.widget_efectos = WidgetsGstreamerEfectos() self.toolbar_accion = ToolbarAccion() self.toolbar_grabar = ToolbarGrabar() self.toolbar_info = ToolbarInfo() self.toolbaraddstream = ToolbarAddStream() self.toolbar_salir = ToolbarSalir() basebox = gtk.VBox() hpanel = gtk.HPaned() basebox.pack_start(self.toolbar, False, False, 0) basebox.pack_start(self.toolbar_salir, False, False, 0) basebox.pack_start(self.toolbar_accion, False, False, 0) basebox.pack_start(self.toolbaraddstream, False, False, 0) basebox.pack_start(hpanel, True, True, 0) ### Area Izquierda del Panel ### Efectos que se están aplicando. # FIXME: Mantiene el fondo negro en miniefectos que se aplican eventbox = gtk.EventBox() eventbox.modify_bg(0, get_color("NEGRO")) self.hbox_efectos_en_pipe = gtk.HBox() self.hbox_efectos_en_pipe.set_size_request(-1, get_pixels(0.5)) eventbox.add(self.hbox_efectos_en_pipe) scroll = gtk.ScrolledWindow() scroll.set_policy( gtk.POLICY_AUTOMATIC, gtk.POLICY_NEVER) scroll.add_with_viewport(eventbox) ### Barra de Progreso + Volúmen ev_box = gtk.EventBox() # FIXME: Para poder pintar el fondo de volumen ev_box.modify_bg(0, get_color("BLANCO")) hbox_barra_progreso = gtk.HBox() hbox_barra_progreso.pack_start(self.barradeprogreso, True, True, 0) hbox_barra_progreso.pack_start(self.volumen, False, False, 0) ev_box.add(hbox_barra_progreso) ### Todo vbox = gtk.VBox() vbox.pack_start(self.toolbar_grabar, False, False, 0) vbox.pack_start(self.pantalla, True, True, 0) vbox.pack_start(scroll, False, False, 0) vbox.pack_start(self.toolbar_info, False, False, 0) vbox.pack_start(ev_box, False, True, 0) hpanel.pack1(vbox, resize=True, shrink=True) ### Area Derecha del Panel self.derecha_vbox = gtk.VBox() ### Configuración de balanace y efectos self.vbox_config = gtk.VBox() self.scroll_config = gtk.ScrolledWindow() self.scroll_config.set_policy( gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.scroll_config.add_with_viewport(self.vbox_config) self.vbox_config.pack_start(self.toolbar_config, False, False, 0) self.vbox_config.pack_start(self.widget_efectos, False, False, 0) ### Lista de Reproducción # FIXME: Para poder pintar el fondo self.evnt_box_lista_reproduccion = gtk.EventBox() self.vbox_lista_reproduccion = gtk.VBox() self.scroll_list = gtk.ScrolledWindow() self.scroll_list.set_policy( gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.scroll_list.add(self.lista_de_reproduccion) #Lista + Controles de Reproducción self.__pack_vbox_lista_reproduccion() self.evnt_box_lista_reproduccion.add(self.vbox_lista_reproduccion) ### Configuración + Lista de Reproducción. self.derecha_vbox.pack_start(self.scroll_config, True, True, 0) self.derecha_vbox.pack_start(self.evnt_box_lista_reproduccion, True, True, 0) hpanel.pack2(self.derecha_vbox, resize=False, shrink=True) self.controles_dinamicos = [ hbox_barra_progreso, self.derecha_vbox, self.toolbar, self.toolbar_info, self.hbox_efectos_en_pipe.get_parent().get_parent( ).get_parent()] basebox.show_all() map(self.__ocultar, [self.toolbar_salir, self.scroll_config, self.toolbar_accion, self.toolbar_grabar, self.toolbaraddstream, self.toolbar_info.descarga]) self.add(basebox) xid = self.pantalla.get_property('window').xid # HACK: La aplicación nunca debe explotar :P if get_programa("mplayer"): self.mplayerreproductor = MplayerReproductor(xid) elif not get_programa("mplayer") and "xo1.5" in platform.platform(): self.mplayerreproductor = MplayerReproductor(xid) else: self.mplayerreproductor = MplayerReproductor(self.pantalla) # HACK: La aplicación nunca debe explotar :P if verificar_Gstreamer(): self.jamediareproductor = JAMediaReproductor(xid) else: self.jamediareproductor = JAMediaReproductor(self.pantalla) self.switch_reproductor(None, "JAMediaReproductor") # default Gst. self.mplayerreproductor.connect("endfile", self.__endfile) self.mplayerreproductor.connect("estado", self.__cambioestadoreproductor) self.mplayerreproductor.connect("newposicion", self.__update_progress) self.mplayerreproductor.connect("volumen", self.__get_volumen) self.mplayerreproductor.connect("video", self.__set_video) self.jamediareproductor.connect("endfile", self.__endfile) self.jamediareproductor.connect("estado", self.__cambioestadoreproductor) self.jamediareproductor.connect("newposicion", self.__update_progress) self.jamediareproductor.connect("volumen", self.__get_volumen) self.jamediareproductor.connect("video", self.__set_video) self.lista_de_reproduccion.connect("nueva-seleccion", self.__cargar_reproducir) self.lista_de_reproduccion.connect("button-press-event", self.__click_derecho_en_lista) self.controlesrepro.connect("activar", self.__activar) self.barradeprogreso.connect("user-set-value", self.__user_set_value) self.pantalla.connect("ocultar_controles", self.__ocultar_controles) self.pantalla.connect("button_press_event", self.__clicks_en_pantalla) #self.pantalla.connect('expose-event', self.paint_pantalla) self.toolbar.connect('salir', self.confirmar_salir) #self.toolbar.connect('capturar', self.fotografiar) self.toolbar.connect('config', self.__mostrar_config) self.toolbar_salir.connect('salir', self.__emit_salir) self.toolbar_config.connect('reproductor', self.switch_reproductor) self.toolbar_config.connect('valor', self.__set_balance) self.toolbar_info.connect('rotar', self.__set_rotacion) self.toolbar_info.connect('actualizar_streamings', self.__actualizar_streamings) self.toolbar_accion.connect("Grabar", self.__grabar_streaming) self.toolbar_accion.connect("accion-stream", self.__accion_stream) self.toolbar_grabar.connect("stop", self.__detener_grabacion) self.volumen.connect("volumen", self.__set_volumen) self.toolbaraddstream.connect("add-stream", self.__ejecutar_add_stream) self.widget_efectos.connect("click_efecto", self.__click_efecto) self.widget_efectos.connect('configurar_efecto', self.__configurar_efecto) ### Controlador del mouse. # FIXME: new_from_pixbuf y get_default no existe #icono = os.path.join(JAMediaObjectsPath, # "Iconos", "jamedia_cursor.png") #pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(icono, # -1, get_pixels(0.8)) #self.jamedia_cursor = gtk.gdk.Cursor.new_from_pixbuf( # gtk.gdk.Display.get_default(), pixbuf, 0, 0) #self.cursor_root = self.get_parent_window().get_cursor() #self.get_parent_window().set_cursor(self.jamedia_cursor) #from JAMediaObjects.JAMediaWidgets import MouseSpeedDetector #self.mouse_listener = MouseSpeedDetector(self) #self.mouse_listener.connect("estado", self.__set_mouse) #self.mouse_listener.new_handler(True) self.get_parent().connect("hide", self.__hide_show_parent) self.get_parent().connect("show", self.__hide_show_parent) self.hbox_efectos_en_pipe.get_parent().get_parent( ).get_parent().hide() self.get_toplevel().set_sensitive(True) # FIXME: La idea es utilizar gdkpixbufsink en el pipe. #def fotografiar(self, widget): # """ # Captura una imagen desde el video en reproduccion. # """ # self.player.fotografiar() def __hide_show_parent(self, widget): """ Controlador del mouse funcionará solo si JAMedia es Visible. """ pass #self.mouse_listener.new_handler(widget.get_visible()) def __set_mouse(self, widget, estado): """ Muestra u oculta el mouse de jamedia según su posición. """ if self.mouse_in_visor: ### Solo cuando el mouse está sobre el Visor. if estado == "moviendose": if self.get_parent_window().get_cursor() != self.jamedia_cursor: self.get_parent_window().set_cursor( self.jamedia_cursor) return elif estado == "detenido": if self.get_parent_window().get_cursor() != gtk.gdk.BLANK_CURSOR: self.get_parent_window().set_cursor( gtk.gdk.Cursor(gtk.gdk.BLANK_CURSOR)) return elif estado == "fuera": if self.get_parent_window().get_cursor() != self.cursor_root: self.get_parent_window().set_cursor( self.cursor_root) return else: if estado == "moviendose" or "detenido": if self.get_parent_window().get_cursor() != self.jamedia_cursor: self.get_parent_window().set_cursor( self.jamedia_cursor) return elif estado == "fuera": if self.get_parent_window().get_cursor() != self.cursor_root: self.get_parent_window().set_cursor( self.cursor_root) return def __cancel_toolbars_flotantes(self, widget=None): """ Asegura un widget flotante a la vez. """ self.toolbaraddstream.cancelar() self.__cancel_toolbar() def __cancel_toolbar(self, widget=None): """ Asegura un widget flotante a la vez. """ self.toolbar_accion.cancelar() self.toolbar_salir.cancelar() def __configurar_efecto(self, widget, nombre_efecto, propiedad, valor): """ Configura un efecto en el pipe, si no está en eĺ, lo agrega. """ # Si el efecto no está agregado al pipe, lo agrega if self.player.efectos: if not nombre_efecto in self.player.efectos: self.__click_efecto(None, nombre_efecto) self.widget_efectos.seleccionar_efecto(nombre_efecto) else: self.__click_efecto(None, nombre_efecto) self.widget_efectos.seleccionar_efecto(nombre_efecto) # Setea el efecto self.player.configurar_efecto(nombre_efecto, propiedad, valor) def __click_efecto(self, widget, nombre_efecto): """ Recibe el nombre del efecto sobre el que se ha hecho click y decide si debe agregarse al pipe de JAMedia. """ self.get_toplevel().set_sensitive(False) self.__cancel_toolbars_flotantes() agregar = False if self.player.efectos: if not nombre_efecto in self.player.efectos: agregar = True else: agregar = True if agregar: self.player.agregar_efecto(nombre_efecto) from Widgets import WidgetEfecto_en_Pipe # Agrega un widget a self.hbox_efectos_en_pipe botonefecto = WidgetEfecto_en_Pipe() botonefecto.set_tooltip(nombre_efecto) botonefecto.connect('clicked', self.__clicked_mini_efecto) lado = get_pixels(0.5) botonefecto.set_tamanio(lado, lado) archivo = os.path.join(JAMediaObjectsPath, "Iconos", 'configurar.png') pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(archivo, lado, lado) botonefecto.imagen.set_from_pixbuf(pixbuf) self.hbox_efectos_en_pipe.pack_start(botonefecto, False, False, 0) self.hbox_efectos_en_pipe.get_parent().get_parent( ).get_parent().show() else: self.player.quitar_efecto(nombre_efecto) self.widget_efectos.des_seleccionar_efecto(nombre_efecto) # Quitar el widget de self.hbox_efectos_en_pipe for efecto in self.hbox_efectos_en_pipe.get_children(): if efecto.get_tooltip_text() == nombre_efecto: efecto.destroy() break if not self.hbox_efectos_en_pipe.get_children(): self.hbox_efectos_en_pipe.get_parent().get_parent( ).get_parent().hide() self.get_toplevel().set_sensitive(True) def __clicked_mini_efecto(self, widget, void=None): """ Cuando se hace click en el mini objeto en pantalla para efecto agregado, este se quita del pipe de la cámara. """ self.__cancel_toolbars_flotantes() nombre_efecto = widget.get_tooltip_text() self.player.quitar_efecto(nombre_efecto) self.widget_efectos.des_seleccionar_efecto(nombre_efecto) widget.destroy() if not self.hbox_efectos_en_pipe.get_children(): self.hbox_efectos_en_pipe.get_parent().get_parent( ).get_parent().hide() def __cargar_efectos(self, efectos): """ Agrega los widgets con efectos a la paleta de configuración. """ self.widget_efectos.cargar_efectos(efectos) return False def __actualizar_streamings(self, widget): """ Actualiza los streamings de jamedia, descargandolos desde su web. """ self.__cancel_toolbars_flotantes() from Widgets import DialogoDescarga dialog = DialogoDescarga(parent=self.get_toplevel()) dialog.run() def __accion_stream(self, widget, accion, url): """ Ejecuta una acción sobre un streaming. borrar de la lista, eliminar streaming, copiar a jamedia, mover a jamedia. """ lista = self.toolbar_list.label.get_text() from JAMediaObjects.JAMediaGlobales import eliminar_streaming from JAMediaObjects.JAMediaGlobales import add_stream if accion == "Borrar": eliminar_streaming(url, lista) print "Streaming Eliminado:", url elif accion == "Copiar": modelo, iter = self.lista_de_reproduccion.treeselection.get_selected() nombre = modelo.get_value(iter, 1) url = modelo.get_value(iter, 2) tipo = self.toolbar_list.label.get_text() add_stream(tipo, [nombre, url]) elif accion == "Mover": modelo, iter = self.lista_de_reproduccion.treeselection.get_selected() nombre = modelo.get_value(iter, 1) url = modelo.get_value(iter, 2) tipo = self.toolbar_list.label.get_text() add_stream(tipo, [nombre, url]) eliminar_streaming(url, lista) else: print "accion_stream desconocido:", accion def __ejecutar_add_stream(self, widget, tipo, nombre, url): """ Ejecuta agregar stream, de acuerdo a los datos que pasa toolbaraddstream en add-stream. """ from JAMediaObjects.JAMediaGlobales import add_stream add_stream(tipo, [nombre, url]) if "Tv" in tipo or "TV" in tipo: indice = 3 elif "Radio" in tipo: indice = 2 else: return self.__cargar_lista(None, indice) def __set_rotacion(self, widget, valor): """ Recibe la señal de rotacion de la toolbar y envia la rotacion al Reproductor. """ self.get_toplevel().set_sensitive(False) self.__cancel_toolbars_flotantes() self.player.rotar(valor) self.get_toplevel().set_sensitive(True) def __set_balance(self, widget, valor, tipo): """ Setea valores en Balance de Video, pasando los valores que recibe de la toolbar (% float). """ self.__cancel_toolbars_flotantes() if tipo == "saturacion": self.player.set_balance(saturacion=valor) if tipo == "contraste": self.player.set_balance(contraste=valor) if tipo == "brillo": self.player.set_balance(brillo=valor) if tipo == "hue": self.player.set_balance(hue=valor) if tipo == "gamma": self.player.set_balance(gamma=valor) def __pack_vbox_lista_reproduccion(self): """ Empaqueta la lista de reproduccion. Se hace a parte porque la toolbar de la lista no debe empaquetarse cuando JAMedia es embebida en otra aplicacion. """ self.vbox_lista_reproduccion.pack_start(self.scroll_list, True, True, 0) self.vbox_lista_reproduccion.pack_end(self.controlesrepro, False, True, 0) def __clicks_en_pantalla(self, widget, event): """ Hace fullscreen y unfullscreen sobre la ventana principal donde JAMedia está embebida cuando el usuario hace doble click en el visor. """ if event.type.value_name == "GDK_2BUTTON_PRESS": self.get_toplevel().set_sensitive(False) ventana = self.get_toplevel() screen = ventana.get_screen() w, h = ventana.get_size() ww, hh = (screen.get_width(), screen.get_height()) self.__cancel_toolbars_flotantes() if ww == w and hh == h: ventana.set_border_width(2) gobject.idle_add(ventana.unfullscreen) else: ventana.set_border_width(0) gobject.idle_add(ventana.fullscreen) self.get_toplevel().set_sensitive(True) def __mostrar_config(self, widget): """ Muestra u oculta las opciones de configuracion (toolbar_config y widget_efectos). """ self.get_toplevel().set_sensitive(False) map(self.__ocultar, [ self.toolbar_accion, self.toolbaraddstream, self.toolbar_salir]) if self.scroll_config.get_visible(): self.scroll_config.hide() self.evnt_box_lista_reproduccion.show() else: rect = self.evnt_box_lista_reproduccion.get_allocation() self.scroll_config.set_size_request(rect.width, -1) self.evnt_box_lista_reproduccion.hide() self.scroll_config.show_all() gobject.idle_add(self.__update_balance_toolbars) self.get_toplevel().set_sensitive(True) def switch_reproductor(self, widget, nombre): """ Recibe la señal "reproductor" desde toolbar_config y cambia el reproductor que se utiliza, entre mplayer y jamediareproductor (Gst 1.0). """ self.get_toplevel().set_sensitive(False) reproductor = self.player # HACK: JAMediaReproductor no funciona con Tv. #if reproductor == self.mplayerreproductor and \ # ("TV" in self.toolbar_list.label.get_text() or \ # "Tv" in self.toolbar_list.label.get_text()): # self.toolbar_config.mplayer_boton.set_active(True) # self.toolbar_config.jamedia_boton.set_active(False) # return if nombre == "MplayerReproductor": if get_programa('mplayer'): reproductor = self.mplayerreproductor self.toolbar_info.set_reproductor("MplayerReproductor") self.toolbar_config.mplayer_boton.set_active(True) elif not get_programa('mplayer') and \ "xo1.5" in platform.platform(): reproductor = self.mplayerreproductor self.toolbar_info.set_reproductor("MplayerReproductor") self.toolbar_config.mplayer_boton.set_active(True) else: reproductor = self.jamediareproductor self.toolbar_info.set_reproductor("JAMediaReproductor") self.toolbar_config.jamedia_boton.set_active(True) elif nombre == "JAMediaReproductor": reproductor = self.jamediareproductor self.toolbar_info.set_reproductor("JAMediaReproductor") self.toolbar_config.jamedia_boton.set_active(True) if self.player != reproductor: try: self.player.stop() except: pass self.player = reproductor print "Reproduciendo con:", self.player.name try: model, iter = self.lista_de_reproduccion.treeselection.get_selected() valor = model.get_value(iter, 2) self.player.load(valor) except: pass self.get_toplevel().set_sensitive(True) def __embed_event(self, widget): """ No hace nada por ahora. """ print "JAMediaPlayer => OK" ''' # FIXME: Nueva metodología Según JAMediaLector, esto reemplaza # self.pantalla.connect("ocultar_controles", self.ocultar_controles) def do_motion_notify_event(self, event): """ Cuando se mueve el mouse sobre la ventana. """ if self.toolbar_info.ocultar_controles: x, y = (int(event.x), int(event.y)) rect = self.get_allocation() xx, yy, ww, hh = (rect.x, rect.y, rect.width, rect.height) arriba = range(0, self.toolbar.get_allocation().height) abajo = range(hh - self.controlesrepro.get_allocation().height, hh) derecha = range(ww - self.derecha_vbox.get_allocation().width, ww) ###Arriba ###Derecha ###Abajo if y in arriba or x in derecha or y in abajo: map(self.mostrar, self.controles_dinamicos) else: map(self.ocultar, [ #self.scroll_config, self.toolbar_accion, self.toolbaraddstream, self.toolbar_salir]) map(self.ocultar, self.controles_dinamicos) else: map(self.mostrar, self.controles_dinamicos)''' def __ocultar_controles(self, widget, valor): """ Oculta o muestra los controles. """ self.mouse_in_visor = valor self.get_toplevel().set_sensitive(False) zona, ocultar = (valor, self.toolbar_info.ocultar_controles) if zona and ocultar: map(self.__ocultar, [ #self.scroll_config, self.toolbar_accion, self.toolbaraddstream, self.toolbar_salir]) map(self.__ocultar, self.controles_dinamicos) elif zona and not ocultar: pass elif not zona and ocultar: #self.scroll_config.hide() map(self.__mostrar, self.controles_dinamicos) if not self.hbox_efectos_en_pipe.get_children(): self.hbox_efectos_en_pipe.get_parent().get_parent( ).get_parent().hide() elif not zona and not ocultar: pass self.get_toplevel().set_sensitive(True) def __ocultar(self, objeto): """ Esta funcion es llamada desde self.ocultar_controles() """ if objeto.get_visible(): objeto.hide() def __mostrar(self, objeto): """ Esta funcion es llamada desde self.ocultar_controles() """ if not objeto.get_visible(): objeto.show() def __activar(self, widget=None, senial=None): """ Recibe: "atras", "siguiente", "stop" o "pause-play" desde la toolbar de reproduccion y ejecuta: atras o siguiente sobre la lista de reproduccion y stop o pause-play sobre el reproductor. """ self.get_toplevel().set_sensitive(False) self.__cancel_toolbars_flotantes() if not self.lista_de_reproduccion.modelo.get_iter_first(): return if senial == "atras": self.lista_de_reproduccion.seleccionar_anterior() elif senial == "siguiente": self.lista_de_reproduccion.seleccionar_siguiente() elif senial == "stop": self.player.stop() elif senial == "pausa-play": self.player.pause_play() while gtk.events_pending(): gtk.main_iteration() self.get_toplevel().set_sensitive(True) def __endfile(self, widget=None, senial=None): """ Recibe la señal de fin de archivo desde el reproductor y llama a seleccionar_siguiente en la lista de reproduccion. """ self.controlesrepro.set_paused() gobject.idle_add(self.lista_de_reproduccion.seleccionar_siguiente) def __cambioestadoreproductor(self, widget=None, valor=None): """ Recibe los cambios de estado del reproductor (paused y playing) y actualiza la imagen del boton play en la toolbar de reproduccion. """ if "playing" in valor: self.controlesrepro.set_playing() elif "paused" in valor or "None" in valor: self.controlesrepro.set_paused() else: print "Estado del Reproductor desconocido:", valor gobject.idle_add(self.__update_balance_toolbars) def __update_balance_toolbars(self): """ Actualiza las toolbars de balance en video. """ config = self.player.get_balance() self.toolbar_config.set_balance( brillo=config['brillo'], contraste=config['contraste'], saturacion=config['saturacion'], hue=config['hue'], gamma=config['gamma']) return False def __update_progress(self, objetoemisor, valor): """ Recibe el progreso de la reproduccion desde el reproductor y actualiza la barra de progreso. """ self.barradeprogreso.set_progress(float(valor)) def __user_set_value(self, widget=None, valor=None): """ Recibe la posicion en la barra de progreso cuando el usuario la desplaza y hace "seek" sobre el reproductor. """ self.__cancel_toolbars_flotantes() self.player.set_position(valor) def pack_standar(self): """ Re empaqueta algunos controles de JAMedia. Cuando JAMedia no está embebido, tiene su toolbar_list """ self.get_toplevel().set_sensitive(False) from JAMediaObjects.JAMediaGlobales import set_listas_default set_listas_default() from Widgets import ToolbarLista self.toolbar_list = ToolbarLista() self.toolbar_list.connect("cargar_lista", self.__cargar_lista) self.toolbar_list.connect("add_stream", self.__add_stream) self.toolbar_list.connect("menu_activo", self.__cancel_toolbars_flotantes) self.toolbar_list.show_all() self.toolbar_list.boton_agregar.hide() self.toolbar_info.descarga.show() for child in self.vbox_lista_reproduccion.get_children(): self.vbox_lista_reproduccion.remove(child) self.vbox_lista_reproduccion.pack_start(self.toolbar_list, False, False, 0) self.__pack_vbox_lista_reproduccion() self.get_toplevel().set_sensitive(True) def pack_efectos(self): """ Empaqueta los widgets de efectos gstreamer. """ self.get_toplevel().set_sensitive(False) self.vbox_config.pack_start(self.widget_efectos, False, False, 0) from JAMediaObjects.JAMediaGlobales import get_jamedia_video_efectos gobject.idle_add(self.__cargar_efectos, list(get_jamedia_video_efectos())) self.get_toplevel().set_sensitive(True) def __add_stream(self, widget): """ Recibe la señal add_stream desde toolbarlist y abre la toolbar que permite agregar un stream. """ self.__cancel_toolbar() map(self.__ocultar, [ self.scroll_config, self.toolbar_accion]) if not self.toolbaraddstream.get_visible(): accion = widget.label.get_text() self.toolbaraddstream.set_accion(accion) self.toolbaraddstream.show() else: self.toolbaraddstream.hide() def set_nueva_lista(self, lista): """ Carga una lista de archivos directamente, sin utilizar la toolbarlist, esto es porque: cuando jamedia está embebido, no tiene la toolbar_list """ if not lista: return self.player.stop() if self.toolbar_list: self.toolbar_list.label.set_text("") self.lista_de_reproduccion.limpiar() gobject.idle_add(self.lista_de_reproduccion.agregar_items, lista) return False def __cargar_reproducir(self, widget, path): """ Recibe lo que se selecciona en la lista de reproduccion y lo manda al reproductor. """ # HACK: Cuando cambia de pista se deben # reestablecer los valores de balance para # que no cuelgue la aplicación, por lo tanto, # el usuario no puede estar modificando estos # valores en el momento en que cambia la pista # en el reproductor. self.get_toplevel().set_sensitive(False) visible = self.scroll_config.get_visible() if visible: self.scroll_config.hide() #self.player.load(path) gobject.idle_add(self.player.load, path) if visible: self.scroll_config.show() self.get_toplevel().set_sensitive(True) def confirmar_salir(self, widget=None, senial=None): """ Recibe salir y lo pasa a la toolbar de confirmación. Es pública para sobre escritura. """ #map(self.__ocultar, [self.toolbaraddstream]) self.__cancel_toolbars_flotantes() self.toolbar_salir.run("JAMedia") def __emit_salir(self, widget): """ Emite salir para que cuando esta embebida, la aplicacion decida que hacer, si salir, o cerrar solo JAMedia. """ if self.grabador != None: self.grabador.stop() self.player.stop() #self.lista_de_reproduccion.limpiar() while gtk.events_pending(): gtk.main_iteration() self.emit('salir') def __cargar_lista(self, widget, indice): """ Recibe el indice seleccionado en el menu de toolbarlist y carga la lista correspondiente. Esto es solo para JAMedia no embebido ya que cuando JAMedia esta embebida, no posee la toolbarlist. """ model, iter = self.lista_de_reproduccion.treeselection.get_selected() ultimopath = False if model and iter: valor = model.get_value(iter, 2) if valor: from JAMediaObjects.JAMFileSystem import describe_uri descripcion = describe_uri(valor) if descripcion: if descripcion[2]: ultimopath = valor map(self.__ocultar, [ self.toolbar_accion, self.toolbaraddstream]) self.toolbar_list.boton_agregar.hide() from JAMediaObjects.JAMediaGlobales import get_data_directory from JAMediaObjects.JAMediaGlobales import get_my_files_directory from JAMediaObjects.JAMediaGlobales import get_tube_directory from JAMediaObjects.JAMediaGlobales import get_audio_directory from JAMediaObjects.JAMediaGlobales import get_video_directory if indice == 0: archivo = os.path.join( get_data_directory(), 'JAMediaRadio.JAMedia') self.__seleccionar_lista_de_stream(archivo, "JAM-Radio") elif indice == 1: # HACK: Tv no funciona con JAMediaReproductor. #if self.player == self.jamediareproductor: # self.switch_reproductor(None, "MplayerReproductor") archivo = os.path.join( get_data_directory(), 'JAMediaTV.JAMedia') self.__seleccionar_lista_de_stream(archivo, "JAM-TV") elif indice == 2: archivo = os.path.join( get_data_directory(), 'MisRadios.JAMedia') self.__seleccionar_lista_de_stream(archivo, "Radios") self.toolbar_list.boton_agregar.show() elif indice == 3: # HACK: Tv no funciona con JAMediaReproductor. #if self.player == self.jamediareproductor: # self.switch_reproductor(None, "MplayerReproductor") archivo = os.path.join( get_data_directory(), 'MisTvs.JAMedia') self.__seleccionar_lista_de_stream(archivo, "TVs") self.toolbar_list.boton_agregar.show() elif indice == 4: self.__seleccionar_lista_de_archivos( get_my_files_directory(), "Archivos") elif indice == 5: self.__seleccionar_lista_de_archivos( get_tube_directory(), "JAM-Tube") elif indice == 6: self.__seleccionar_lista_de_archivos( get_audio_directory(), "JAM-Audio") elif indice == 7: self.__seleccionar_lista_de_archivos( get_video_directory(), "JAM-Video") elif indice == 8: from Widgets import My_FileChooser directorio = None if ultimopath: directorio = "file://%s" % os.path.dirname(ultimopath) selector = My_FileChooser( parent=self.get_toplevel(), action=gtk.FILE_CHOOSER_ACTION_OPEN, mime=["audio/*", "video/*"], title="Abrir Archivos.", path=directorio, filter=[]) selector.connect('archivos-seleccionados', self.__cargar_directorio) selector.run() def __cargar_directorio(self, widget, archivos): """ Recibe una lista de archivos y setea la lista de reproduccion con ellos. """ if not archivos: return items = [] for archivo in archivos: path = archivo archivo = os.path.basename(path) items.append([archivo, path]) self.set_nueva_lista(items) def __seleccionar_lista_de_archivos(self, directorio, titulo): """ Responde a la seleccion en el menu de la toolbarlist. Recibe un directorio para generar una lista de archivos y setear la lista de reproduccion con ellos y recibe un titulo para la lista cargada. Esto es solo para las listas standar de JAMedia no embebido. """ self.player.stop() archivos = sorted(os.listdir(directorio)) lista = [] for texto in archivos: url = os.path.join(directorio, texto) elemento = [texto, url] lista.append(elemento) self.toolbar_list.label.set_text(titulo) self.lista_de_reproduccion.limpiar() gobject.idle_add(self.lista_de_reproduccion.agregar_items, lista) def __seleccionar_lista_de_stream(self, archivo, titulo): """ Responde a la seleccion en el menu de la toolbarlist. Recibe un archivo desde donde cargar una lista de streamings, carga los streamings y los pasa a la lista de reproduccion, y recibe un titulo para la nueva lista. Esto es solo para las listas standar de JAMedia no embebido. """ self.player.stop() self.__cancel_toolbars_flotantes() from JAMediaObjects.JAMediaGlobales import get_streamings items = get_streamings(archivo) self.toolbar_list.label.set_text(titulo) self.lista_de_reproduccion.limpiar() gobject.idle_add(self.lista_de_reproduccion.agregar_items, items) def __click_derecho_en_lista(self, widget, event): """ Esto es para abrir un menu de opciones cuando el usuario hace click derecho sobre un elemento en la lista de reproduccion, permitiendo copiar, mover y borrar el archivo o streaming o simplemente quitarlo de la lista. """ self.__cancel_toolbars_flotantes() # FIXME: Desactivar __cargar_reproducir boton = event.button pos = (event.x, event.y) tiempo = event.time path, columna, xdefondo, ydefondo = (None, None, None, None) try: path, columna, xdefondo, ydefondo = widget.get_path_at_pos( int(pos[0]), int(pos[1])) except: return # TreeView.get_path_at_pos(event.x, event.y) devuelve: # * La ruta de acceso en el punto especificado (x, y), # en relación con las coordenadas widget # * El gtk.TreeViewColumn en ese punto # * La coordenada X en relación con el fondo de la celda # * La coordenada Y en relación con el fondo de la celda if boton == 1: return elif boton == 3: from Widgets import MenuList menu = MenuList(widget, boton, pos, tiempo, path, widget.modelo) menu.connect('accion', self.__set_accion) gtk.Menu.popup(menu, None, None, None, boton, tiempo) elif boton == 2: return def __set_accion(self, widget, lista, accion, iter): """ Responde a la seleccion del usuario sobre el menu que se despliega al hacer click derecho sobre un elemento en la lista de reproduccion. Recibe la lista de reproduccion, una accion a realizar sobre el elemento seleccionado en ella y el elemento seleccionado y pasa todo a toolbar_accion para pedir confirmacion al usuario sobre la accion a realizar. """ self.toolbar_accion.set_accion(lista, accion, iter) def __grabar_streaming(self, widget, uri): """ Se ha confirmado grabar desde un streaming en la toolbar_accion. """ self.get_toplevel().set_sensitive(False) self.__detener_grabacion() # FIXME: Reparar para grabar Tv Con JAMediaReproductor extension = "" if "TV" in self.toolbar_list.label.get_text() or \ "Tv" in self.toolbar_list.label.get_text(): extension = ".avi" else: extension = ".mp3" import time import datetime hora = time.strftime("%H-%M-%S") fecha = str(datetime.date.today()) from JAMediaObjects.JAMediaGlobales import get_my_files_directory archivo = "%s-%s-%s" % (fecha, hora, extension) archivo = os.path.join(get_my_files_directory(), archivo) if self.player == self.jamediareproductor: self.grabador = JAMediaGrabador(uri, archivo) elif self.player == self.mplayerreproductor: self.grabador = MplayerGrabador(uri, archivo) self.grabador.connect('update', self.__update_grabador) self.get_toplevel().set_sensitive(True) def __update_grabador(self, widget, datos): """ Actualiza informacion de Grabacion en proceso. """ self.toolbar_grabar.set_info(datos) def __detener_grabacion(self, widget=None): """ Detiene la Grabación en Proceso. """ if self.grabador != None: self.grabador.stop() self.toolbar_grabar.stop() def __set_volumen(self, widget, valor): """ Cuando el usuario cambia el volumen. """ valor = valor * 100 self.player.set_volumen(valor) def __get_volumen(self, widget, valor): """ El volumen con el que se reproduce actualmente. """ self.volumen.set_value(valor) def __set_video(self, widget, valor): """ Si hay video o no en la fuente . . . """ pass
class JAMediaFotografiaWidget(JAMediaVideoWidget): """ Plug - Interfaz para Webcam con cámara fotográfica. """ def __init__(self): JAMediaVideoWidget.__init__(self) def setup_init(self): """ Se crea la interfaz grafica, se setea y se empaqueta todo. """ from Widgets import ToolbarFotografia from Widgets import ToolbarRafagas # Widgets Base: - vbox - toolbars - panel basebox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.toolbar_salir = ToolbarSalir() self.toolbar = ToolbarFotografia() hpanel = Gtk.HPaned() basebox.pack_start(self.toolbar_salir, False, True, 0) basebox.pack_start(self.toolbar, False, True, 0) basebox.pack_start(hpanel, True, True, 0) self.add(basebox) # Panel lado Izquierdo: vbox - pantalla - hbox_efectos_aplicados vbox_izq_panel = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.pantalla = Visor() eventbox = Gtk.EventBox() eventbox.modify_bg(0, get_color("NEGRO")) self.hbox_efectos_en_pipe = Gtk.Box( orientation=Gtk.Orientation.HORIZONTAL) self.hbox_efectos_en_pipe.set_size_request(-1, get_pixels(0.5)) scroll = Gtk.ScrolledWindow() scroll.set_policy( Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER) scroll.add_with_viewport(eventbox) eventbox.add(self.hbox_efectos_en_pipe) vbox_izq_panel.pack_start(self.pantalla, True, True, 0) vbox_izq_panel.pack_start(scroll, False, False, 0) hpanel.pack1(vbox_izq_panel, resize=True, shrink=True) # Panel lado Derecho: eventbox - vbox - scroll # - balance_widget - widget_efectos self.box_config = Gtk.EventBox() self.box_config.set_size_request(get_pixels(5.0), -1) vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.balance_widget = ToolbarBalanceConfig() scroll = Gtk.ScrolledWindow() scroll.set_policy( Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) scroll.add_with_viewport(vbox) self.box_config.add(scroll) self.widget_efectos = WidgetsGstreamerEfectos() self.toolbar_rafagas = ToolbarRafagas() vbox.pack_start(self.balance_widget, False, True, 0) vbox.pack_start(self.toolbar_rafagas, False, True, 0) vbox.pack_start(self.widget_efectos, False, True, 0) hpanel.pack2(self.box_config, resize=False, shrink=False) self.show_all() self.realize() from gi.repository import GdkX11 xid = self.pantalla.get_property('window').get_xid() self.jamediawebcam = JAMediaWebCam(xid) self.controles_dinamicos = [ self.toolbar_salir, self.box_config, ] map(self.ocultar, self.controles_dinamicos) self.jamediawebcam.connect('estado', self.set_estado) self.pantalla.connect("button_press_event", self.clicks_en_pantalla) self.toolbar.connect("rotar", self.set_rotacion) self.toolbar.connect("accion", self.set_accion) self.toolbar.connect('salir', self.confirmar_salir) self.balance_widget.connect('valor', self.set_balance) self.widget_efectos.connect("click_efecto", self.click_efecto) self.widget_efectos.connect('configurar_efecto', self.configurar_efecto) self.toolbar_rafagas.connect('run_rafaga', self.set_rafaga) self.toolbar_salir.connect('salir', self.emit_salir) def set_rafaga(self, widget, valor): """ Cuando se hace click en play de la toolbar de ráfagas se setea y comienza a fotografiar. """ self.jamediawebcam.set_rafaga(valor) def set_accion(self, widget, senial): """ Cuando se hace click en fotografiar o en configurar filmacion. """ if senial == 'fotografiar': if self.jamediawebcam.estado != "Fotografiando": self.jamediawebcam.fotografiar() else: # Solo puede estar en estado Fotografiando # si hay ráfagas en proceso. self.jamediawebcam.stop_rafagas() elif senial == 'configurar': if self.box_config.get_visible(): self.box_config.hide() else: self.box_config.show() GLib.idle_add(self.update_balance_toolbars) elif senial == 'Reset': self.reset() def confirmar_salir(self, widget=None, senial=None): """ Recibe salir y lo pasa a la toolbar de confirmación. """ self.toolbar_salir.run("Menú Fotografía.")
class JAMediaVideoWidget(Gtk.Plug): """ Plug - Interfaz para Webcam con grabación de audio y video. """ __gsignals__ = { "salir": (GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, [])} def __init__(self): """ JAMediaVideoWidget: Gtk.Plug para embeber en otra aplicacion. """ Gtk.Plug.__init__(self, 0L) self.toolbar_salir = None self.toolbar = None self.pantalla = None self.balance_widget = None self.controles_dinamicos = [] self.jamediawebcam = None self.box_config = None self.widget_efectos = None self.hbox_efectos_en_pipe = None self.show_all() def setup_init(self): """ Se crea la interfaz grafica, se setea y se empaqueta todo. """ from Widgets import ToolbarVideo # Widgets Base: - vbox - toolbars - panel basebox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.toolbar_salir = ToolbarSalir() self.toolbar = ToolbarVideo() hpanel = Gtk.HPaned() basebox.pack_start(self.toolbar_salir, False, True, 0) basebox.pack_start(self.toolbar, False, True, 0) basebox.pack_start(hpanel, True, True, 0) self.add(basebox) # Panel lado Izquierdo: vbox - pantalla - hbox_efectos_aplicados vbox_izq_panel = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.pantalla = Visor() eventbox = Gtk.EventBox() eventbox.modify_bg(0, get_color("NEGRO")) self.hbox_efectos_en_pipe = Gtk.Box( orientation=Gtk.Orientation.HORIZONTAL) self.hbox_efectos_en_pipe.set_size_request(-1, get_pixels(0.5)) scroll = Gtk.ScrolledWindow() scroll.set_policy( Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER) scroll.add_with_viewport(eventbox) eventbox.add(self.hbox_efectos_en_pipe) vbox_izq_panel.pack_start(self.pantalla, True, True, 0) vbox_izq_panel.pack_start(scroll, False, False, 0) hpanel.pack1(vbox_izq_panel, resize=True, shrink=True) # Panel lado Derecho: eventbox - vbox - scroll # - balance_widget - widget_efectos self.box_config = Gtk.EventBox() self.box_config.set_size_request(get_pixels(5.0), -1) vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.balance_widget = ToolbarBalanceConfig() scroll = Gtk.ScrolledWindow() scroll.set_policy( Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) scroll.add_with_viewport(vbox) self.box_config.add(scroll) self.widget_efectos = WidgetsGstreamerEfectos() vbox.pack_start(self.balance_widget, False, True, 0) vbox.pack_start(self.widget_efectos, False, True, 0) hpanel.pack2(self.box_config, resize=False, shrink=False) self.show_all() self.realize() from gi.repository import GdkX11 xid = self.pantalla.get_property('window').get_xid() self.jamediawebcam = JAMediaWebCam(xid) self.controles_dinamicos = [ self.toolbar_salir, self.box_config, ] map(self.ocultar, self.controles_dinamicos) self.jamediawebcam.connect('estado', self.set_estado) self.pantalla.connect("button_press_event", self.clicks_en_pantalla) self.toolbar.connect("rotar", self.set_rotacion) self.toolbar.connect("accion", self.set_accion) self.toolbar.connect('salir', self.confirmar_salir) self.balance_widget.connect('valor', self.set_balance) self.widget_efectos.connect("click_efecto", self.click_efecto) self.widget_efectos.connect('configurar_efecto', self.configurar_efecto) self.toolbar_salir.connect('salir', self.emit_salir) def reset(self): """ Resetea la cámara quitando los efectos y actualiza los widgets correspondientes. """ for efecto in self.hbox_efectos_en_pipe.get_children(): efecto.destroy() for button in self.widget_efectos.gstreamer_efectos.get_children(): button.des_seleccionar() self.jamediawebcam.reset() def set_estado(self, widget, valor): if valor == 'playing': self.toolbar.set_estado("detenido") GLib.idle_add(self.update_balance_toolbars) elif valor == 'stoped': self.toolbar.set_estado("detenido") GLib.idle_add(self.update_balance_toolbars) elif valor == 'GrabandoAudioVideo': self.toolbar.set_estado("grabando") GLib.idle_add(self.update_balance_toolbars) # FIXME: Solo por JAMediaAudio - JAMediaAudioWidget. por ahora elif valor == 'GrabandoAudio': self.toolbar.set_estado("grabando") GLib.idle_add(self.update_balance_toolbars) # FIXME: Para JAMediaFotografiaWidget. Pero por ahora no se utiliza elif valor == 'Fotografiando': self.toolbar.set_estado("grabando") GLib.idle_add(self.update_balance_toolbars) else: print "### Estado:", valor def cargar_efectos(self, efectos): """ Agrega los widgets con efectos a la paleta de configuración. """ self.widget_efectos.cargar_efectos(efectos) def configurar_efecto(self, widget, nombre_efecto, propiedad, valor): """ Configura un efecto en el pipe, si no está en eĺ, lo agrega. """ # Si el efecto no está agregado al pipe, lo agrega if self.jamediawebcam.efectos: if not nombre_efecto in self.jamediawebcam.efectos: # HACK: si se agregan o quitan efectos mientras se graba, # las grabaciones se reinician. if self.jamediawebcam.estado == "GrabandoAudioVideo" or \ self.jamediawebcam.estado == "GrabandoAudio": return self.click_efecto(None, nombre_efecto) self.widget_efectos.seleccionar_efecto(nombre_efecto) else: # HACK: si se agregan o quitan efectos mientras se graba, # las grabaciones se reinician. if self.jamediawebcam.estado == "GrabandoAudioVideo" or \ self.jamediawebcam.estado == "GrabandoAudio": return self.click_efecto(None, nombre_efecto) self.widget_efectos.seleccionar_efecto(nombre_efecto) # Setea el efecto self.jamediawebcam.configurar_efecto(nombre_efecto, propiedad, valor) def click_efecto(self, widget, nombre_efecto): """ Recibe el nombre del efecto sobre el que se ha hecho click y decide si debe agregarse al pipe de JAMediaWebcam. """ # HACK: si se agregan o quitan efectos mientras se graba, # las grabaciones se reinician. if self.jamediawebcam.estado == "GrabandoAudioVideo" or \ self.jamediawebcam.estado == "GrabandoAudio": for efecto in self.hbox_efectos_en_pipe.get_children(): n_efecto = efecto.get_tooltip_text() if n_efecto == nombre_efecto: self.widget_efectos.seleccionar_efecto(nombre_efecto) return self.widget_efectos.des_seleccionar_efecto(nombre_efecto) return agregar = False if self.jamediawebcam.efectos: if not nombre_efecto in self.jamediawebcam.efectos: # Si el efecto no está en el pipe. agregar = True else: # Si no se han agregado efectos. agregar = True if agregar: #if self.jamediawebcam.estado == "GrabandoAudioVideo": # self.jamediawebcam.re_init() # pass from Widgets import WidgetEfecto_en_Pipe self.jamediawebcam.agregar_efecto(nombre_efecto) # Agrega un widget a self.hbox_efectos_en_pipe botonefecto = WidgetEfecto_en_Pipe() botonefecto.set_tooltip(nombre_efecto) botonefecto.connect('clicked', self.clicked_mini_efecto) lado = get_pixels(0.5) botonefecto.set_tamanio(lado, lado) archivo = os.path.join(JAMediaObjectsPath, "Iconos", 'configurar.svg') pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size( archivo, lado, lado) botonefecto.imagen.set_from_pixbuf(pixbuf) self.hbox_efectos_en_pipe.pack_start( botonefecto, False, False, 0) else: # Si el usuario hace click sobre el botón de un efecto # que ya se encuentra en el pipe de la camara, se quita # el efecto del pipe y se deselecciona el botón correspondiente. #if self.jamediawebcam.estado == "GrabandoAudioVideo": # self.jamediawebcam.re_init() # pass self.jamediawebcam.quitar_efecto(nombre_efecto) self.widget_efectos.des_seleccionar_efecto(nombre_efecto) # Quitar el widget de self.hbox_efectos_en_pipe for efecto in self.hbox_efectos_en_pipe.get_children(): if efecto.get_tooltip_text() == nombre_efecto: efecto.destroy() break def clicked_mini_efecto(self, widget, void=None): """ Cuando se hace click en el mini objeto en pantalla para efecto agregado, este se quita del pipe de la cámara. """ # HACK: si se agregan o quitan efectos mientras se graba, # las grabaciones se reinician. if self.jamediawebcam.estado == "GrabandoAudioVideo" or \ self.jamediawebcam.estado == "GrabandoAudio": return nombre_efecto = widget.get_tooltip_text() self.jamediawebcam.quitar_efecto(nombre_efecto) self.widget_efectos.des_seleccionar_efecto(nombre_efecto) widget.destroy() def update_balance_toolbars(self): """ Actualiza las toolbars de balance en video. """ config = self.jamediawebcam.get_balance() self.balance_widget.set_balance( brillo=config['brillo'], contraste=config['contraste'], saturacion=config['saturacion'], hue=config['hue'], gamma=config['gamma']) def set_balance(self, widget, valor, tipo): """ Setea valores en Balance de Video. valor es % float """ if tipo == "saturacion": self.jamediawebcam.set_balance(saturacion=valor) elif tipo == "contraste": self.jamediawebcam.set_balance(contraste=valor) elif tipo == "brillo": self.jamediawebcam.set_balance(brillo=valor) elif tipo == "hue": self.jamediawebcam.set_balance(hue=valor) elif tipo == "gamma": self.jamediawebcam.set_balance(gamma=valor) def set_rotacion(self, widget, valor): """ Recibe rotación y la pasa a la webcam. """ self.jamediawebcam.rotar(valor) def set_accion(self, widget, senial): """ Cuando se hace click en filmar o en configurar filmacion. """ if senial == 'filmar': if self.jamediawebcam.estado != "GrabandoAudioVideo": self.jamediawebcam.grabar() else: self.jamediawebcam.stop_grabar() elif senial == 'configurar': if self.box_config.get_visible(): self.box_config.hide() else: self.box_config.show() GLib.idle_add(self.update_balance_toolbars) elif senial == 'Reset': self.reset() def play(self): """ Comienza a correr la aplicación. """ GLib.idle_add(self.jamediawebcam.reset) def ocultar(self, objeto): if objeto.get_visible(): objeto.hide() def mostrar(self, objeto): if not objeto.get_visible(): objeto.show() def clicks_en_pantalla(self, widget, event): """ Hace fullscreen y unfullscreen sobre la ventana principal cuando el usuario hace doble click en el visor. """ if event.type.value_name == "GDK_2BUTTON_PRESS": ventana = self.get_toplevel() screen = ventana.get_screen() w, h = ventana.get_size() ww, hh = (screen.get_width(), screen.get_height()) if ww == w and hh == h: ventana.unfullscreen() else: ventana.fullscreen() def confirmar_salir(self, widget=None, senial=None): """ Recibe salir y lo pasa a la toolbar de confirmación. """ self.toolbar_salir.run("Menú Video.") def emit_salir(self, widget): """ Emite salir para que cuando esta embebida, la aplicacion decida que hacer, si salir, o cerrar solo la aplicacion embebida. """ self.reset() self.jamediawebcam.stop() # FIXME: emitir la señal directamente se ve mejor, # pero aveces falla la cámara, la segunda opcion # evita esto, pero no se ve bien. GLib.idle_add(self.emit, 'salir') # self.emit('salir')
class JAMediaAudioWidget(JAMediaVideoWidget): """ Plug - Interfaz para Webcam con grabación de audio. """ def __init__(self): """ JAMediaAudioWidget: Gtk.Plug para embeber en otra aplicacion. """ JAMediaVideoWidget.__init__(self) self.toolbar_salir = None self.toolbar = None self.pantalla = None self.balance_widget = None self.controles_dinamicos = [] self.jamediawebcam = None self.box_config = None self.widget_efectos = None self.widget_visualizadores_de_audio = None self.hbox_efectos_en_pipe = None self.show_all() def setup_init(self): """ Se crea la interfaz grafica, se setea y se empaqueta todo. """ from JAMediaObjects.JAMediaWidgets import WidgetsGstreamerAudioVisualizador from JAMediaObjects.JAMediaGstreamer.JAMediaAudio import JAMediaAudio from Widgets import ToolbarGrabarAudio # Widgets Base: - vbox - toolbars - panel basebox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.toolbar_salir = ToolbarSalir() self.toolbar = ToolbarGrabarAudio() hpanel = Gtk.HPaned() basebox.pack_start(self.toolbar_salir, False, True, 0) basebox.pack_start(self.toolbar, False, True, 0) basebox.pack_start(hpanel, True, True, 0) self.add(basebox) # Panel lado Izquierdo: vbox - pantalla - hbox_efectos_aplicados vbox_izq_panel = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.pantalla = Visor() eventbox = Gtk.EventBox() eventbox.modify_bg(0, get_color("NEGRO")) self.hbox_efectos_en_pipe = Gtk.Box( orientation=Gtk.Orientation.HORIZONTAL) self.hbox_efectos_en_pipe.set_size_request(-1, get_pixels(0.5)) scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER) scroll.add_with_viewport(eventbox) eventbox.add(self.hbox_efectos_en_pipe) vbox_izq_panel.pack_start(self.pantalla, True, True, 0) vbox_izq_panel.pack_start(scroll, False, False, 0) hpanel.pack1(vbox_izq_panel, resize=True, shrink=True) # Panel lado Derecho: eventbox - vbox - scroll # - balance_widget - widget_efectos self.box_config = Gtk.EventBox() self.box_config.set_size_request(get_pixels(5.0), -1) vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.widget_visualizadores_de_audio = WidgetsGstreamerAudioVisualizador( ) scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER) scroll.add_with_viewport(self.widget_visualizadores_de_audio) self.balance_widget = ToolbarBalanceConfig() vbox.pack_start(self.balance_widget, False, True, 0) vbox.pack_start(scroll, False, True, 0) scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) scroll.add_with_viewport(vbox) self.box_config.add(scroll) self.widget_efectos = WidgetsGstreamerEfectos() vbox.pack_start(self.widget_efectos, False, True, 0) hpanel.pack2(self.box_config, resize=False, shrink=False) self.show_all() self.realize() from gi.repository import GdkX11 xid = self.pantalla.get_property('window').get_xid() self.jamediawebcam = JAMediaAudio(xid) self.controles_dinamicos = [ self.toolbar_salir, self.box_config, ] map(self.ocultar, self.controles_dinamicos) self.jamediawebcam.connect('estado', self.set_estado) self.pantalla.connect("button_press_event", self.clicks_en_pantalla) self.toolbar.connect("rotar", self.set_rotacion) self.toolbar.connect("accion", self.set_accion) self.toolbar.connect('salir', self.confirmar_salir) self.balance_widget.connect('valor', self.set_balance) self.widget_efectos.connect("click_efecto", self.click_efecto) self.widget_efectos.connect('configurar_efecto', self.configurar_efecto) self.widget_visualizadores_de_audio.connect("click_efecto", self.click_visualizador) #self.widget_visualizadores_de_audio.connect( # 'configurar_efecto', self.configurar_visualizador) self.toolbar_salir.connect('salir', self.emit_salir) def set_accion(self, widget, senial): """ Cuando se hace click en grabar o en configurar. """ if senial == 'grabar': if self.jamediawebcam.estado != "GrabandoAudio": self.jamediawebcam.grabar() else: self.jamediawebcam.stop_grabar() elif senial == 'configurar': if self.box_config.get_visible(): self.box_config.hide() else: self.box_config.show() GLib.idle_add(self.update_balance_toolbars) elif senial == 'Reset': self.reset() def cargar_visualizadores(self, efectos): """ Agrega los widgets con efectos a la paleta de configuración. """ self.widget_visualizadores_de_audio.cargar_efectos(efectos) #def configurar_visualizador(self, widget, nombre_efecto, propiedad, valor): # """Configura un efecto en el pipe, si no está en eĺ, lo agrega.""" # self.jamediawebcam.configurar_visualizador(nombre_efecto, propiedad, valor) def click_visualizador(self, widget, nombre_efecto): if self.jamediawebcam.estado != "GrabandoAudio": self.jamediawebcam.set_visualizador(nombre_efecto) # FIXME: Agregar seleccionar visualizador actual def confirmar_salir(self, widget=None, senial=None): """ Recibe salir y lo pasa a la toolbar de confirmación. """ self.toolbar_salir.run("Menú Audio.")
class JAMediaVideoWidget(Gtk.Plug): """ Plug - Interfaz para Webcam con grabación de audio y video. """ __gsignals__ = {"salir": (GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, [])} def __init__(self): """ JAMediaVideoWidget: Gtk.Plug para embeber en otra aplicacion. """ Gtk.Plug.__init__(self, 0L) self.toolbar_salir = None self.toolbar = None self.pantalla = None self.balance_widget = None self.controles_dinamicos = [] self.jamediawebcam = None self.box_config = None self.widget_efectos = None self.hbox_efectos_en_pipe = None self.show_all() def setup_init(self): """ Se crea la interfaz grafica, se setea y se empaqueta todo. """ from Widgets import ToolbarVideo # Widgets Base: - vbox - toolbars - panel basebox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.toolbar_salir = ToolbarSalir() self.toolbar = ToolbarVideo() hpanel = Gtk.HPaned() basebox.pack_start(self.toolbar_salir, False, True, 0) basebox.pack_start(self.toolbar, False, True, 0) basebox.pack_start(hpanel, True, True, 0) self.add(basebox) # Panel lado Izquierdo: vbox - pantalla - hbox_efectos_aplicados vbox_izq_panel = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.pantalla = Visor() eventbox = Gtk.EventBox() eventbox.modify_bg(0, get_color("NEGRO")) self.hbox_efectos_en_pipe = Gtk.Box( orientation=Gtk.Orientation.HORIZONTAL) self.hbox_efectos_en_pipe.set_size_request(-1, get_pixels(0.5)) scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER) scroll.add_with_viewport(eventbox) eventbox.add(self.hbox_efectos_en_pipe) vbox_izq_panel.pack_start(self.pantalla, True, True, 0) vbox_izq_panel.pack_start(scroll, False, False, 0) hpanel.pack1(vbox_izq_panel, resize=True, shrink=True) # Panel lado Derecho: eventbox - vbox - scroll # - balance_widget - widget_efectos self.box_config = Gtk.EventBox() self.box_config.set_size_request(get_pixels(5.0), -1) vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.balance_widget = ToolbarBalanceConfig() scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) scroll.add_with_viewport(vbox) self.box_config.add(scroll) self.widget_efectos = WidgetsGstreamerEfectos() vbox.pack_start(self.balance_widget, False, True, 0) vbox.pack_start(self.widget_efectos, False, True, 0) hpanel.pack2(self.box_config, resize=False, shrink=False) self.show_all() self.realize() from gi.repository import GdkX11 xid = self.pantalla.get_property('window').get_xid() self.jamediawebcam = JAMediaWebCam(xid) self.controles_dinamicos = [ self.toolbar_salir, self.box_config, ] map(self.ocultar, self.controles_dinamicos) self.jamediawebcam.connect('estado', self.set_estado) self.pantalla.connect("button_press_event", self.clicks_en_pantalla) self.toolbar.connect("rotar", self.set_rotacion) self.toolbar.connect("accion", self.set_accion) self.toolbar.connect('salir', self.confirmar_salir) self.balance_widget.connect('valor', self.set_balance) self.widget_efectos.connect("click_efecto", self.click_efecto) self.widget_efectos.connect('configurar_efecto', self.configurar_efecto) self.toolbar_salir.connect('salir', self.emit_salir) def reset(self): """ Resetea la cámara quitando los efectos y actualiza los widgets correspondientes. """ for efecto in self.hbox_efectos_en_pipe.get_children(): efecto.destroy() for button in self.widget_efectos.gstreamer_efectos.get_children(): button.des_seleccionar() self.jamediawebcam.reset() def set_estado(self, widget, valor): if valor == 'playing': self.toolbar.set_estado("detenido") GLib.idle_add(self.update_balance_toolbars) elif valor == 'stoped': self.toolbar.set_estado("detenido") GLib.idle_add(self.update_balance_toolbars) elif valor == 'GrabandoAudioVideo': self.toolbar.set_estado("grabando") GLib.idle_add(self.update_balance_toolbars) # FIXME: Solo por JAMediaAudio - JAMediaAudioWidget. por ahora elif valor == 'GrabandoAudio': self.toolbar.set_estado("grabando") GLib.idle_add(self.update_balance_toolbars) # FIXME: Para JAMediaFotografiaWidget. Pero por ahora no se utiliza elif valor == 'Fotografiando': self.toolbar.set_estado("grabando") GLib.idle_add(self.update_balance_toolbars) else: print "### Estado:", valor def cargar_efectos(self, efectos): """ Agrega los widgets con efectos a la paleta de configuración. """ self.widget_efectos.cargar_efectos(efectos) def configurar_efecto(self, widget, nombre_efecto, propiedad, valor): """ Configura un efecto en el pipe, si no está en eĺ, lo agrega. """ # Si el efecto no está agregado al pipe, lo agrega if self.jamediawebcam.efectos: if not nombre_efecto in self.jamediawebcam.efectos: # HACK: si se agregan o quitan efectos mientras se graba, # las grabaciones se reinician. if self.jamediawebcam.estado == "GrabandoAudioVideo" or \ self.jamediawebcam.estado == "GrabandoAudio": return self.click_efecto(None, nombre_efecto) self.widget_efectos.seleccionar_efecto(nombre_efecto) else: # HACK: si se agregan o quitan efectos mientras se graba, # las grabaciones se reinician. if self.jamediawebcam.estado == "GrabandoAudioVideo" or \ self.jamediawebcam.estado == "GrabandoAudio": return self.click_efecto(None, nombre_efecto) self.widget_efectos.seleccionar_efecto(nombre_efecto) # Setea el efecto self.jamediawebcam.configurar_efecto(nombre_efecto, propiedad, valor) def click_efecto(self, widget, nombre_efecto): """ Recibe el nombre del efecto sobre el que se ha hecho click y decide si debe agregarse al pipe de JAMediaWebcam. """ # HACK: si se agregan o quitan efectos mientras se graba, # las grabaciones se reinician. if self.jamediawebcam.estado == "GrabandoAudioVideo" or \ self.jamediawebcam.estado == "GrabandoAudio": for efecto in self.hbox_efectos_en_pipe.get_children(): n_efecto = efecto.get_tooltip_text() if n_efecto == nombre_efecto: self.widget_efectos.seleccionar_efecto(nombre_efecto) return self.widget_efectos.des_seleccionar_efecto(nombre_efecto) return agregar = False if self.jamediawebcam.efectos: if not nombre_efecto in self.jamediawebcam.efectos: # Si el efecto no está en el pipe. agregar = True else: # Si no se han agregado efectos. agregar = True if agregar: #if self.jamediawebcam.estado == "GrabandoAudioVideo": # self.jamediawebcam.re_init() # pass from Widgets import WidgetEfecto_en_Pipe self.jamediawebcam.agregar_efecto(nombre_efecto) # Agrega un widget a self.hbox_efectos_en_pipe botonefecto = WidgetEfecto_en_Pipe() botonefecto.set_tooltip(nombre_efecto) botonefecto.connect('clicked', self.clicked_mini_efecto) lado = get_pixels(0.5) botonefecto.set_tamanio(lado, lado) archivo = os.path.join(JAMediaObjectsPath, "Iconos", 'configurar.svg') pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size( archivo, lado, lado) botonefecto.imagen.set_from_pixbuf(pixbuf) self.hbox_efectos_en_pipe.pack_start(botonefecto, False, False, 0) else: # Si el usuario hace click sobre el botón de un efecto # que ya se encuentra en el pipe de la camara, se quita # el efecto del pipe y se deselecciona el botón correspondiente. #if self.jamediawebcam.estado == "GrabandoAudioVideo": # self.jamediawebcam.re_init() # pass self.jamediawebcam.quitar_efecto(nombre_efecto) self.widget_efectos.des_seleccionar_efecto(nombre_efecto) # Quitar el widget de self.hbox_efectos_en_pipe for efecto in self.hbox_efectos_en_pipe.get_children(): if efecto.get_tooltip_text() == nombre_efecto: efecto.destroy() break def clicked_mini_efecto(self, widget, void=None): """ Cuando se hace click en el mini objeto en pantalla para efecto agregado, este se quita del pipe de la cámara. """ # HACK: si se agregan o quitan efectos mientras se graba, # las grabaciones se reinician. if self.jamediawebcam.estado == "GrabandoAudioVideo" or \ self.jamediawebcam.estado == "GrabandoAudio": return nombre_efecto = widget.get_tooltip_text() self.jamediawebcam.quitar_efecto(nombre_efecto) self.widget_efectos.des_seleccionar_efecto(nombre_efecto) widget.destroy() def update_balance_toolbars(self): """ Actualiza las toolbars de balance en video. """ config = self.jamediawebcam.get_balance() self.balance_widget.set_balance(brillo=config['brillo'], contraste=config['contraste'], saturacion=config['saturacion'], hue=config['hue'], gamma=config['gamma']) def set_balance(self, widget, valor, tipo): """ Setea valores en Balance de Video. valor es % float """ if tipo == "saturacion": self.jamediawebcam.set_balance(saturacion=valor) elif tipo == "contraste": self.jamediawebcam.set_balance(contraste=valor) elif tipo == "brillo": self.jamediawebcam.set_balance(brillo=valor) elif tipo == "hue": self.jamediawebcam.set_balance(hue=valor) elif tipo == "gamma": self.jamediawebcam.set_balance(gamma=valor) def set_rotacion(self, widget, valor): """ Recibe rotación y la pasa a la webcam. """ self.jamediawebcam.rotar(valor) def set_accion(self, widget, senial): """ Cuando se hace click en filmar o en configurar filmacion. """ if senial == 'filmar': if self.jamediawebcam.estado != "GrabandoAudioVideo": self.jamediawebcam.grabar() else: self.jamediawebcam.stop_grabar() elif senial == 'configurar': if self.box_config.get_visible(): self.box_config.hide() else: self.box_config.show() GLib.idle_add(self.update_balance_toolbars) elif senial == 'Reset': self.reset() def play(self): """ Comienza a correr la aplicación. """ GLib.idle_add(self.jamediawebcam.reset) def ocultar(self, objeto): if objeto.get_visible(): objeto.hide() def mostrar(self, objeto): if not objeto.get_visible(): objeto.show() def clicks_en_pantalla(self, widget, event): """ Hace fullscreen y unfullscreen sobre la ventana principal cuando el usuario hace doble click en el visor. """ if event.type.value_name == "GDK_2BUTTON_PRESS": ventana = self.get_toplevel() screen = ventana.get_screen() w, h = ventana.get_size() ww, hh = (screen.get_width(), screen.get_height()) if ww == w and hh == h: ventana.unfullscreen() else: ventana.fullscreen() def confirmar_salir(self, widget=None, senial=None): """ Recibe salir y lo pasa a la toolbar de confirmación. """ self.toolbar_salir.run("Menú Video.") def emit_salir(self, widget): """ Emite salir para que cuando esta embebida, la aplicacion decida que hacer, si salir, o cerrar solo la aplicacion embebida. """ self.reset() self.jamediawebcam.stop() # FIXME: emitir la señal directamente se ve mejor, # pero aveces falla la cámara, la segunda opcion # evita esto, pero no se ve bien. GLib.idle_add(self.emit, 'salir') # self.emit('salir')
class JAMediaFotografiaWidget(JAMediaVideoWidget): """ Plug - Interfaz para Webcam con cámara fotográfica. """ def __init__(self): JAMediaVideoWidget.__init__(self) def setup_init(self): """ Se crea la interfaz grafica, se setea y se empaqueta todo. """ from Widgets import ToolbarFotografia from Widgets import ToolbarRafagas # Widgets Base: - vbox - toolbars - panel basebox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.toolbar_salir = ToolbarSalir() self.toolbar = ToolbarFotografia() hpanel = Gtk.HPaned() basebox.pack_start(self.toolbar_salir, False, True, 0) basebox.pack_start(self.toolbar, False, True, 0) basebox.pack_start(hpanel, True, True, 0) self.add(basebox) # Panel lado Izquierdo: vbox - pantalla - hbox_efectos_aplicados vbox_izq_panel = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.pantalla = Visor() eventbox = Gtk.EventBox() eventbox.modify_bg(0, get_color("NEGRO")) self.hbox_efectos_en_pipe = Gtk.Box( orientation=Gtk.Orientation.HORIZONTAL) self.hbox_efectos_en_pipe.set_size_request(-1, get_pixels(0.5)) scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER) scroll.add_with_viewport(eventbox) eventbox.add(self.hbox_efectos_en_pipe) vbox_izq_panel.pack_start(self.pantalla, True, True, 0) vbox_izq_panel.pack_start(scroll, False, False, 0) hpanel.pack1(vbox_izq_panel, resize=True, shrink=True) # Panel lado Derecho: eventbox - vbox - scroll # - balance_widget - widget_efectos self.box_config = Gtk.EventBox() self.box_config.set_size_request(get_pixels(5.0), -1) vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.balance_widget = ToolbarBalanceConfig() scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) scroll.add_with_viewport(vbox) self.box_config.add(scroll) self.widget_efectos = WidgetsGstreamerEfectos() self.toolbar_rafagas = ToolbarRafagas() vbox.pack_start(self.balance_widget, False, True, 0) vbox.pack_start(self.toolbar_rafagas, False, True, 0) vbox.pack_start(self.widget_efectos, False, True, 0) hpanel.pack2(self.box_config, resize=False, shrink=False) self.show_all() self.realize() from gi.repository import GdkX11 xid = self.pantalla.get_property('window').get_xid() self.jamediawebcam = JAMediaWebCam(xid) self.controles_dinamicos = [ self.toolbar_salir, self.box_config, ] map(self.ocultar, self.controles_dinamicos) self.jamediawebcam.connect('estado', self.set_estado) self.pantalla.connect("button_press_event", self.clicks_en_pantalla) self.toolbar.connect("rotar", self.set_rotacion) self.toolbar.connect("accion", self.set_accion) self.toolbar.connect('salir', self.confirmar_salir) self.balance_widget.connect('valor', self.set_balance) self.widget_efectos.connect("click_efecto", self.click_efecto) self.widget_efectos.connect('configurar_efecto', self.configurar_efecto) self.toolbar_rafagas.connect('run_rafaga', self.set_rafaga) self.toolbar_salir.connect('salir', self.emit_salir) def set_rafaga(self, widget, valor): """ Cuando se hace click en play de la toolbar de ráfagas se setea y comienza a fotografiar. """ self.jamediawebcam.set_rafaga(valor) def set_accion(self, widget, senial): """ Cuando se hace click en fotografiar o en configurar filmacion. """ if senial == 'fotografiar': if self.jamediawebcam.estado != "Fotografiando": self.jamediawebcam.fotografiar() else: # Solo puede estar en estado Fotografiando # si hay ráfagas en proceso. self.jamediawebcam.stop_rafagas() elif senial == 'configurar': if self.box_config.get_visible(): self.box_config.hide() else: self.box_config.show() GLib.idle_add(self.update_balance_toolbars) elif senial == 'Reset': self.reset() def confirmar_salir(self, widget=None, senial=None): """ Recibe salir y lo pasa a la toolbar de confirmación. """ self.toolbar_salir.run("Menú Fotografía.")