def __init__(self):

        Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL)

        self.toolbar = Toolbar()
        self.pack_start(self.toolbar, False, False, 0)

        self.basebox = BaseBox()
        self.pack_start(self.basebox, True, True, 0)

        self.informewidget = False

        # FIXME: Activar para obtener informe de módulos
        #self.connect("realize", self.__realize)
        self.show_all()

        self.toolbar.connect("import", self.__import)
        self.toolbar.connect("accion-menu", self.__set_accion)
        self.toolbar.connect("salir", self.__emit_salir)
        self.toolbar.connect("zoom", self.__zoom)
        self.toolbar.connect("accion", self.__buscar_mas)
        self.toolbar.connect("informe", self.__informar)

        self.basebox.connect("update", self.__update)
        self.basebox.connect('abrir', self.__open_file)
        self.basebox.connect("nobusquedas", self.__desactivar_busquedas)
Exemple #2
0
    def __init__(self, escenario):

        GObject.GObject.__init__(self)

        self.override_background_color(Gtk.StateType.NORMAL,
                                       color_parser("#ffffff"))

        self.lecciones = []

        self.toolbar = Toolbar()
        vbox = Gtk.VBox()
        vbox.pack_start(self.toolbar, False, False, 0)
        vbox.pack_start(escenario, True, True, 0)
        self.toolbarestado = ToolbarEstado()
        vbox.pack_end(self.toolbarestado, False, False, 0)

        self.pack1(vbox, resize=True, shrink=True)
        self.derecha = Derecha()
        self.pack2(self.derecha, resize=False, shrink=False)

        self.toolbarestado.connect("volumen", self.__volumen_changed)
        self.derecha.connect("select", self.__set_cursor)
        self.derecha.connect("lectura", self.__run_lectura)

        self.show_all()

        self.agua_cursor = False
        self.alimento_cursor = False
        self.cursor_root = False
        self.cursor_tipo = False

        GLib.idle_add(self.__config_cursors)
Exemple #3
0
    def __init__(self, escenario):

        gtk.HPaned.__init__(self)

        self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#ffffff"))

        self.lecciones = []

        self.toolbar = Toolbar()
        vbox = gtk.VBox()
        vbox.pack_start(self.toolbar, False, False, 0)
        vbox.pack_start(escenario, True, True, 0)
        self.toolbarestado = ToolbarEstado()
        vbox.pack_end(self.toolbarestado, False, False, 0)

        self.pack1(vbox, resize=True, shrink=True)
        self.derecha = Derecha()
        self.pack2(self.derecha, resize=False, shrink=False)

        self.toolbarestado.connect("volumen", self.__volumen_changed)
        self.derecha.connect("select", self.__set_cursor)
        self.derecha.connect("lectura", self.__run_lectura)

        self.show_all()

        self.agua_cursor = False
        self.alimento_cursor = False
        self.cursor_root = False
        self.cursor_tipo = False

        gobject.idle_add(self.__config_cursors)
Exemple #4
0
    def __setup_init(self):
        """
        Crea y Empaqueta todo.
        """

        from Widgets import Toolbar
        from Widgets import Toolbar_Busqueda
        from Widgets import Toolbar_Descarga
        from Widgets import Alerta_Busqueda

        from PanelTube import PanelTube

        from Widgets import ToolbarSalir

        boxbase = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.box_tube = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)

        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

        GLib.idle_add(self.__setup_init2)
    def __init__(self):

        Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL)

        self.toolbar = Toolbar()
        self.pack_start(self.toolbar, False, False, 0)

        self.basebox = BaseBox()
        self.pack_start(self.basebox, True, True, 0)

        self.informewidget = False

        # FIXME: Activar para obtener informe de módulos
        #self.connect("realize", self.__realize)
        self.show_all()

        self.toolbar.connect("import", self.__import)
        self.toolbar.connect("accion-menu", self.__set_accion)
        self.toolbar.connect("salir", self.__emit_salir)
        self.toolbar.connect("zoom", self.__zoom)
        self.toolbar.connect("accion", self.__buscar_mas)
        self.toolbar.connect("informe", self.__informar)

        self.basebox.connect("update", self.__update)
        self.basebox.connect('abrir', self.__open_file)
        self.basebox.connect("nobusquedas", self.__desactivar_busquedas)
Exemple #6
0
    def __init__(self):

        Gtk.Window.__init__(self)

        self.set_size_request(640, 480)
        self.set_title('Reloj')
        
        self.speaker_active = False
        self.speaker = JAMediaSpeak()
        self.minutos = 0
        
        self.toolbar = Toolbar()
        self.reloj = Imagen_Reloj()
        self.hora = Gtk.Label("Time")
        self.fecha = Gtk.Label("Date")
        
        vbox = Gtk.VBox()
        vbox.pack_start(self.toolbar, False, False, 0)
        vbox.pack_start(self.reloj, True, True, 0)
        vbox.pack_start(self.hora, False, False, 0)
        vbox.pack_start(self.fecha, False, False, 0)

        self.add(vbox)
        self.show_all()
        
        self.reloj.connect("update", self.__update)
        self.toolbar.connect("accion", self.__set_accion)
        self.toolbar.connect("speak", self.__set_speak)
        self.connect("delete-event", self.__exit)
Exemple #7
0
    def __init__(self, escenario):

        GObject.GObject.__init__(self)

        self.override_background_color(Gtk.StateType.NORMAL, color_parser("#ffffff"))

        self.lecciones = []

        self.toolbar = Toolbar()
        vbox = Gtk.VBox()
        vbox.pack_start(self.toolbar, False, False, 0)
        vbox.pack_start(escenario, True, True, 0)
        self.toolbarestado = ToolbarEstado()
        vbox.pack_end(self.toolbarestado, False, False, 0)

        self.pack1(vbox, resize=True, shrink=True)
        self.derecha = Derecha()
        self.pack2(self.derecha, resize=False, shrink=False)

        self.toolbarestado.connect("volumen", self.__volumen_changed)
        self.derecha.connect("select", self.__set_cursor)
        self.derecha.connect("lectura", self.__run_lectura)

        self.show_all()

        self.agua_cursor = False
        self.alimento_cursor = False
        self.cursor_root = False
        self.cursor_tipo = False

        GLib.idle_add(self.__config_cursors)
    def __setup_init(self):
        """
        Crea y Empaqueta todo.
        """
        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()

        event = gtk.EventBox()
        event.modify_bg(0, get_colors("drawingplayer"))
        event.add(self.toolbar)
        self.box_tube.pack_start(event, False, False, 0)

        event = gtk.EventBox()
        event.modify_bg(0, get_colors("download"))
        event.add(self.toolbar_salir)
        self.box_tube.pack_start(event, False, False, 0)

        self.box_tube.pack_start(self.toolbar_busqueda, False, False, 0)

        event = gtk.EventBox()
        event.modify_bg(0, get_colors("download"))
        event.add(self.toolbar_descarga)
        self.box_tube.pack_start(event, False, False, 0)

        self.box_tube.pack_start(self.alerta_busqueda, False, False, 0)
        self.box_tube.pack_start(self.paneltube, True, True, 0)

        self.jamedia = JAMedia()

        boxbase.pack_start(self.box_tube, True, True, 0)
        boxbase.pack_start(self.jamedia, True, True, 0)
        self.add(boxbase)

        self.show_all()
        self.realize()

        self.paneltube.set_vista_inicial()  # oculta las toolbarsaccion

        gobject.idle_add(self.__setup_init2)
    def __init__(self):

        Gtk.EventBox.__init__(self)

        vbox = Gtk.VBox()

        self.toolbar = Toolbar()
        vbox.pack_start(self.toolbar, False, False, 0)

        self.base_panel = BasePanel()
        vbox.pack_start(self.base_panel, True, True, 0)

        self.add(vbox)
        self.show_all()

        self.toolbar.connect("import", self.__import)
        self.toolbar.connect("accion-menu", self.__set_accion)
        self.toolbar.connect("salir", self.__emit_salir)
        self.base_panel.connect("update", self.__update)
Exemple #10
0
    def __init__(self):

        super(Ventana, self).__init__()

        self.set_title("JAMedia Converter")

        self.set_icon_from_file(
            os.path.join(BASEPATH,
            "Iconos", "JAMediaConvert.svg"))

        self.set_resizable(True)
        self.set_size_request(640, 480)
        self.set_border_width(2)
        self.set_position(Gtk.WindowPosition.CENTER)
        self.modify_bg(0, get_colors("window"))

        vbox = Gtk.VBox()
        base_panel = Gtk.HPaned()
        base_panel.modify_bg(0, get_colors("window"))

        self.toolbar = Toolbar()
        self.lista = Lista()
        self.widgettareas = WidgetTareas()

        scroll = Gtk.ScrolledWindow()
        scroll.set_policy(
            Gtk.PolicyType.AUTOMATIC,
            Gtk.PolicyType.AUTOMATIC)
        scroll.add(self.lista)

        base_panel.pack1(scroll, resize=False, shrink=False)
        base_panel.pack2(self.widgettareas, resize=False, shrink=False)

        vbox.pack_start(
            self.toolbar, False, False, 0)
        vbox.pack_start(
            base_panel, True, True, 0)

        self.add(vbox)

        self.show_all()
        self.realize()

        self.toolbar.connect(
            'salir', self.__salir)
        self.toolbar.connect(
            'load', self.__load_files)
        self.lista.connect(
            "nueva-seleccion", self.__selecction_file)
        self.widgettareas.connect(
            'copy_tarea', self.__copy_tarea)

        self.connect("delete-event", self.__salir)
Exemple #11
0
class JAMediaPyGiHack(Gtk.EventBox):

    __gtype_name__ = 'JAMediaPyGiHack'

    __gsignals__ = {
    'salir': (GObject.SIGNAL_RUN_FIRST,
        GObject.TYPE_NONE, [])}

    def __init__(self):

        Gtk.EventBox.__init__(self)

        vbox = Gtk.VBox()

        self.toolbar = Toolbar()
        vbox.pack_start(self.toolbar, False, False, 0)

        self.base_panel = BasePanel()
        vbox.pack_start(self.base_panel, True, True, 0)

        self.add(vbox)
        self.show_all()

        self.toolbar.connect("import", self.__import)
        self.toolbar.connect("accion-menu", self.__set_accion)
        self.toolbar.connect("salir", self.__emit_salir)
        self.base_panel.connect("update", self.__update)

    def __emit_salir(self, widget):

        self.emit('salir')

    def __update(self, widget, view):

        if view == "Terminal":
            pass

        elif view == "Gstreamer - Inspect 1.0" or \
            view == "Apis PyGiHack":
            self.toolbar.update(view)

    def __set_accion(self, widget, menu, wid_lab, valor):

        self.base_panel.set_accion(menu, wid_lab, valor)

    def __import(self, widget, paquete, modulo):

        self.base_panel.import_modulo(paquete, modulo)
Exemple #12
0
    def __setup_init(self):
        """
        Crea y Empaqueta todo.
        """

        from Widgets import Toolbar
        from Widgets import Toolbar_Busqueda
        from Widgets import Toolbar_Descarga
        from Widgets import Alerta_Busqueda

        from PanelTube import PanelTube

        from Widgets import ToolbarSalir

        boxbase = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.box_tube = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)

        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

        GLib.idle_add(self.__setup_init2)
    def __setup_init(self):
        """
        Crea y Empaqueta todo.
        """
        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()

        event = gtk.EventBox()
        event.modify_bg(0, get_colors("drawingplayer"))
        event.add(self.toolbar)
        self.box_tube.pack_start(event, False, False, 0)

        event = gtk.EventBox()
        event.modify_bg(0, get_colors("download"))
        event.add(self.toolbar_salir)
        self.box_tube.pack_start(event, False, False, 0)

        self.box_tube.pack_start(self.toolbar_busqueda, False, False, 0)

        event = gtk.EventBox()
        event.modify_bg(0, get_colors("download"))
        event.add(self.toolbar_descarga)
        self.box_tube.pack_start(event, False, False, 0)

        self.box_tube.pack_start(self.alerta_busqueda, False, False, 0)
        self.box_tube.pack_start(self.paneltube, True, True, 0)

        self.jamedia = JAMedia()

        boxbase.pack_start(self.box_tube, True, True, 0)
        boxbase.pack_start(self.jamedia, True, True, 0)
        self.set_canvas(boxbase)

        self.show_all()
        self.realize()

        self.paneltube.set_vista_inicial()  # oculta las toolbarsaccion

        gobject.idle_add(self.__setup_init2)
Exemple #14
0
    def __init__(self):

        Gtk.EventBox.__init__(self)

        vbox = Gtk.VBox()

        self.toolbar = Toolbar()
        vbox.pack_start(self.toolbar, False, False, 0)

        self.base_panel = BasePanel()
        vbox.pack_start(self.base_panel, True, True, 0)

        self.add(vbox)
        self.show_all()

        self.toolbar.connect("import", self.__import)
        self.toolbar.connect("accion-menu", self.__set_accion)
        self.toolbar.connect("salir", self.__emit_salir)
        self.base_panel.connect("update", self.__update)
class JAMediaPyGiHack(Gtk.EventBox):

    __gtype_name__ = 'JAMediaPyGiHack'

    __gsignals__ = {'salir': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, [])}

    def __init__(self):

        Gtk.EventBox.__init__(self)

        vbox = Gtk.VBox()

        self.toolbar = Toolbar()
        vbox.pack_start(self.toolbar, False, False, 0)

        self.base_panel = BasePanel()
        vbox.pack_start(self.base_panel, True, True, 0)

        self.add(vbox)
        self.show_all()

        self.toolbar.connect("import", self.__import)
        self.toolbar.connect("accion-menu", self.__set_accion)
        self.toolbar.connect("salir", self.__emit_salir)
        self.base_panel.connect("update", self.__update)

    def __emit_salir(self, widget):
        self.emit('salir')

    def __update(self, widget, view):
        if view == "Terminal":
            pass
        elif view == "Gstreamer - Inspect 1.0" or view == "Apis PyGiHack":
            self.toolbar.update(view)

    def __set_accion(self, widget, menu, wid_lab, valor):
        self.base_panel.set_accion(menu, wid_lab, valor)

    def __import(self, widget, paquete, modulo):
        self.base_panel.import_modulo(paquete, modulo)
    def crear_barra(self):

        self.toolbar = Toolbar()
        self.combo_borrar = self.toolbar.combo_borrar

        self.toolbar.connect('save', self.guardar_archivo)
        self.toolbar.connect('new-variable', self.crear_variable)
        self.toolbar.connect('new-variable', self.actualizar_widgets)
        self.toolbar.connect('new-column', self.aniadir_a_variable)
        self.toolbar.connect('settings-dialog', self.dialogo_configuraciones)
        self.toolbar.connect('change-plot', self.cambiar_tipo)
        self.toolbar.connect('remove-column', self.borrar_columna)
        self.toolbar.connect('remove-column', self.actualizar_widgets)
        self.toolbar.connect('help-request', self.dialogo_ayuda)

        for x in range(0, len(self.toolbar.lista)):
            if self.grafica.endswith(self.toolbar.lista[x]):
                self.combo_borrar.set_active(x)
                self.combo_borrar.emit('changed')
                break

        self.set_titlebar(self.toolbar)
Exemple #17
0
    def __setup_init(self):
        """
        Genera y empaqueta toda la interfaz.
        """

        from Widgets import Visor
        from Widgets import ToolbarSalir
        from Widgets import Toolbar
        from Widgets import ToolbarPrincipal
        #from JAMediaVideoAplicaciones import JAMediaVideoWidget
        #from JAMediaVideoAplicaciones import JAMediaFotografiaWidget
        #from JAMediaVideoAplicaciones import JAMediaAudioWidget

        #from JAMedia.JAMedia import JAMediaPlayer
        #from JAMImagenes2.JAMImagenes import JAMImagenes

        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.add(vbox)
        self.show_all()

        self.toolbar = Toolbar()
        self.toolbar_salir = ToolbarSalir()
        self.toolbarprincipal = ToolbarPrincipal()

        #self.socketjamediavideo = Gtk.Socket()
        #self.socketjamediafotografia = Gtk.Socket()
        #self.socketjamediaaudio = Gtk.Socket()
        #self.socketjamedia = Gtk.Socket()
        #self.socketjamimagenes = Gtk.Socket()

        self.pantalla = Visor()

        vbox.pack_start(self.toolbar, False, True, 0)
        vbox.pack_start(self.toolbar_salir, False, True, 0)
        vbox.pack_start(self.toolbarprincipal, False, True, 0)

        #vbox.pack_start(self.socketjamediavideo, True, True, 0)
        #vbox.pack_start(self.socketjamediafotografia, True, True, 0)
        #vbox.pack_start(self.socketjamediaaudio, True, True, 0)
        #vbox.pack_start(self.socketjamedia, True, True, 0)
        #vbox.pack_start(self.socketjamimagenes, True, True, 0)

        vbox.pack_start(self.pantalla, True, True, 0)

        #self.jamediavideo = JAMediaVideoWidget()
        #self.socketjamediavideo.add_id(self.jamediavideo.get_id())

        #self.jamediafotografia = JAMediaFotografiaWidget()
        #self.socketjamediafotografia.add_id(self.jamediafotografia.get_id())

        #self.jamediaaudio = JAMediaAudioWidget()
        #self.socketjamediaaudio.add_id(self.jamediaaudio.get_id())

        #self.jamediaplayer = JAMediaPlayer()
        #self.socketjamedia.add_id(self.jamediaplayer.get_id())

        #self.jamimagenes = JAMImagenes()
        #self.socketjamimagenes.add_id(self.jamimagenes.get_id())

        self.show_all()
        self.realize()

        GLib.idle_add(self.__setup_init2)
Exemple #18
0
class Ventana(Gtk.Window):

    __gtype_name__ = 'Ventana'

    def __init__(self):

        super(Ventana, self).__init__()

        self.set_title("JAMedia Converter")

        self.set_icon_from_file(
            os.path.join(BASEPATH,
            "Iconos", "JAMediaConvert.svg"))

        self.set_resizable(True)
        self.set_size_request(640, 480)
        self.set_border_width(2)
        self.set_position(Gtk.WindowPosition.CENTER)
        self.modify_bg(0, get_colors("window"))

        vbox = Gtk.VBox()
        base_panel = Gtk.HPaned()
        base_panel.modify_bg(0, get_colors("window"))

        self.toolbar = Toolbar()
        self.lista = Lista()
        self.widgettareas = WidgetTareas()

        scroll = Gtk.ScrolledWindow()
        scroll.set_policy(
            Gtk.PolicyType.AUTOMATIC,
            Gtk.PolicyType.AUTOMATIC)
        scroll.add(self.lista)

        base_panel.pack1(scroll, resize=False, shrink=False)
        base_panel.pack2(self.widgettareas, resize=False, shrink=False)

        vbox.pack_start(
            self.toolbar, False, False, 0)
        vbox.pack_start(
            base_panel, True, True, 0)

        self.add(vbox)

        self.show_all()
        self.realize()

        self.toolbar.connect(
            'salir', self.__salir)
        self.toolbar.connect(
            'load', self.__load_files)
        self.lista.connect(
            "nueva-seleccion", self.__selecction_file)
        self.widgettareas.connect(
            'copy_tarea', self.__copy_tarea)

        self.connect("delete-event", self.__salir)

    def __copy_tarea(self, widget, tarea):
        """
        Extiende la tarea configurada a todos
        los archivos en la lista, siempre que estos
        sean del mismo tipo (audio o video) y si su formato
        actual lo permite (ejemplo: no se convierte mp3 a mp3).
        """

        model = self.lista.get_model()
        item = model.get_iter_first()

        it = None

        while item:
            it = item
            item = model.iter_next(item)

            if it:
                path = model.get_value(it, 2)
                widtarea = self.widgettareas.tareas.get(path, False)

                if not widtarea:
                    self.widgettareas.go_tarea(path)

        for key in self.widgettareas.tareas.keys():
            widtarea = self.widgettareas.tareas[key]

            if not widtarea.estado:
                widtarea.setear(tarea)

    def __selecction_file(self, widget, path):

        self.widgettareas.go_tarea(path)

    def __load_files(self, widget, lista):
        """
        Agrega archivos a la lista a procesar.
        """

        items = []

        for origen in lista:
            if os.path.isdir(origen):
                for archivo in os.listdir(origen):
                    arch = os.path.join(origen, archivo)
                    datos = get_data(arch)

                    if 'audio' in datos or \
                        'video' in datos or \
                        'application/ogg' in datos or \
                        'application/octet-stream' in datos:
                        items.append([os.path.basename(arch), arch])

            elif os.path.isfile(origen):
                datos = get_data(origen)

                if 'audio' in datos or \
                    'video' in datos or \
                    'application/ogg' in datos or \
                    'application/octet-stream' in datos:
                    items.append([os.path.basename(origen), origen])

        self.lista.limpiar()

        if items:
            self.lista.agregar_items(items)

    def __salir(self, widget=None, senial=None):

        for key in self.widgettareas.tareas.keys():
            widtarea = self.widgettareas.tareas[key]
            widtarea.stop()

        import sys
        sys.exit(0)
Exemple #19
0
class JAMediaTube(Gtk.Window):
    """
    JAMediaTube.
    """

    def __init__(self):

        Gtk.Window.__init__(self)

        self.set_title("JAMediaTube")
        self.set_icon_from_file(
            os.path.join(BASE_PATH,
            "Iconos", "JAMediaTube.svg"))
        self.set_resizable(True)
        self.set_size_request(640, 480)
        self.set_border_width(2)
        self.set_position(Gtk.WindowPosition.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 Widgets import Toolbar
        from Widgets import Toolbar_Busqueda
        from Widgets import Toolbar_Descarga
        from Widgets import Alerta_Busqueda

        from PanelTube import PanelTube

        from Widgets import ToolbarSalir

        boxbase = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.box_tube = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)

        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

        GLib.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.DestDefaults.ALL,
            target,
            Gdk.DragAction.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.DestDefaults.ALL,
            target,
            Gdk.DragAction.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()

        GLib.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()

        GLib.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)
        from JAMediaYoutube import Buscar

        for video in Buscar(palabras):
            self.videos_temp.append(video)

        GLib.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 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(
            Gdk.ModifierType.BUTTON1_MASK,
            target,
            Gdk.DragAction.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)

        GLib.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)
Exemple #20
0
    def setup_init(self):
        """Se crea la interfaz grafica, se setea todo y
        se empaqueta todo."""

        basebox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        hpanel = Gtk.HPaned()
        self.toolbar = Toolbar()
        self.toolbar_config = ToolbarConfig()
        self.toolbarlector = ToolbarLector()
        self.toolbartry = ToolbarTry()
        self.visor = Drawing()
        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
        ev_box = Gtk.EventBox()  # Para poder pintarlo
        ev_box.modify_bg(0, Gdk.Color(65000, 65000, 65000))
        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)
        vbox.pack_start(self.toolbarpaginas, False, False, 0)
        vbox.pack_start(scroll, True, True, 0)
        ev_box.add(vbox)

        self.controlespdf.append(ev_box)

        hpanel.pack2(ev_box, resize=False, shrink=False)

        basebox.pack_start(self.toolbar, False, False, 0)
        basebox.pack_start(self.toolbar_config, False, False, 0)
        basebox.pack_start(hpanel, True, True, 0)
        basebox.pack_start(self.toolbartry, False, False, 0)

        self.controles_dinamicos = [
            self.toolbar, self.toolbarlector, ev_box, self.toolbartry
        ]

        self.add(basebox)
        self.show_all()

        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("ocultar_controles", self.ocultar_controles)
        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.emit_salir)

        map(self.ocultar, self.controlestexto)
        map(self.ocultar, self.controlespdf)
 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)
Exemple #22
0
    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)
Exemple #23
0
class JAMediaVideo(Gtk.Window):

    def __init__(self):

        super(JAMediaVideo, self).__init__()

        self.set_title("JAMediaVideo")
        self.set_icon_from_file(os.path.join(BASE_PATH,
            "Iconos", "JAMediaVideo.svg"))
        self.set_resizable(True)
        self.set_default_size(640, 480)
        self.modify_bg(0, get_colors("drawingplayer"))
        self.set_position(Gtk.WindowPosition.CENTER)

        self.jamediawebcam = None

        self.toolbar = None
        self.toolbar_salir = None
        self.toolbarprincipal = None

        # Sockets para Aplicaciones Embebidas
        #self.socketjamediavideo = None
        #self.socketjamediafotografia = None
        #self.socketjamediaaudio = None
        #self.socketjamedia = None
        #self.socketjamimagenes = None

        # Aplicaciones Embebidas
        #self.jamediavideo = None
        #self.jamediafotografia = None
        #self.jamediaaudio = None
        #self.jamediaplayer = None
        #self.jamimagenes = None

        self.pantalla = None

        self.controlesdinamicos = None

        self.pistas = []

        self.__setup_init()

    def __setup_init(self):
        """
        Genera y empaqueta toda la interfaz.
        """

        from Widgets import Visor
        from Widgets import ToolbarSalir
        from Widgets import Toolbar
        from Widgets import ToolbarPrincipal
        #from JAMediaVideoAplicaciones import JAMediaVideoWidget
        #from JAMediaVideoAplicaciones import JAMediaFotografiaWidget
        #from JAMediaVideoAplicaciones import JAMediaAudioWidget

        #from JAMedia.JAMedia import JAMediaPlayer
        #from JAMImagenes2.JAMImagenes import JAMImagenes

        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.add(vbox)
        self.show_all()

        self.toolbar = Toolbar()
        self.toolbar_salir = ToolbarSalir()
        self.toolbarprincipal = ToolbarPrincipal()

        #self.socketjamediavideo = Gtk.Socket()
        #self.socketjamediafotografia = Gtk.Socket()
        #self.socketjamediaaudio = Gtk.Socket()
        #self.socketjamedia = Gtk.Socket()
        #self.socketjamimagenes = Gtk.Socket()

        self.pantalla = Visor()

        vbox.pack_start(self.toolbar, False, True, 0)
        vbox.pack_start(self.toolbar_salir, False, True, 0)
        vbox.pack_start(self.toolbarprincipal, False, True, 0)

        #vbox.pack_start(self.socketjamediavideo, True, True, 0)
        #vbox.pack_start(self.socketjamediafotografia, True, True, 0)
        #vbox.pack_start(self.socketjamediaaudio, True, True, 0)
        #vbox.pack_start(self.socketjamedia, True, True, 0)
        #vbox.pack_start(self.socketjamimagenes, True, True, 0)

        vbox.pack_start(self.pantalla, True, True, 0)

        #self.jamediavideo = JAMediaVideoWidget()
        #self.socketjamediavideo.add_id(self.jamediavideo.get_id())

        #self.jamediafotografia = JAMediaFotografiaWidget()
        #self.socketjamediafotografia.add_id(self.jamediafotografia.get_id())

        #self.jamediaaudio = JAMediaAudioWidget()
        #self.socketjamediaaudio.add_id(self.jamediaaudio.get_id())

        #self.jamediaplayer = JAMediaPlayer()
        #self.socketjamedia.add_id(self.jamediaplayer.get_id())

        #self.jamimagenes = JAMImagenes()
        #self.socketjamimagenes.add_id(self.jamimagenes.get_id())

        self.show_all()
        self.realize()

        GLib.idle_add(self.__setup_init2)

    def __setup_init2(self):
        """
        Inicializa la aplicación a su estado fundamental.
        """

        from JAMediaWebCam import JAMediaWebCam

        #self.jamediaplayer.setup_init()
        #self.jamediaplayer.switch_reproductor(None, "JAMediaReproductor")

        #self.jamediavideo.setup_init()
        #self.jamediafotografia.setup_init()
        #self.jamediaaudio.setup_init()

        #self.controlesdinamicos = [
        #    self.toolbar,
        #    self.toolbar_salir,
        #    self.toolbarprincipal,
        #    self.socketjamediavideo,
        #    self.socketjamediafotografia,
        #    self.socketjamediaaudio,
        #    self.socketjamedia,
        #    self.socketjamimagenes]

        #map(self.__ocultar, self.controlesdinamicos)
        #map(self.__mostrar, [self.toolbar, self.toolbarprincipal])

        #from gi.repository import GdkX11

        #xid = self.pantalla.get_property('window').get_xid()
        #self.jamediawebcam = JAMediaWebCam(xid)

        self.toolbar.connect('salir', self.__confirmar_salir)
        self.toolbar_salir.connect('salir', self.__salir)
        self.toolbarprincipal.connect("menu", self.__get_menu)

        #self.jamediavideo.connect('salir', self.__get_menu_base)
        #self.jamediafotografia.connect('salir', self.__get_menu_base)
        #self.jamediaaudio.connect('salir', self.__get_menu_base)
        #self.jamediaplayer.connect('salir', self.__get_menu_base)
        #self.jamimagenes.connect('salir', self.__get_menu_base)

        self.pantalla.connect("button_press_event", self.__clicks_en_pantalla)

        self.connect("delete-event", self.__salir)

        #self.fullscreen()

        #from JAMediaObjects.JAMediaGlobales import get_video_efectos
        #from JAMediaObjects.JAMediaGlobales import get_visualizadores

        #self.jamediavideo.cargar_efectos(list(get_video_efectos()))
        #self.jamediafotografia.cargar_efectos(list(get_video_efectos()))
        #self.jamediaaudio.cargar_efectos(list(get_video_efectos()))
        #self.jamediaaudio.cargar_visualizadores(list(get_visualizadores()))

        #GLib.idle_add(self.jamediawebcam.reset)

        #if self.pistas:
        #    # FIXME: Agregar reconocer tipo de archivo para cargar
        #    # la lista en jamedia o jamediaimagenes.
        #    map(self.__ocultar, self.controlesdinamicos)
        #    self.jamediawebcam.stop()
        #    map(self.__ocultar, [self.pantalla])
        #    map(self.__mostrar, [self.socketjamedia])
        #    self.jamediaplayer.set_nueva_lista(self.pistas)

    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 __get_menu_base(self, widget):
        """
        Cuando se sale de un menú particular,
        se vuelve al menú principal.
        """
        pass
        #map(self.__ocultar, self.controlesdinamicos)
        #map(self.__mostrar, [self.toolbar,
        #    self.toolbarprincipal, self.pantalla])

        #GLib.idle_add(self.jamediawebcam.reset)

    def __get_menu(self, widget, menu):
        """
        Cuando se hace click en algún botón de
        la toolbar principal, se entra en el menú
        correspondiente o se ejecuta determinada acción.
        """
        pass
        #map(self.__ocultar, self.controlesdinamicos)

        #if menu == "Filmar":
        #    self.jamediawebcam.stop()
        #    map(self.__ocultar, [self.pantalla])
        #    map(self.__mostrar, [self.socketjamediavideo])
        #    self.jamediavideo.play()

        #elif menu == "Fotografiar":
        #    self.jamediawebcam.stop()
        #    map(self.__ocultar, [self.pantalla])
        #    map(self.__mostrar, [self.socketjamediafotografia])
        #    self.jamediafotografia.play()

        #elif menu == "Grabar":
        #    self.jamediawebcam.stop()
        #    map(self.__ocultar, [self.pantalla])
        #    map(self.__mostrar, [self.socketjamediaaudio])
        #    self.jamediaaudio.play()

        #elif menu == "Reproducir":
        #    self.jamediawebcam.stop()
        #    map(self.__ocultar, [self.pantalla])
        #    map(self.__mostrar, [self.socketjamedia])
        #    archivos = []

        #    for arch in os.listdir(get_audio_directory()):
        #        ar = os.path.join(get_audio_directory(), arch)
        #        archivos.append([arch, ar])

        #    for arch in os.listdir(get_video_directory()):
        #        ar = os.path.join(get_video_directory(), arch)
        #        archivos.append([arch, ar])

        #    GLib.idle_add(self.jamediaplayer.set_nueva_lista, archivos)

        #elif menu == "Ver":
        #    self.jamediawebcam.stop()
        #    map(self.__ocultar, [self.pantalla])
        #    map(self.__mostrar, [self.socketjamimagenes])

        #    self.jamimagenes.switch_to(None, get_imagenes_directory())

    def __ocultar(self, objeto):
        """
        Esta funcion es llamada desde self.get_menu()
        """

        if objeto.get_visible():
            objeto.hide()

    def __mostrar(self, objeto):
        """
        Esta funcion es llamada desde self.get_menu()
        """

        if not objeto.get_visible():
            objeto.show()

    def set_pistas(self, pistas):

        self.pistas = pistas

    def __confirmar_salir(self, widget=None, senial=None):
        """
        Recibe salir y lo pasa a la toolbar de confirmación.
        """

        self.toolbar_salir.run("JAMediaVideo")

    def __salir(self, widget=None, senial=None):
        """
        Reconfigurar la cámara y salir.
        """

        #self.jamediawebcam.reset()
        #self.jamediawebcam.stop()

        import sys
        Gtk.main_quit()
        sys.exit(0)
Exemple #24
0
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 JAMediaTube(gtk.Window):

    def __init__(self):

        gtk.Window.__init__(self)

        self.set_title("JAMediaTube")
        self.set_icon_from_file(os.path.join(BASE_PATH,
            "Iconos", "JAMediaTube.svg"))
        self.modify_bg(gtk.STATE_NORMAL, get_colors("window"))
        self.set_resizable(True)
        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.jamedia = None

        self.archivos = []
        self.videos_temp = []

        gobject.idle_add(self.__setup_init)
        print "JAMediaTube process:", os.getpid()

    def __setup_init(self):
        """
        Crea y Empaqueta todo.
        """
        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()

        event = gtk.EventBox()
        event.modify_bg(0, get_colors("drawingplayer"))
        event.add(self.toolbar)
        self.box_tube.pack_start(event, False, False, 0)

        event = gtk.EventBox()
        event.modify_bg(0, get_colors("download"))
        event.add(self.toolbar_salir)
        self.box_tube.pack_start(event, False, False, 0)

        self.box_tube.pack_start(self.toolbar_busqueda, False, False, 0)

        event = gtk.EventBox()
        event.modify_bg(0, get_colors("download"))
        event.add(self.toolbar_descarga)
        self.box_tube.pack_start(event, False, False, 0)

        self.box_tube.pack_start(self.alerta_busqueda, False, False, 0)
        self.box_tube.pack_start(self.paneltube, True, True, 0)

        self.jamedia = JAMedia()

        boxbase.pack_start(self.box_tube, True, True, 0)
        boxbase.pack_start(self.jamedia, True, True, 0)
        self.add(boxbase)

        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.__cancel_toolbar()
        self.paneltube.cancel_toolbars_flotantes()

        map(self.__ocultar, [self.toolbar_descarga, self.alerta_busqueda])

        if self.archivos:
            self.__switch(None, 'jamedia')
            self.jamedia.base_panel.set_nueva_lista(self.archivos)
            self.archivos = []
        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)

        self.resize(640, 480)

    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 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)
        for video in 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 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]
        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)
        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)
        gobject.idle_add(self.__add_videos, videos, destino)
        return False

    def __switch(self, widget, valor):
        """
        Cambia entre la vista de descargas y la de reproduccion.
        """
        if valor == 'jamediatube':
            map(self.__ocultar, [self.jamedia])
            map(self.__mostrar, [self.box_tube])
        elif valor == 'jamedia':
            map(self.__ocultar, [self.box_tube])
            map(self.__mostrar, [self.jamedia])

    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):
        self.paneltube.cancel_toolbars_flotantes()
        self.toolbar_salir.run("JAMediaTube")

    def __salir(self, widget=None, senial=None):
        gtk.main_quit()
        sys.exit(0)

    def set_archivos(self, pistas):
        """
        Cuando se ejecuta pasandole un archivo.
        """
        self.archivos = pistas
Exemple #26
0
    def __init__(self, handle):

        activity.Activity.__init__(self, handle)

        self._logger = logging.getLogger('poll-activity')
        self._logger.debug('Starting Poll activity')

        self._polls = set()
        self.current_vote = None

        # This property allows result viewing while voting
        self._view_answer = True

        # This property allows use image in answer
        self._use_image = False

        # This property allows play a sound when click in
        # the button to make a vote
        self._play_vote_sound = False

        # This property allows remember in the radio button options
        # the last vote
        self._remember_last_vote = True

        # This property has the image size
        self._image_size = {'height': 100, 'width': 100}

        # the active poll
        self._poll = None

        # get the Presence Service
        self.pservice = presenceservice.get_instance()
        self.initiating = False

        # Buddy object for you
        owner = self.pservice.get_owner()
        self.owner = owner
        self.nick = owner.props.nick
        self.nick_sha1 = sha1(self.nick.encode()).hexdigest()

        toolbar = Toolbar(self)
        toolbar.create_button.connect('clicked', self.__button_new_clicked)
        toolbar.choose_button.connect('clicked', self.__button_select_clicked)
        toolbar.export_data_bt.connect('clicked', self.__save_data_cb)
        toolbar.export_image_bt.connect('clicked', self.__save_image_cb)

        toolbar.pie_chart_button.connect('clicked',
                                         self.__chart_type_clicked_cb,
                                         CHART_TYPE_PIE)
        toolbar.vbar_chart_button.connect('clicked',
                                          self.__chart_type_clicked_cb,
                                          CHART_TYPE_VERTICAL_BARS)
        self._chart_type_selected = CHART_TYPE_PIE

        self.set_toolbar_box(toolbar)

        emptypanel.show(self, 'new-poll', _('Create a new poll'), _('Create'),
                        self.__button_new_clicked)

        self.show_all()

        self.poll_session = None

        self.connect('shared', self.__shared_cb)
        self.connect('joined', self.__joined_cb)
    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)
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 CairoGrapher(Gtk.Window):

    __gsignals__ = {
        'reload': (GObject.SIGNAL_RUN_FIRST, None, []),
        'save-changes': (GObject.SIGNAL_RUN_FIRST, None, []),
            }

    def __init__(self):

        Gtk.Window.__init__(self)

        self.set_size_request(600, 480)

        self.vbox = Gtk.VBox()
        self.listbox = Gtk.ListBox()
        self.paned = Gtk.HPaned()
        self.area = PlotArea()

        self.listbox.set_selection_mode(Gtk.SelectionMode.NONE)

        scrolled1 = Gtk.ScrolledWindow()
        scrolled2 = Gtk.ScrolledWindow()

        self.cargar_configuracion()
        self.crear_barra()
        self.cargar_variables()

        self.connect('reload', self.__recargar)
        self.connect('reload', self.actualizar_widgets, self.combo_borrar)
        self.connect('save-changes', self.guardar_configuracion)
        self.connect('delete-event', self.salir)

        scrolled1.add(self.area)
        scrolled2.add(self.listbox)
        self.paned.pack1(scrolled1, 300, -1)
        self.paned.pack2(scrolled2)
        self.vbox.pack_start(self.paned, True, True, 0)

        self.add(self.vbox)
        self.vbox.show()
        self.paned.show()
        scrolled1.show_all()
        scrolled2.show()

        self.emit('reload')

    def transformar_colores(self):

        if len(self.colores) >= len(self.colors.keys()):
            for x in self.listbox.get_children():
                self.colors[x] = (self.colores[self.listbox.get_children().index(x)])

    def actualizar_widgets(self, *args):

        boton = self.toolbar.get_children()[3]
        columnas = 0

        if self.valores.keys():
            columnas = len(self.valores[self.valores.keys()[0]])

            self.combo_borrar.remove_all()

            for x in range(1, columnas + 1):
                self.combo_borrar.append_text('Columna ' + str(x))

        self.combo_borrar.set_active(0)
        self.combo_borrar.set_sensitive(columnas > 1)
        self.combo_borrar.boton.set_sensitive(columnas > 1)
        boton.set_sensitive(bool(self.valores.keys()))

        for x in self.toolbar.lista:
            if self.grafica.endswith(x):
                self.toolbar.combo_graficas.set_active(self.toolbar.lista.index(x))
                break

    def crear_barra(self):

        self.toolbar = Toolbar()
        self.combo_borrar = self.toolbar.combo_borrar

        self.toolbar.connect('save', self.guardar_archivo)
        self.toolbar.connect('new-variable', self.crear_variable)
        self.toolbar.connect('new-variable', self.actualizar_widgets)
        self.toolbar.connect('new-column', self.aniadir_a_variable)
        self.toolbar.connect('settings-dialog', self.dialogo_configuraciones)
        self.toolbar.connect('change-plot', self.cambiar_tipo)
        self.toolbar.connect('remove-column', self.borrar_columna)
        self.toolbar.connect('remove-column', self.actualizar_widgets)
        self.toolbar.connect('help-request', self.dialogo_ayuda)

        for x in range(0, len(self.toolbar.lista)):
            if self.grafica.endswith(self.toolbar.lista[x]):
                self.combo_borrar.set_active(x)
                self.combo_borrar.emit('changed')
                break

        self.set_titlebar(self.toolbar)

    def ocultar_controles_de_colores(self, *args):

        for x in self.listbox.get_children():
            hbox = x.get_children()[0]
            controles = hbox.get_children()[-2]
            controles.hide()

    def guardar_archivo(self, *args):

        def save_file(widget, direccion):

            self.direccion = direccion
            self._direccion = direccion
            self.emit('reload')
            self.direccion = os.path.expanduser('~/.cairographer/Grafica.png')

        d = SaveFilesDialog(self._direccion)
        d.connect('save-file', save_file)

    def cambiar_tipo(self, toolbar):

        combo = toolbar.get_plot_combo()
        lista = toolbar.lista
        self.grafica = 'Gráfica de ' + lista[combo.get_active()]

        self.emit('reload')

    def dialogo_configuraciones(self, *args):

        dialogo = SettingsDialog(self.cargar_configuracion(True))
        dialogo.connect('settings-changed', self.settings_changed)
        dialogo.show_all()

    def dialogo_ayuda(self, *args):

        HelpDialog(self)

    def settings_changed(self, widget, dicc):

        self.direccion = dicc['direccion']
        self.grafica = dicc['grafica']
        self.nombre = dicc['nombre']
        self.titulo_x = dicc['titulo_x']
        self.titulo_y = dicc['titulo_y']
        self.tamanyo_x = int(dicc['tamanyo_x'])
        self.tamanyo_y = int(dicc['tamanyo_y'])
        self.inner_radius = dicc['inner_radius']
        self.borde = dicc['borde']
        self.axis = dicc['axis']
        self.rounded_corners = dicc['rounded_corners']
        self.display_values = dicc['display_values']
        self.cuadricula = dicc['gird']
        self.fondo = dicc['fondo']

        texto = str(dicc)
        archivo = os.path.expanduser('~/.cairographer/config.json')
        archivo = open(archivo, 'w')

        archivo.write(texto)
        archivo.close()

        self.emit('reload')

    def crear_grafica(self, grafica=None):

        if not grafica:
            grafica = self.grafica

        self.grafica = grafica
        pasar = False

        #self.cargar_colores()

        if self.colores and type(self.colores[-1]) == float:
            c1 = self.colores[-3]
            c2 = self.colores[-2]
            c3 = self.colores[-1]

            self.colores.remove(self.colores[-1])
            self.colores.remove(self.colores[-1])
            self.colores.remove(self.colores[-1])

            self.colores.insert(-1, (c1, c2, c3))

        for x in self.valores.keys():
            for i in self.valores[x]:
                if i >= 1:
                    pasar = True
                    break

        if not pasar and self.valores.keys():
            self.valores[sorted(self.valores.keys())[0]] = [1]

        if grafica == 'Gráfica de barras horizontales':
            y_labels = sorted(self.valores.keys())
            y_labels.sort()

            if self.valores:
                if len(self.valores[sorted(self.valores.keys())[0]]) == 1:
                    valores = self.transformar_a_barras()

                else:
                    valores = self.valores

                CairoPlot.horizontal_bar_plot(
                    self.direccion,
                    valores,
                    self.tamanyo_x,
                    self.tamanyo_y,
                    background=self.fondo,
                    border=self.borde,
                    display_values=self.display_values,
                    grid=self.cuadricula,
                    rounded_corners=self.rounded_corners,
                    stack=False,
                    three_dimension=True,
                    series_labels=None,
                    x_labels=[],
                    y_labels=y_labels,
                    x_bounds=None,
                    y_bounds=None,
                    colors=self.colores)

        elif grafica == 'Gráfica de barras verticales':
            x_labels = sorted(self.valores.keys()) #self.l_valores
            y_labels = []
            x_labels.sort()

            if self.valores:
                if len(self.valores[sorted(self.valores.keys())[0]]) == 1:
                    valores = self.transformar_a_barras()

                else:
                    valores = self.valores

                CairoPlot.vertical_bar_plot(
                    self.direccion,
                    valores,
                    self.tamanyo_x,
                    self.tamanyo_y,
                    background=self.fondo,
                    border=self.borde,
                    display_values=self.display_values,
                    grid=self.cuadricula,
                    rounded_corners=self.rounded_corners,
                    stack=False,
                    three_dimension=True,
                    series_labels=None,
                    x_labels=x_labels,
                    y_labels=y_labels,
                    x_bounds=None,
                    y_bounds=None,
                    colors=self.colores)

        elif grafica == 'Gráfica de torta':
            CairoPlot.pie_plot(
                self.direccion,
                self.valores,
                self.tamanyo_x,
                self.tamanyo_y,
                background=self.fondo,
                gradient=True,
                shadow=False,
                colors=self.colores)

        elif grafica == 'Gráfica de puntos':
            CairoPlot.dot_line_plot(
                self.direccion,
                self.valores,
                self.tamanyo_x,
                self.tamanyo_y,
                background=self.fondo,
                border=self.borde,
                axis=self.axis,
                dots=False,
                grid=self.cuadricula,
                series_legend=self.grupos,
                x_labels=self.x_labels,
                y_labels=self.y_labels,
                x_bounds=None,
                y_bounds=None,
                x_title=self.titulo_x,
                y_title=self.titulo_y,
                series_colors=self.colores)

        elif grafica == 'Gráfica de anillo':
            CairoPlot.donut_plot(
                self.direccion,
                self.valores,
                self.tamanyo_x,
                self.tamanyo_y,
                background=self.fondo,
                gradient=True,
                shadow=False,
                colors=self.colores,
                inner_radius=self.inner_radius)

        elif grafica == 'Gráfica de ecuaciones':
            valores, rectas = self.transformar_a_ecuaciones()

            CairoPlot.dot_ecuations_plot(self.direccion, valores, rectas=rectas, width=self.tamanyo_x, height=self.tamanyo_y)

        self.area.set_plot(self.direccion)

        self.emit('save-changes')

    def transformar_a_barras(self):

        lista = []
        valores = self.valores.keys()
        valores.sort()

        for x in valores:
            lista += self.valores[x]

        while len(self.colores) < len(lista):
            self.colores += [self.get_color()]

        return lista

    def transformar_a_ecuaciones(self):

        lista = []
        rectas = []
        colores = {}
        rows = self.listbox.get_children()

        for row in rows:
            if len(row.get_children()[0].get_children()) >= 6:
                spins = row.get_children()[0].get_children()[1:3]
                hbox =  row.get_children()[0].get_children()[-2]
                num1 = spins[0].get_value()
                num2 = spins[1].get_value()
                adj1 = Gtk.Adjustment(num1 if num1 <= 20 else 20, -20, 20, 1, 0)
                adj2 = Gtk.Adjustment(num2 if num2 <= 20 else 20, -20, 20, 1, 0)
                spins[0].set_adjustment(adj1)
                spins[1].set_adjustment(adj2)
                spins[0].set_value(num1 if num1 <= 20 else 20)
                spins[1].set_value(num2 if num2 <= 20 else 20)

                r = hbox.get_children()[0].get_value()
                g = hbox.get_children()[1].get_value()
                b = hbox.get_children()[2].get_value()
                color = (r, g, b)
                #print r, g, b
                #for x in hbox.get_children():
                #    color += (x.get_value() * 1.0,)

                lista += [(spins[0].get_value(), spins[1].get_value(), color)]

                if not color in colores:
                    colores[color] = spins[0].get_value(), spins[1].get_value(), color

                else:
                    rectas += [[spins[0].get_value(), spins[1].get_value(), colores[color]]]

        return lista, rectas

    def cargar_colores(self):

        self.colores = []

        for x in self.listbox.get_children():
            self.colores += [self.colors[x]]

        if self.listbox.get_children() and len(self.colores) < len(self.listbox.get_children()[0].get_children()[0]):
            while len(self.colores) < len(self.listbox.get_children()[0].get_children()[0]):
                self.colores += [self.get_color()]

    def borrar_columna(self, widget):

        columna = self.combo_borrar.get_active()
        cambiar = True

        if self.valores.keys() and len(self.valores[sorted(self.valores.keys())[0]]) >= columna:
            self.limpiar_vbox()
            valores = sorted(self.valores.keys())

            for x in valores:
                self.valores[x].remove(self.valores[x][columna])

                c = True

                for i in self.valores[x]:
                    if i > 0:
                        c = False
                        break

                if c and cambiar:
                    self.valores[x][0] = 1.0
                    cambiar = False

            self.cargar_variables()

        self.actualizar_widgets()

    def cargar_variables(self, actualizar=True):

        #if actualizar:
        self.colors = {}
        lista = []
        n = 0

        self.limpiar_vbox()

        for _x in sorted(self.valores.keys()):
            row = Gtk.ListBoxRow()
            hbox = Gtk.HBox()
            label = Gtk.Label(_x)
            entrada = Gtk.Entry()
            numero = 0
            n += 1

            if len(self.colores) >= n:
                self.colors[row] = self.colores[n - 1]

            else:
                self.colors[row] = self.get_color()
                self.colores.append(self.colors[row])

            self.widgets['Entrys'].append(entrada)

            entrada.connect('changed', self.cambiar_nombre_variable, label, row)

            entrada.set_text(_x)

            hbox.pack_start(entrada, False, False, 0)

            for x in self.valores[_x]:
                if len(self.valores) == 1 and len(self.valores[_x]) == 1:
                    _min = 1
                    self.valores[_x][0] = 1

                else:
                    _min = 0

                if self.grafica == 'Gráfica de ecuaciones':
                    _min = -20

                spin = Gtk.SpinButton()
                adj = Gtk.Adjustment(x, _min, 10000000, 1, 10, 0)
                spin.variable = _x

                spin.set_digits(1)
                spin.set_adjustment(adj)
                spin.set_value(x)

                spin.connect('value-changed', self.__change_value, numero)
                self.widgets['SpinButtons'].append(spin)
                hbox.pack_start(spin, False, False, 10)

                numero += 1

            color = self.colors[row]

            boton_cerrar = Gtk.Button()
            boton_cerrar.img = Gtk.Image.new_from_stock(Gtk.STOCK_CLOSE, Gtk.IconSize.BUTTON)
            boton_mas = Gtk.Button()
            boton_mas.img = Gtk.Image.new_from_stock(Gtk.STOCK_ADD, Gtk.IconSize.BUTTON)
            hbox_mas = Gtk.HBox()
            r_adj = Gtk.Adjustment(color[0], 0.0, 1.0, 0.1, 0)
            g_adj = Gtk.Adjustment(color[1], 0.0, 1.0, 0.1)
            b_adj = Gtk.Adjustment(color[2], 0.0, 1.0, 0.1)
            r_scale = Gtk.Scale(orientation=Gtk.Orientation.VERTICAL, adjustment=r_adj)
            g_scale = Gtk.Scale(orientation=Gtk.Orientation.VERTICAL, adjustment=g_adj)
            b_scale = Gtk.Scale(orientation=Gtk.Orientation.VERTICAL, adjustment=b_adj)

            boton_cerrar.set_image(boton_cerrar.img)
            boton_mas.set_image(boton_mas.img)
            boton_mas.set_tooltip_text('Mostrar los controles de color')
            r_scale.set_value(color[0])
            g_scale.set_value(color[1])
            b_scale.set_value(color[2])
            r_scale.set_size_request(-1, 100)
            g_scale.set_size_request(-1, 100)
            b_scale.set_size_request(-1, 100)

            boton_cerrar.connect('clicked', self.borrar_valor, label, entrada, spin, row)

            boton_mas.connect('clicked', self.mostrar, hbox_mas)
            r_scale.connect('value-changed', self.setear_color, 'Rojo', row)
            g_scale.connect('value-changed', self.setear_color, 'Verde', row)
            b_scale.connect('value-changed', self.setear_color, 'Azúl', row)

            hbox_mas.pack_start(r_scale, False, False, 5)
            hbox_mas.pack_start(g_scale, False, False, 5)
            hbox_mas.pack_start(b_scale, False, False, 5)

            lista.append(hbox_mas)

            self.widgets['ClouseButtons'].append(boton_cerrar)
            hbox.pack_end(boton_cerrar, False, False, 0)
            hbox.pack_end(hbox_mas, True, True, 0)
            hbox.pack_end(boton_mas, False, False, 10)
            row.add(hbox)
            self.listbox.add(row)
            self.listbox.show_all()
            self.ocultar_controles_de_colores()

        if actualizar:
            self.emit('reload')
            self.show_all()

            for x in lista:
                x.hide()

    def mostrar(self, boton, widget):

        if widget.get_visible():
            imagen = Gtk.Image.new_from_stock(Gtk.STOCK_ADD,
                Gtk.IconSize.BUTTON)

            widget.hide()
            boton.set_image(imagen)
            boton.set_tooltip_text('Mostrar los controles de color')

        else:
            imagen = Gtk.Image.new_from_stock(Gtk.STOCK_REMOVE,
                Gtk.IconSize.BUTTON)

            widget.show_all()
            boton.set_image(imagen)
            boton.set_tooltip_text('Ocultar los controles de color')

    def setear_color(self, widget, label, row):

        cantidad = widget.get_value()

        if label == 'Rojo':
            color = (cantidad,) + self.colors[row][1:]

        elif label == 'Verde':
            color = self.colors[row][:1] + (cantidad,) + self.colors[row][2:]

        elif label == 'Azúl':
            color =  self.colors[row][:2] + (cantidad,)

        self.colors[row] = color
        self.colores = []

        for x in self.listbox.get_children():
            self.colores.append(self.colors[x])

        self.emit('reload')

    def borrar_valor(self, widget, label, entrada, spin, row):

        self.listbox.remove(row)
        del self.colors[row]
        del self.valores[label.get_label()]

        self.widgets['Entrys'].remove(entrada)
        self.widgets['SpinButtons'].remove(spin)
        self.widgets['ClouseButtons'].remove(widget)

        self.emit('reload')

    def cargar_configuracion(self, devolver=False):

        direccion = os.path.expanduser('~/.cairographer')

        if not os.path.exists(direccion):
            os.mkdir(direccion)

        if not devolver:
            self.widgets = {'SpinButtons': [], 'Entrys': [], 'ClouseButtons': []}
            self.botones = []
            self.grupos = False
            self.colors = {}
            self.x_labels = []
            self.y_labels = []
            self._direccion = os.path.expanduser('~/Grafica.png')

            if not os.path.exists(os.path.join(direccion, 'config.json')):
                self.direccion = os.path.join(direccion, 'Grafica.png')
                self.grafica = 'Gráfica de torta'
                self.valores = {}
                #self.colors = {}
                self.colores = []
                self.nombre = 'Grafica'
                self.titulo_x = 'Gráfica'
                self.titulo_y = ''
                self.tamanyo_x = 600
                self.tamanyo_y = 600
                self.fondo = (1, 1, 1)
                self.borde = 0
                self.display_values = False
                self.axis = True
                self.cuadricula = True
                self.rounded_corners = True
                self.inner_radius = 0.3

                self.emit('save-changes')

            elif os.path.exists(os.path.join(direccion, 'config.json')):
                texto = open(os.path.join(direccion, 'config.json')).read()
                dicc = eval(texto)

                self.direccion = dicc['direccion']
                self.grafica = dicc['grafica']
                self.valores = dicc['valores']
                #self.colors = dicc['colors']
                self.colores = dicc['colores']
                self.nombre = dicc['nombre']
                self.titulo_x = dicc['titulo_x']
                self.titulo_y = dicc['titulo_y']
                self.tamanyo_x = int(dicc['tamanyo_x'])
                self.tamanyo_y = int(dicc['tamanyo_y'])
                self.inner_radius = dicc['inner_radius']
                self.borde = dicc['borde']
                self.axis = dicc['axis']
                self.rounded_corners = dicc['rounded_corners']
                self.display_values = dicc['display_values']
                self.cuadricula = dicc['gird']
                self.fondo = dicc['fondo']

                if '\xc3\xa1' in self.grafica:
                    self.grafica = self.grafica.replace('\xc3\xa1', 'á')

                #self.transformar_colores()
                self.emit('reload')

        else:
            return {
                'direccion': self.direccion,
                'grafica': self.grafica,
                'nombre': self.nombre,
                'titulo_x': self.titulo_x,
                'titulo_y': self.titulo_y,
                'tamanyo_x': self.tamanyo_x,
                'tamanyo_y': self.tamanyo_y,
                'inner_radius': self.inner_radius,
                'borde': self.borde,
                'axis': self.axis,
                'rounded_corners': self.rounded_corners,
                'display_values': self.display_values,
                'gird': self.cuadricula,
                'fondo': self.fondo,
                'valores': self.valores,
                'colors': self.colors,
                'colores': self.colores,
                }

        self.ocultar_controles_de_colores()

    def cambiar_nombre_variable(self, widget, label, row):

        nombre_nuevo = widget.get_text()
        nombre_antiguo = label.get_label()
        valores = self.valores[nombre_antiguo]

        if (nombre_nuevo == nombre_antiguo) or \
            (nombre_nuevo in self.valores.keys()) or \
            (nombre_nuevo == ''):

            return

        label.set_label(nombre_nuevo)
        del self.valores[nombre_antiguo]
        self.valores[nombre_nuevo] = valores

        for x in self.widgets['SpinButtons']:
            if x.variable == nombre_antiguo:
                x.variable = nombre_nuevo

        self.emit('reload')

    def crear_variable(self, *args):

        self.colores += [self.get_color()]
        a = self.valores.keys()

        self.limpiar_vbox()

        if self.valores.keys():
            cantidad = len(self.valores[sorted(self.valores.keys())[0]])
            lista = []

            for x in range(0, cantidad):
                lista += [0.0]

        else:
            lista = [0.0]

        num = (len(self.valores) + 1)
        valor = 'Variable %d' % num

        while True:
            num = int(valor.split(' ')[-1])
            valor = 'Variable %d' % num

            if not valor in self.valores:
                break

            else:
                num += 1
                valor = 'Variable %d' % num

        self.valores[valor] = lista

        self.cargar_variables()
        self.emit('save-changes')

    def limpiar_vbox(self):

        while True:
            if len(self.listbox.get_children()) == 0:
                break

            for x in self.listbox.get_children():
                self.listbox.remove(x)

    def aniadir_a_variable(self, widget):

        for x in self.valores.keys(): #self.l_valores:
            self.valores[x] += [0]

        if self.grafica.startswith('Gráfica de barras'):
            self.colores += self.get_color()

        self.cargar_variables()

    def get_color(self):

        random.seed()

        num1 = random.randint(0, 100) / 100.0
        num2 = random.randint(0, 100) / 100.0
        num3 = random.randint(0, 100) / 100.0
        color = (num1, num2, num3)

        return color

    def guardar_configuracion(self, *args):

        dicc = self.cargar_configuracion(devolver=True)
        archivo = open(os.path.expanduser('~/.cairographer/config.json'), 'w')
        texto = '{\n'

        for x in sorted(dicc.keys()):
            if type(dicc[x]) != list and type(dicc[x]) != dict:
                if type(dicc[x]) == str:
                    texto += '    "' + x + '": ' + '"' + str(dicc[x]) + '",\n'

                elif type(dicc[x]) != str:
                    texto += '    "' + x + '": ' + str(dicc[x]) + ',\n'

            else:
                if type(dicc[x]) == dict and x != 'colors':
                    texto += '    "' + x + '": {\n'
                    for i in sorted(dicc[x].keys()):
                        texto += '        "' + i + '": ' + str(dicc[x][i]) + ',\n'

                    texto += '    },\n'

                elif type(dicc[x]) == list:
                    texto += '    "' + x + '": [\n'
                    for i in sorted(dicc[x]):
                        texto += '        ' + str(i) + ',\n'

                    texto += '    ],\n'

        texto += '}'

        archivo.write(texto)
        archivo.close()

    def __set_value(self, widget, gparam=None):

        if not gparam:
            exec(widget.variable + ' = %d' % widget.get_value())

        elif gparam:
            exec(widget.variable + ' = ' + str(widget.get_active()))

        self.emit('reload')

    def __recargar(self, *args):

        self.crear_grafica()

    def __change_value(self, widget, valor):

        conjunto = widget.variable
        self.valores[conjunto][valor] = widget.get_value()
        self.emit('reload')

    def salir(self, *args):

        Gtk.main_quit()
Exemple #30
0
class JAMediaTube(gtk.Window):

    def __init__(self):

        gtk.Window.__init__(self)

        self.set_title("JAMediaTube")
        self.set_icon_from_file(os.path.join(BASE_PATH,
            "Iconos", "JAMediaTube.svg"))
        self.modify_bg(gtk.STATE_NORMAL, get_colors("window"))
        self.set_resizable(True)
        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.jamedia = None

        self.archivos = []
        self.buscador = Buscar()

        gobject.idle_add(self.__setup_init)
        print "JAMediaTube process:", os.getpid()

    def __setup_init(self):
        """
        Crea y Empaqueta todo.
        """
        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()

        event = gtk.EventBox()
        event.modify_bg(0, get_colors("drawingplayer"))
        event.add(self.toolbar)
        self.box_tube.pack_start(event, False, False, 0)

        event = gtk.EventBox()
        event.modify_bg(0, get_colors("download"))
        event.add(self.toolbar_salir)
        self.box_tube.pack_start(event, False, False, 0)

        self.box_tube.pack_start(self.toolbar_busqueda, False, False, 0)

        event = gtk.EventBox()
        event.modify_bg(0, get_colors("download"))
        event.add(self.toolbar_descarga)
        self.box_tube.pack_start(event, False, False, 0)

        self.box_tube.pack_start(self.alerta_busqueda, False, False, 0)
        self.box_tube.pack_start(self.paneltube, True, True, 0)

        self.jamedia = JAMedia()

        boxbase.pack_start(self.box_tube, True, True, 0)
        boxbase.pack_start(self.jamedia, True, True, 0)
        self.add(boxbase)

        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.__cancel_toolbar()
        self.paneltube.cancel_toolbars_flotantes()
        map(self.__ocultar, [self.toolbar_descarga, self.alerta_busqueda])
        if self.archivos:
            self.__switch(None, 'jamedia')
            self.jamedia.base_panel.set_nueva_lista(self.archivos)
            self.archivos = []
        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)
        self.buscador.connect("encontrado", self.__add_video_encontrado)
        self.buscador.connect("end", self.__end_busqueda)
        self.resize(640, 480)

    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 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 __add_video_encontrado(self, buscador, _id, url):
        """
        Cuando el buscador encuentra un video, se agrega al panel.
        """
        video = dict(FEED)
        video["id"] = _id
        video["titulo"] = ""
        video["descripcion"] = ""
        video["categoria"] = ""
        video["url"] = url
        video["duracion"] = 0
        video["previews"] = ""
        self.__add_videos([video], self.paneltube.encontrados, sensitive=False)
        while gtk.events_pending():
            gtk.main_iteration()
        # Para evitar mover videos antes de lanzar actualización de metadatos

    def __end_busqueda(self, buscador):
        """
        Cuando Termina la Búsqueda, se actualizan los widgets de videos.
        """
        self.paneltube.update_widgets_videos_encontrados()
        self.paneltube.set_sensitive(True)

    def __comenzar_busqueda(self, widget, palabras, cantidad):
        """
        Muestra 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, cantidad)

    def __lanzar_busqueda(self, palabras, cantidad):
        """
        Lanza la Búsqueda y comienza secuencia que agrega los videos al panel.
        """
        # FIXME: Reparar (Si no hay conexión)
        self.buscador.buscar(palabras, cantidad)
        return False

    def __add_videos(self, videos, destino, sensitive=True):
        """
        Se crean los video_widgets y se agregan al panel, segun destino.
        """
        if not videos:
            map(self.__ocultar, [self.alerta_busqueda])
            if sensitive:
                self.paneltube.set_sensitive(True)
            self.toolbar_busqueda.set_sensitive(True)
            return False

        video = videos[0]
        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)
        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)
        gobject.idle_add(self.__add_videos, videos, destino, sensitive)
        return False

    def __switch(self, widget, valor):
        """
        Cambia entre la vista de descargas y la de reproduccion.
        """
        if valor == 'jamediatube':
            map(self.__ocultar, [self.jamedia])
            map(self.__mostrar, [self.box_tube])
        elif valor == 'jamedia':
            map(self.__ocultar, [self.box_tube])
            map(self.__mostrar, [self.jamedia])

    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):
        self.paneltube.cancel_toolbars_flotantes()
        self.toolbar_salir.run("JAMediaTube")

    def __salir(self, widget=None, senial=None):
        gtk.main_quit()
        sys.exit(0)

    def set_archivos(self, pistas):
        """
        Cuando se ejecuta pasandole archivos como parámetros.
        """
        self.archivos = pistas
class JAMediaPyGiHack(Gtk.Box):

    __gtype_name__ = 'JAMediaPyGiHack'

    __gsignals__ = {
        'salir': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, []),
        "abrir":
        (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, (GObject.TYPE_STRING, ))
    }

    def __init__(self):

        Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL)

        self.toolbar = Toolbar()
        self.pack_start(self.toolbar, False, False, 0)

        self.basebox = BaseBox()
        self.pack_start(self.basebox, True, True, 0)

        self.informewidget = False

        # FIXME: Activar para obtener informe de módulos
        #self.connect("realize", self.__realize)
        self.show_all()

        self.toolbar.connect("import", self.__import)
        self.toolbar.connect("accion-menu", self.__set_accion)
        self.toolbar.connect("salir", self.__emit_salir)
        self.toolbar.connect("zoom", self.__zoom)
        self.toolbar.connect("accion", self.__buscar_mas)
        self.toolbar.connect("informe", self.__informar)

        self.basebox.connect("update", self.__update)
        self.basebox.connect('abrir', self.__open_file)
        self.basebox.connect("nobusquedas", self.__desactivar_busquedas)

    """
    def __realize(self, widget):
        GLib.timeout_add(1000, self.__informe_pygihack)

    def __informe_pygihack(self):
        self.get_toplevel().set_sensitive(False)
        dialog = Gtk.Dialog(parent=self.get_toplevel(),
        flags=Gtk.DialogFlags.MODAL,
        buttons=["Aceptar", Gtk.ResponseType.ACCEPT])
        dialog.set_border_width(15)
        dialog.set_size_request(250, 400)
        textview = Gtk.TextView()
        textview.set_editable(False)
        scroll = Gtk.ScrolledWindow()
        scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        scroll.add(textview)
        textview.get_buffer().set_text(self.toolbar.menu.informe)
        dialog.vbox.pack_start(scroll, True, True, 0)
        dialog.vbox.show_all()
        dialog.run()
        dialog.destroy()
        self.get_toplevel().set_sensitive(True)
        return False
    """

    def __open_file(self, widget, modulo_path):
        self.emit("abrir", modulo_path)

    def __zoom(self, widget, zoom):
        self.basebox.zoom(zoom)

    def __informar(self, widget):
        """
        Abre nueva lengueta en Workpanel con la información de Introspección
        del archivo seleccionado.
        """
        if self.informewidget:
            self.informewidget.destroy()
        self.informewidget = InformeWidget(self.get_toplevel())
        text = self.basebox.get_estructura()
        self.informewidget.setting(text)

    def __buscar_mas(self, widget, accion, text):
        self.basebox.buscar_mas(accion, text)

    def __emit_salir(self, widget):
        self.emit('salir')

    def __update(self, widget, view):
        self.toolbar.update(view)
        self.toolbar.activar_busquedas(self.basebox.check_busquedas())

    def __desactivar_busquedas(self, widget):
        self.toolbar.activar_busquedas(False)

    def __set_accion(self, widget, menu, wid_lab, valor):
        self.basebox.set_accion(menu, wid_lab, valor)

    def __import(self, widget, paquete, modulo):
        self.basebox.import_modulo(paquete, modulo)
Exemple #32
0
class CucaraSimsWidget(gtk.HPaned):

    __gsignals__ = {
        "exit": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, []),
        "set-cursor": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
                       (gobject.TYPE_PYOBJECT, )),
        "volumen":
        (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_FLOAT, ))
    }

    def __init__(self, escenario):

        gtk.HPaned.__init__(self)

        self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#ffffff"))

        self.lecciones = []

        self.toolbar = Toolbar()
        vbox = gtk.VBox()
        vbox.pack_start(self.toolbar, False, False, 0)
        vbox.pack_start(escenario, True, True, 0)
        self.toolbarestado = ToolbarEstado()
        vbox.pack_end(self.toolbarestado, False, False, 0)

        self.pack1(vbox, resize=True, shrink=True)
        self.derecha = Derecha()
        self.pack2(self.derecha, resize=False, shrink=False)

        self.toolbarestado.connect("volumen", self.__volumen_changed)
        self.derecha.connect("select", self.__set_cursor)
        self.derecha.connect("lectura", self.__run_lectura)

        self.show_all()

        self.agua_cursor = False
        self.alimento_cursor = False
        self.cursor_root = False
        self.cursor_tipo = False

        gobject.idle_add(self.__config_cursors)

    def __volumen_changed(self, widget, valor):
        self.emit('volumen', valor)

    def __config_cursors(self):
        icono = os.path.join(BASE_PATH, "Imagenes", "jarra.png")
        pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(icono, -1, 24)
        self.agua_cursor = gtk.gdk.Cursor(gtk.gdk.display_get_default(),
                                          pixbuf, 0, 0)

        icono = os.path.join(BASE_PATH, "Imagenes", "pan.png")
        pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(icono, -1, 24)
        self.alimento_cursor = gtk.gdk.Cursor(gtk.gdk.display_get_default(),
                                              pixbuf, 0, 0)

        self.cursor_root = self.get_toplevel().get_property(
            "window").get_cursor()
        return False

    def __set_cursor(self, widget, tipo):
        """
        Cuando el usuario selecciona alimento o agua en la interfaz gtk,
        setea el cursor y manda una señal para hacerlo tambien en pygame.
        """
        win = self.get_toplevel().get_property("window")
        if tipo == "agua":
            if self.cursor_tipo == "agua":
                win.set_cursor(self.cursor_root)
                self.cursor_tipo = False
            else:
                win.set_cursor(self.agua_cursor)
                self.cursor_tipo = "agua"
        elif tipo == "alimento":
            if self.cursor_tipo == "alimento":
                win.set_cursor(self.cursor_root)
                self.cursor_tipo = False
            else:
                win.set_cursor(self.alimento_cursor)
                self.cursor_tipo = "alimento"
        else:
            win.set_cursor(self.cursor_root)
            self.cursor_tipo = False
        self.emit("set-cursor", self.cursor_tipo)

    def __run_lectura(self, derecha, lectura):
        """
        La Interfaz gtk manda abrir una lectura.
        """
        if lectura == "salir":
            self.emit("exit")
            return
        try:
            self.get_toplevel().juego.pause()
        except:
            # Para Sugar
            self.get_toplevel().interfaz.juego.pause()
        dialog = Widget_Leccion(parent=self.get_toplevel(), lectura=lectura)
        dialog.run()
        dialog.stop()
        dialog.destroy()
        try:
            self.get_toplevel().juego.unpause()
        except:
            # Para Sugar
            self.get_toplevel().interfaz.juego.unpause()

    def update(self, juego, _dict):
        """
        El juego pygame actualiza información en la interfaz gtk.
        """
        infocucas = " %sH + %sM = %s" % (_dict["hembras"], _dict["machos"],
                                         _dict["cucas"])
        infoootecas = " = %s" % _dict["ootecas"]
        infoagua = "= %s" % int(_dict["agua"])
        infoalimento = " = %s" % int(_dict["alimento"])
        tiempo = " Años: %s Dias: %s Horas: %s" % (
            _dict["Años"], _dict["Dias"], _dict["Horas"])
        self.toolbar.set_info(infocucas, infoootecas, infoagua, infoalimento,
                              tiempo)

    def run_lectura(self, juego, lectura):
        """
        El Juego pygame manda abrir una lectura.
        """
        if not lectura in self.lecciones:
            self.lecciones.append(lectura)
            try:
                self.get_toplevel().juego.pause()
            except:
                # Para Sugar
                self.get_toplevel().interfaz.juego.pause()
            dialog = Widget_Leccion(parent=self.get_toplevel(),
                                    lectura=lectura)
            dialog.run()
            dialog.stop()
            dialog.destroy()
            try:
                self.get_toplevel().juego.unpause()
            except:
                # Para Sugar
                self.get_toplevel().interfaz.juego.unpause()
        if lectura == "muerte":
            self.toolbarestado.set_info(
                "Se han producido muertes en el habitat.")
        elif lectura == "reproducción":
            self.toolbarestado.set_info("Hay nuevas ootecas en el habitat.")
        elif lectura == "ciclo vital":
            self.toolbarestado.set_info(
                "Se han producido nacimientos en el habitat.")
        elif lectura == "muda de exoesqueleto":
            self.toolbarestado.set_info(
                "Algunas Cucarachas han realizado la muda de su exoesqueleto.")
        elif lectura == "plaga":
            self.toolbarestado.set_info(
                "Hay Demasiadas Cucarachas en el habitat. Algunas migrarán. !!!"
            )
        elif lectura == "extinción":
            self.toolbarestado.set_info(
                "Ya no es Posible la Reproducción en el Habitat.")
        else:
            print lectura, self.run_lectura

    def clear_cursor(self, widget):
        """
        El juego pygame indica que ya no debe haber cursor personalizado.
        """
        self.__set_cursor(False, False)
        self.toolbarestado.set_info(
            "Las Cucarachas Detectan el Alimento con sus Antenas.")

    def puntos(self, juego, puntos):
        self.derecha.set_puntos(puntos)
Exemple #33
0
class Reloj(Gtk.Window):
    
    __gtype_name__ = 'Reloj'
    
    def __init__(self):

        Gtk.Window.__init__(self)

        self.set_size_request(640, 480)
        self.set_title('Reloj')
        
        self.speaker_active = False
        self.speaker = JAMediaSpeak()
        self.minutos = 0
        
        self.toolbar = Toolbar()
        self.reloj = Imagen_Reloj()
        self.hora = Gtk.Label("Time")
        self.fecha = Gtk.Label("Date")
        
        vbox = Gtk.VBox()
        vbox.pack_start(self.toolbar, False, False, 0)
        vbox.pack_start(self.reloj, True, True, 0)
        vbox.pack_start(self.hora, False, False, 0)
        vbox.pack_start(self.fecha, False, False, 0)

        self.add(vbox)
        self.show_all()
        
        self.reloj.connect("update", self.__update)
        self.toolbar.connect("accion", self.__set_accion)
        self.toolbar.connect("speak", self.__set_speak)
        self.connect("delete-event", self.__exit)
        
    def __set_speak(self, widget, valor):
        
        self.speaker_active = valor
    
    def __set_accion(self, widget, accion, valor):
        
        if valor:
            if accion == "Reloj Sencillo":
                self.reloj.tipo = accion
            
            elif accion == "Reloj Digital":
                self.reloj.tipo = accion
    
    def __update(self, widget, date, time):
        
        self.fecha.set_text(date)
        self.hora.set_text(time)
        
        minutos = int(time.split(":")[1])
        
        if self.speaker_active:
            if minutos != self.minutos:
                self.minutos = minutos
                horas = int(time.split(":")[0])
                self.speaker.speak("Son las %s Horas con %s Minutos" % (horas, minutos))
    
    def __exit(self, widget, event):
        
        import sys
        sys.exit(0)
Exemple #34
0
class JAMediaTube(Gtk.Window):
    """
    JAMediaTube.
    """
    def __init__(self):

        Gtk.Window.__init__(self)

        self.set_title("JAMediaTube")
        self.set_icon_from_file(
            os.path.join(BASE_PATH, "Iconos", "JAMediaTube.svg"))
        self.set_resizable(True)
        self.set_size_request(640, 480)
        self.set_border_width(2)
        self.set_position(Gtk.WindowPosition.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 Widgets import Toolbar
        from Widgets import Toolbar_Busqueda
        from Widgets import Toolbar_Descarga
        from Widgets import Alerta_Busqueda

        from PanelTube import PanelTube

        from Widgets import ToolbarSalir

        boxbase = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.box_tube = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)

        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

        GLib.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.DestDefaults.ALL, target,
                                                 Gdk.DragAction.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.DestDefaults.ALL, target,
                                               Gdk.DragAction.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()

        GLib.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()

        GLib.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)
        from JAMediaYoutube import Buscar

        for video in Buscar(palabras):
            self.videos_temp.append(video)

        GLib.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 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(Gdk.ModifierType.BUTTON1_MASK, target,
                                    Gdk.DragAction.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)

        GLib.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)
Exemple #35
0
class JAMediaTube(gtk.Window):
    """
    JAMediaTube.
    """

    def __init__(self):

        gtk.Window.__init__(self)

        self.set_title("JAMediaTube")
        self.set_icon_from_file(
            os.path.join(BASE_PATH,
            "Iconos", "JAMediaTube.svg"))
        self.modify_bg(gtk.STATE_NORMAL, get_colors("window"))
        self.set_resizable(True)
        self.set_size_request(640, 480)
        self.set_border_width(2)
        #self.set_decorated(False)
        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.jamedia = None

        self.pistas = []

        self.videos_temp = []

        self.__setup_init()

    def __setup_init(self):
        """
        Crea y Empaqueta todo.
        """

        from Widgets import Toolbar
        from Widgets import Toolbar_Busqueda
        from Widgets import Toolbar_Descarga
        from Widgets import Alerta_Busqueda
        from PanelTube import PanelTube
        from Widgets 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()

        event = gtk.EventBox()
        event.modify_bg(0, get_colors("drawingplayer"))
        event.add(self.toolbar)
        self.box_tube.pack_start(
            event, False, False, 0)

        event = gtk.EventBox()
        event.modify_bg(0, get_colors("download"))
        event.add(self.toolbar_salir)
        self.box_tube.pack_start(
            event, False, False, 0)

        self.box_tube.pack_start(
            self.toolbar_busqueda, False, False, 0)

        event = gtk.EventBox()
        event.modify_bg(0, get_colors("download"))
        event.add(self.toolbar_descarga)
        self.box_tube.pack_start(
            event, False, False, 0)

        self.box_tube.pack_start(
            self.alerta_busqueda, False, False, 0)
        self.box_tube.pack_start(
            self.paneltube, True, True, 0)

        from Widgets import Tube_Player
        self.jamedia = Tube_Player()

        boxbase.pack_start(self.box_tube, True, True, 0)
        boxbase.pack_start(self.jamedia, True, True, 0)
        self.add(boxbase)

        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)
        from JAMediaYoutube import Buscar

        for video in 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 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)

        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)

        gobject.idle_add(self.__add_videos, videos, destino)

    def __switch(self, widget, valor):
        """
        Cambia entre la vista de descargas y
        la de reproduccion.
        """

        if valor == 'jamediatube':
            map(self.__ocultar, [self.jamedia])
            map(self.__mostrar, [self.box_tube])

        elif valor == 'jamedia':
            map(self.__ocultar, [self.box_tube])
            map(self.__mostrar, [self.jamedia])

    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):

        #import commands
        import sys

        #commands.getoutput('killall mplayer')
        gtk.main_quit()
        sys.exit(0)

    def set_pistas(self, pistas):
        """
        Cuando se ejecuta pasandole un archivo.
        """

        self.pistas = pistas
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 JAMediaPyGiHack(Gtk.Box):

    __gtype_name__ = 'JAMediaPyGiHack'

    __gsignals__ = {
    'salir': (GObject.SIGNAL_RUN_LAST,
        GObject.TYPE_NONE, []),
    "abrir": (GObject.SIGNAL_RUN_LAST,
        GObject.TYPE_NONE, (GObject.TYPE_STRING,))}

    def __init__(self):

        Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL)

        self.toolbar = Toolbar()
        self.pack_start(self.toolbar, False, False, 0)

        self.basebox = BaseBox()
        self.pack_start(self.basebox, True, True, 0)

        self.informewidget = False

        # FIXME: Activar para obtener informe de módulos
        #self.connect("realize", self.__realize)
        self.show_all()

        self.toolbar.connect("import", self.__import)
        self.toolbar.connect("accion-menu", self.__set_accion)
        self.toolbar.connect("salir", self.__emit_salir)
        self.toolbar.connect("zoom", self.__zoom)
        self.toolbar.connect("accion", self.__buscar_mas)
        self.toolbar.connect("informe", self.__informar)

        self.basebox.connect("update", self.__update)
        self.basebox.connect('abrir', self.__open_file)
        self.basebox.connect("nobusquedas", self.__desactivar_busquedas)
        
    """
    def __realize(self, widget):
        GLib.timeout_add(1000, self.__informe_pygihack)

    def __informe_pygihack(self):
        self.get_toplevel().set_sensitive(False)
        dialog = Gtk.Dialog(parent=self.get_toplevel(),
        flags=Gtk.DialogFlags.MODAL,
        buttons=["Aceptar", Gtk.ResponseType.ACCEPT])
        dialog.set_border_width(15)
        dialog.set_size_request(250, 400)
        textview = Gtk.TextView()
        textview.set_editable(False)
        scroll = Gtk.ScrolledWindow()
        scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        scroll.add(textview)
        textview.get_buffer().set_text(self.toolbar.menu.informe)
        dialog.vbox.pack_start(scroll, True, True, 0)
        dialog.vbox.show_all()
        dialog.run()
        dialog.destroy()
        self.get_toplevel().set_sensitive(True)
        return False
    """
    
    def __open_file(self, widget, modulo_path):
        self.emit("abrir", modulo_path)

    def __zoom(self, widget, zoom):
        self.basebox.zoom(zoom)

    def __informar(self, widget):
        """
        Abre nueva lengueta en Workpanel con la información de Introspección
        del archivo seleccionado.
        """
        if self.informewidget:
            self.informewidget.destroy()
        self.informewidget = InformeWidget(self.get_toplevel())
        text = self.basebox.get_estructura()
        self.informewidget.setting(text)

    def __buscar_mas(self, widget, accion, text):
        self.basebox.buscar_mas(accion, text)

    def __emit_salir(self, widget):
        self.emit('salir')

    def __update(self, widget, view):
        self.toolbar.update(view)
        self.toolbar.activar_busquedas(self.basebox.check_busquedas())

    def __desactivar_busquedas(self, widget):
        self.toolbar.activar_busquedas(False)

    def __set_accion(self, widget, menu, wid_lab, valor):
        self.basebox.set_accion(menu, wid_lab, valor)

    def __import(self, widget, paquete, modulo):
        self.basebox.import_modulo(paquete, modulo)
Exemple #38
0
class CucaraSimsWidget(Gtk.HPaned):

    __gsignals__ = {
    "exit": (GObject.SignalFlags.RUN_LAST,
        None, []),
    "set-cursor": (GObject.SignalFlags.RUN_LAST,
        None, (GObject.TYPE_PYOBJECT, )),
    "volumen": (GObject.SignalFlags.RUN_LAST,
        None, (GObject.TYPE_FLOAT, ))}

    def __init__(self, escenario):

        GObject.GObject.__init__(self)

        self.override_background_color(Gtk.StateType.NORMAL, color_parser("#ffffff"))

        self.lecciones = []

        self.toolbar = Toolbar()
        vbox = Gtk.VBox()
        vbox.pack_start(self.toolbar, False, False, 0)
        vbox.pack_start(escenario, True, True, 0)
        self.toolbarestado = ToolbarEstado()
        vbox.pack_end(self.toolbarestado, False, False, 0)

        self.pack1(vbox, resize=True, shrink=True)
        self.derecha = Derecha()
        self.pack2(self.derecha, resize=False, shrink=False)

        self.toolbarestado.connect("volumen", self.__volumen_changed)
        self.derecha.connect("select", self.__set_cursor)
        self.derecha.connect("lectura", self.__run_lectura)

        self.show_all()

        self.agua_cursor = False
        self.alimento_cursor = False
        self.cursor_root = False
        self.cursor_tipo = False

        GLib.idle_add(self.__config_cursors)

    def __volumen_changed(self, widget, valor):
        self.emit('volumen', valor)

    def __config_cursors(self):
        icono = os.path.join(BASE_PATH, "Imagenes", "jarra.png")
        pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(icono, -1, 24)
        self.agua_cursor = Gdk.Cursor.new_from_pixbuf(
            Gdk.Display.get_default(), pixbuf, 0, 0)

        icono = os.path.join(BASE_PATH, "Imagenes", "pan.png")
        pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(icono, -1, 24)
        self.alimento_cursor = Gdk.Cursor.new_from_pixbuf(
            Gdk.Display.get_default(), pixbuf, 0, 0)

        self.cursor_root = self.get_toplevel().get_property(
            "window").get_cursor()
        return False

    def __set_cursor(self, widget, tipo):
        """
        Cuando el usuario selecciona alimento o agua en la interfaz gtk,
        setea el cursor y manda una señal para hacerlo tambien en pygame.
        """
        win = self.get_toplevel().get_property("window")
        if tipo == "agua":
            if self.cursor_tipo == "agua":
                win.set_cursor(self.cursor_root)
                self.cursor_tipo = False
            else:
                win.set_cursor(self.agua_cursor)
                self.cursor_tipo = "agua"
        elif tipo == "alimento":
            if self.cursor_tipo == "alimento":
                win.set_cursor(self.cursor_root)
                self.cursor_tipo = False
            else:
                win.set_cursor(self.alimento_cursor)
                self.cursor_tipo = "alimento"
        else:
            win.set_cursor(self.cursor_root)
            self.cursor_tipo = False
        self.emit("set-cursor", self.cursor_tipo)

    def __run_lectura(self, derecha, lectura):
        """
        La Interfaz gtk manda abrir una lectura.
        """
        if lectura == "salir":
            self.emit("exit")
            return
        try:
            self.get_toplevel().juego.pause()
        except:
            # Para Sugar
            self.get_toplevel().interfaz.juego.pause()
        dialog = Widget_Leccion(
            parent=self.get_toplevel(), lectura=lectura)
        dialog.run()
        dialog.stop()
        dialog.destroy()
        try:
            self.get_toplevel().juego.unpause()
        except:
            # Para Sugar
            self.get_toplevel().interfaz.juego.unpause()

    def update(self, juego, _dict):
        """
        El juego pygame actualiza información en la interfaz Gtk.
        """
        infocucas = " %sH + %sM = %s" % (_dict["hembras"],
            _dict["machos"], _dict["cucas"])
        infoootecas = " = %s" % _dict["ootecas"]
        infoagua = "= %s" % int(_dict["agua"])
        infoalimento = " = %s" % int(_dict["alimento"])
        tiempo = " Años: %s Dias: %s Horas: %s" % (_dict["Años"],
            _dict["Dias"], _dict["Horas"])
        self.toolbar.set_info(infocucas, infoootecas,
            infoagua, infoalimento, tiempo)

    def run_lectura(self, juego, lectura):
        """
        El Juego pygame manda abrir una lectura.
        """
        if not lectura in self.lecciones:
            self.lecciones.append(lectura)
            try:
                self.get_toplevel().juego.pause()
            except:
                # Para Sugar
                self.get_toplevel().interfaz.juego.pause()
            dialog = Widget_Leccion(
                parent=self.get_toplevel(), lectura=lectura)
            dialog.run()
            dialog.stop()
            dialog.destroy()
            try:
                self.get_toplevel().juego.unpause()
            except:
                # Para Sugar
                self.get_toplevel().interfaz.juego.unpause()
        if lectura == "muerte":
            self.toolbarestado.set_info(
                "Se han producido muertes en el habitat.")
        elif lectura == "reproducción":
            self.toolbarestado.set_info("Hay nuevas ootecas en el habitat.")
        elif lectura == "ciclo vital":
            self.toolbarestado.set_info(
                "Se han producido nacimientos en el habitat.")
        elif lectura == "muda de exoesqueleto":
            self.toolbarestado.set_info(
                "Algunas Cucarachas han realizado la muda de su exoesqueleto.")
        elif lectura == "plaga":
            self.toolbarestado.set_info(
                "Hay Demasiadas Cucarachas en el habitat. Algunas migrarán. !!!")
        elif lectura == "extinción":
            self.toolbarestado.set_info(
                "Ya no es Posible la Reproducción en el Habitat.")
        else:
            print lectura, self.run_lectura

    def clear_cursor(self, widget):
        """
        El juego pygame indica que ya no debe haber cursor personalizado.
        """
        self.__set_cursor(False, False)
        self.toolbarestado.set_info(
            "Las Cucarachas Detectan el Alimento con sus Antenas.")

    def puntos(self, juego, puntos):
        self.derecha.set_puntos(puntos)