class BasePanel(gtk.HPaned):
"""
izquierda:
visor
barra con efectos de video que se aplican
derecha:
Configuración de cámara y formato de salida ==> self.camara_setting
balance y efectos de video ==> self.video_widgets_config
efectos de audio ==> self.audio_widgets_config
"""
__gsignals__ = {
"accion-list":
(gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
(gobject.TYPE_PYOBJECT, gobject.TYPE_STRING, gobject.TYPE_PYOBJECT)),
"in-run":
(gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_BOOLEAN, )),
"cancel-toolbars": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ()),
"pendientes":
(gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_STRING, ))
}
def __init__(self):
gtk.HPaned.__init__(self)
self.modify_bg(0, get_colors("toolbars"))
self.control = True
self.jamediawebcam = False
self.player = False
self.imageplayer = False
self.pantalla = Visor()
self.info_label = Info_Label()
self.efectos_en_pipe = Efectos_en_Pipe()
self.progressplayer = ProgressPlayer()
self.jamediaconvert = WidgetConvert()
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_NEVER)
scroll.add_with_viewport(self.efectos_en_pipe)
scroll.get_child().modify_bg(0, get_colors("drawingplayer"))
vbox = gtk.VBox()
vbox.pack_start(self.info_label, False, False, 0)
vbox.pack_start(self.pantalla, True, True, 0)
vbox.pack_start(self.jamediaconvert, True, True, 0)
vbox.pack_start(scroll, False, False, 0)
vbox.pack_start(self.progressplayer, False, False, 0)
self.pack1(vbox, resize=True, shrink=True)
# Area Derecha del Panel
self.box_config = gtk.EventBox()
self.box_config.modify_bg(0, get_colors("window"))
self.vbox_config = gtk.VBox()
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scroll.add_with_viewport(self.vbox_config)
scroll.get_child().modify_bg(0, get_colors("window"))
self.box_config.add(scroll)
self.camara_setting = CamaraConfig()
self.video_out_setting = Video_out_Config()
self.rafagas_setting = Rafagas_Config()
self.balance_config_widget = ToolbarConfig()
self.playerlist = PlayerList()
self.player_control = PlayerControls()
self.widget_efectos = False # WidgetsGstreamerEfectos()
self.vbox_config.pack_start(self.camara_setting, False, False, 0)
self.vbox_config.pack_start(self.video_out_setting, False, False, 0)
self.vbox_config.pack_start(self.rafagas_setting, False, False, 0)
self.vbox_config.pack_start(self.balance_config_widget, False, False,
0)
#self.derecha_vbox.pack_start(self.widget_efectos, True, True, 0)
self.vbox_config.pack_start(self.playerlist, True, True, 0)
self.vbox_config.pack_end(self.player_control, False, True, 0)
self.pack2(self.box_config, resize=False, shrink=False)
self.show_all()
self.pantalla.connect("button_press_event", self.__clicks_en_pantalla)
self.balance_config_widget.connect('valor', self.__set_balance)
self.camara_setting.connect("set_camara", self.__set_camara)
self.video_out_setting.connect("set_video_out", self.__set_video_out)
self.player_control.connect("accion-controls", self.__accion_player)
self.playerlist.connect("nueva-seleccion", self.__play_item)
self.playerlist.connect("accion", self.__re_emit_accion_list)
self.progressplayer.connect("seek", self.__user_set_progress)
self.progressplayer.connect("volumen", self.__set_volumen)
self.jamediaconvert.connect("accion-list", self.__re_emit_accion_list)
self.jamediaconvert.connect("in-run", self.__jamediaconvert_in_run)
self.jamediaconvert.connect("pendientes", self.__jamediaconvert_info)
self.control = False
def __jamediaconvert_info(self, widget, info):
self.emit("pendientes", info)
def __jamediaconvert_in_run(self, widget, valor):
self.emit("in-run", valor)
def __re_emit_accion_list(self, widget, lista, accion, _iter):
self.emit("accion-list", lista, accion, _iter)
def __set_volumen(self, widget, valor):
"""
REPRODUCTOR:
Cuando el usuario cambia el volumen.
"""
if self.player:
self.player.set_volumen(valor)
self.emit("cancel-toolbars")
def __user_set_progress(self, widget=None, valor=None):
"""
REPRODUCTOR:
Recibe la posicion en la barra de progreso cuando
el usuario la desplaza y hace "seek" sobre el reproductor.
"""
if self.player:
self.player.set_position(valor)
self.emit("cancel-toolbars")
def __accion_player(self, widget, senial):
"""
REPRODUCTOR:
Acciones sobre pistas en lista de reproducción.
"""
if senial == "atras":
self.playerlist.seleccionar_anterior()
elif senial == "siguiente":
self.playerlist.seleccionar_siguiente()
elif senial == "stop":
if self.player:
self.player.stop()
elif senial == "pausa-play":
if self.player:
self.player.pause_play()
self.emit("cancel-toolbars")
def __play_item(self, widget, path):
"""
REPRODUCTOR y VISOR de IMAGENES:
"""
if self.player:
volumen = 1.0
volumen = float("{:.1f}".format(
self.progressplayer.volumen.get_value() * 10))
try:
self.player.disconnect_by_func(self.__endfile)
self.player.disconnect_by_func(self.__cambioestadoreproductor)
self.player.disconnect_by_func(self.__update_progress)
#self.player.disconnect_by_func(self.__set_video)
except:
pass
self.player.stop()
del (self.player)
xid = self.pantalla.get_property('window').xid
self.player = JAMediaReproductor(xid)
self.player.connect("endfile", self.__endfile)
self.player.connect("estado", self.__cambioestadoreproductor)
self.player.connect("newposicion", self.__update_progress)
#self.player.connect("video", self.__set_video)
if path:
self.player.load(path)
self.player.set_volumen(volumen)
self.progressplayer.volumen.set_value(volumen / 10)
elif self.imageplayer:
self.imageplayer.load(path)
else:
print self.__play_item, path
def __endfile(self, widget=None, senial=None):
"""
REPRODUCTOR:
Recibe la señal de fin de archivo desde el reproductor
y llama a seleccionar_siguiente en la lista de reproduccion.
"""
self.player_control.set_paused()
gobject.idle_add(self.playerlist.seleccionar_siguiente)
def __cambioestadoreproductor(self, widget=None, valor=None):
"""
REPRODUCTOR:
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.player_control.set_playing()
elif "paused" in valor or "None" in valor:
self.player_control.set_paused()
else:
print "Estado del Reproductor desconocido:", valor
def __update_progress(self, objetoemisor, valor):
"""
REPRODUCTOR:
Recibe el progreso de la reproduccion desde el reproductor
y actualiza la barra de progreso.
"""
self.progressplayer.set_progress(float(valor))
def __set_efecto(self, widget, efecto, propiedad=None, valor=None):
"""
Agrega o configura efectos en la cámara de video o fotografía.
"""
if self.control:
return
if propiedad == True:
self.efectos_en_pipe.add_efecto(efecto)
self.__re_init_video_web_cam()
elif propiedad == False:
self.efectos_en_pipe.remover_efecto(efecto)
self.__re_init_video_web_cam()
else:
self.jamediawebcam.set_efecto(efecto, propiedad, valor)
self.emit("cancel-toolbars")
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 __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()
ventana.set_sensitive(False)
screen = ventana.get_screen()
w, h = ventana.get_size()
ww, hh = (screen.get_width(), screen.get_height())
ventana.toolbar_salir.hide()
color = get_colors("toolbars")
if ww == w and hh == h:
ventana.set_border_width(4)
color = get_colors("toolbars")
gobject.idle_add(ventana.unfullscreen)
else:
ventana.set_border_width(0)
color = get_colors("drawingplayer")
gobject.idle_add(ventana.fullscreen)
ventana.modify_bg(0, color)
ventana.toolbar.modify_bg(0, color)
ventana.toolbar.toolbar_principal.modify_bg(0, color)
ventana.toolbar.toolbar_video.modify_bg(0, color)
ventana.toolbar.toolbar_fotografia.modify_bg(0, color)
ventana.toolbar.toolbar_jamedia.modify_bg(0, color)
ventana.toolbar.toolbar_jamediaimagenes.modify_bg(0, color)
ventana.set_sensitive(True)
self.emit("cancel-toolbars")
def __set_balance(self, widget, valor, tipo):
"""
Setea valores en Balance de Video. valor es % float
"""
if tipo == "saturacion":
self.jamediawebcam.set_balance(saturacion=valor)
elif tipo == "contraste":
self.jamediawebcam.set_balance(contraste=valor)
elif tipo == "brillo":
self.jamediawebcam.set_balance(brillo=valor)
elif tipo == "hue":
self.jamediawebcam.set_balance(hue=valor)
elif tipo == "gamma":
self.jamediawebcam.set_balance(gamma=valor)
self.emit("cancel-toolbars")
def __jamediaconvert_run(self):
"""
Cambia a modo Conversor y Extractor.
"""
if PR:
print "__jamediaconvert_run"
self.pantalla.hide()
self.box_config.hide()
self.jamediaconvert.show()
self.emit("in-run", False)
def __jamediaimagenes_run(self):
"""
Cambia a modo visor de imágenes.
"""
if PR:
print "__jamediaimagenes_run"
self.imageplayer = ImagePlayer(self.pantalla)
self.playerlist.set_mime_types(["image/*"])
def __jamedia_run(self):
"""
Cambia a modo reproductor.
"""
if PR:
print "__jamedia_run"
xid = self.pantalla.get_property('window').xid
self.player = JAMediaReproductor(xid)
self.playerlist.set_mime_types(["audio/*", "video/*"])
self.progressplayer.show()
def __camara_menu_run(self):
"""
Cambia a modo Cámara básica del menú.
"""
if PR:
print "__camara_menu_run"
self.control = True
device = self.camara_setting.device
xid = self.pantalla.get_property('window').xid
self.jamediawebcam = JAMediaWebCamMenu(xid, device=device)
self.jamediawebcam.play()
self.control = False
def __camara_video_run(self):
"""
Cambia modo Cámara de video.
"""
if PR:
print "__camara_video_run"
self.control = True
device = self.camara_setting.device
salida = self.video_out_setting.formato
xid = self.pantalla.get_property('window').xid
self.jamediawebcam = JAMediaWebCamVideo(xid,
device=device,
formato=salida,
efectos=[])
self.jamediawebcam.connect("update", self.__update_record)
self.jamediawebcam.connect("stop-rafaga", self.__recibe_stop_rafaga)
self.jamediawebcam.connect("endfile", self.__control_grabacion_end)
if "Escritorio" in device:
self.get_toplevel().toolbar.permitir_filmar(True)
else:
if "/dev/video" in device:
self.get_toplevel().toolbar.permitir_filmar(True)
else:
self.get_toplevel().toolbar.permitir_filmar(False)
self.jamediawebcam.play()
self.control = False
def __control_grabacion_end(self, widget):
self.mode_change("video")
def __camara_foto_run(self):
"""
Cambia a modo Cámara de Fotografía.
"""
if PR:
print "__camara_foto_run"
self.control = True
device = self.camara_setting.device
salida = self.video_out_setting.formato
xid = self.pantalla.get_property('window').xid
self.jamediawebcam = JAMediaWebCamVideo(xid,
device=device,
formato=salida,
efectos=[])
self.jamediawebcam.connect("update", self.__update_record)
self.jamediawebcam.connect("stop-rafaga", self.__recibe_stop_rafaga)
gobject.idle_add(self.jamediawebcam.play)
self.control = False
def __recibe_stop_rafaga(self, widget):
"""
Cuando la camara dejará de fotografiar.
"""
self.info_label.set_text("")
self.info_label.hide()
gobject.timeout_add(500, self.__resensitive_foto)
def __resensitive_foto(self):
toolbar = self.get_toplevel().toolbar
toolbar.toolbar_fotografia.set_estado("Stop")
return False
def __update_balance_toolbars(self, config):
"""
Actualiza las toolbars de balance en video.
"""
self.balance_config_widget.set_balance(
brillo=config.get('brillo', False),
contraste=config.get('contraste', False),
saturacion=config.get('saturacion', False),
hue=config.get('hue', False),
gamma=config.get('gamma', False))
def __set_video_out(self, widget, tipo, formato):
"""
Setea la salida de video para camara de filmación y fotografía.
"""
self.jamediawebcam.set_formato(formato)
self.emit("cancel-toolbars")
def __set_camara(self, widget, tipo, device):
"""
Setea la entrada de video para camara de filmación y fotografía.
Si la entrada de video es la red lan, deshabilita el volcado a la
red y la grabación.
"""
if "Escritorio" in device:
self.video_out_setting.set_sensitive(True)
self.get_toplevel().toolbar.permitir_filmar(True)
else:
if "/dev/video" in device:
self.video_out_setting.set_sensitive(True)
self.get_toplevel().toolbar.permitir_filmar(True)
else:
#FIXME: Anular Grabación para cámara Remota:
self.video_out_setting.set_sensitive(False)
self.get_toplevel().toolbar.permitir_filmar(False)
self.__re_init_video_web_cam(device=device)
self.emit("cancel-toolbars")
def __re_init_video_web_cam(self, device=False, salida=False):
"""
Cuando se agregan o quitan efectos o se cambia la fuente de video,
se crea un nuevo objeto gstreamer que mantiene las configuraciones
realizadas hasta el momento.
"""
if PR:
print "__re_init_video_web_cam", device, salida
rot = 0
config = {}
if self.jamediawebcam:
rot = self.jamediawebcam.get_rotacion()
config = self.jamediawebcam.get_config()
efectos = self.efectos_en_pipe.get_efectos()
if not device:
device = self.camara_setting.device
if not salida:
salida = self.video_out_setting.formato
if self.jamediawebcam:
try:
self.jamediawebcam.disconnect_by_func(self.__update_record)
self.jamediawebcam.disconnect_by_func(
self.__recibe_stop_rafaga)
self.jamediawebcam.disconnect_by_func(
self.__control_grabacion_end)
except:
pass
self.jamediawebcam.stop()
del (self.jamediawebcam)
self.jamediawebcam = False
time.sleep(3)
xid = self.pantalla.get_property('window').xid
self.jamediawebcam = JAMediaWebCamVideo(xid,
device=device,
formato=salida,
efectos=efectos)
self.jamediawebcam.connect("update", self.__update_record)
self.jamediawebcam.connect("stop-rafaga", self.__recibe_stop_rafaga)
self.jamediawebcam.connect("endfile", self.__control_grabacion_end)
self.jamediawebcam.play()
self.__re_config(rot, config, efectos)
def __re_config(self, rot, config, efectos):
if PR:
print "__re_config", rot, config, efectos
self.jamediawebcam.set_balance(
brillo=config.get("brillo", False),
contraste=config.get("contraste", False),
saturacion=config.get("saturacion", False),
hue=config.get("hue", False),
gamma=config.get("gamma", False))
if rot:
self.jamediawebcam.set_rotacion(rot)
for efecto in efectos:
self.widget_efectos.reemit_config_efecto(efecto)
self.__update_balance_toolbars(config)
return False
def __update_record(self, widget, info):
self.info_label.show()
self.info_label.set_text(info)
def __re_sensitive(self):
self.get_toplevel().toolbar.set_sensitive(True)
return False
def update_accions(self, accion, uri):
"""
Cuando se quita un archivo de su lugar a través de la lista,
se detienen los reproductores y se quita la tarea de ese
archivo en el conversor.
"""
if accion in ["Quitar", "Borrar", "Mover"]:
if self.player:
self.player.stop()
if self.imageplayer:
self.imageplayer.stop()
self.jamediaconvert.quitar(uri)
def mode_change(self, tipo):
"""
Cambia el modo de la aplicación.
"""
if PR:
print "Mode_Change:", tipo
self.get_toplevel().toolbar.set_sensitive(False)
self.jamediaconvert.reset()
self.jamediaconvert.hide()
self.pantalla.show()
if self.jamediawebcam:
try:
self.jamediawebcam.disconnect_by_func(self.__update_record)
self.jamediawebcam.disconnect_by_func(
self.__recibe_stop_rafaga)
self.jamediawebcam.disconnect_by_func(
self.__control_grabacion_end)
except:
pass
self.jamediawebcam.stop()
del (self.jamediawebcam)
self.jamediawebcam = False
if self.player:
try:
self.player.disconnect_by_func(self.__endfile)
self.player.disconnect_by_func(self.__cambioestadoreproductor)
self.player.disconnect_by_func(self.__update_progress)
#self.player.disconnect_by_func(self.__set_video)
except:
pass
self.player.stop()
del (self.player)
self.player = False
if self.imageplayer:
self.imageplayer.stop()
del (self.imageplayer)
self.imageplayer = False
if self.widget_efectos:
self.widget_efectos.clear()
self.info_label.set_text("")
self.info_label.hide()
self.efectos_en_pipe.clear()
self.playerlist.limpiar()
self.progressplayer.hide()
if tipo == "menu":
self.__camara_menu_run()
elif tipo == "video":
self.__camara_video_run()
elif tipo == "foto":
self.__camara_foto_run()
elif tipo == "jamedia":
self.__jamedia_run()
elif tipo == "jamediaimagenes":
self.__jamediaimagenes_run()
elif tipo == "converter":
self.__jamediaconvert_run()
else:
print "BasePanel Nuevo Modo:", tipo
gobject.timeout_add(1000, self.__re_sensitive)
def set_accion(self, modo, accion):
"""
Le pasa a la camara las ordenes seleccionadas por el
usuario en la toolbar correspondiente de la aplicacion.
"""
self.emit("cancel-toolbars")
if accion == "Izquierda" or accion == "Derecha":
if self.jamediawebcam:
self.jamediawebcam.rotar(accion)
elif self.player:
self.player.rotar(accion)
elif self.imageplayer:
self.imageplayer.rotar(accion)
else:
print "Accion sin definir:", self.set_accion, modo, accion
elif accion == "Stop":
if modo == "video":
self.get_toplevel().toolbar.set_sensitive(False)
self.__re_init_video_web_cam()
self.info_label.set_text("")
self.info_label.hide()
gobject.timeout_add(1000, self.__re_sensitive)
elif modo == "foto":
self.get_toplevel().toolbar.set_sensitive(False)
self.__re_init_video_web_cam()
self.info_label.set_text("")
self.info_label.hide()
gobject.timeout_add(300, self.__re_sensitive)
elif modo == "jamediaconverter":
self.jamediaconvert.tareas_pendientes = []
# FIXME: Considerar detener la conversíon en progreso
else:
print "Accion sin definir:", self.set_accion, modo, accion
elif accion == "Filmar": # and modo == "video":
self.get_toplevel().toolbar.set_sensitive(False)
hora = time.strftime("%H-%M-%S")
fecha = str(datetime.date.today())
archivo = "JV_%s_%s" % (fecha, hora)
archivo = os.path.join(get_video_directory(), archivo)
self.jamediawebcam.filmar(archivo)
gobject.timeout_add(1000, self.__re_sensitive)
elif accion == "Fotografiar":
self.get_toplevel().toolbar.set_sensitive(False)
rafaga = self.rafagas_setting.get_rafaga()
self.jamediawebcam.fotografiar(get_imagenes_directory(), rafaga)
gobject.timeout_add(300, self.__re_sensitive)
# FIXME: Desactivadas por ahora
#elif accion == "Centrar" or accion == "Acercar" or accion == "Alejar":
# self.imageplayer.set_zoom(accion)
else:
print "Accion sin definir:", self.set_accion, modo, accion
def config_show(self, tipo):
"""
Muestra u oculta los widgets de configuración.
"""
if tipo:
if self.box_config.get_visible():
self.box_config.hide()
else:
self.box_config.show()
else:
self.box_config.hide()
return
video_widgets = [
self.camara_setting, self.video_out_setting,
self.balance_config_widget, self.widget_efectos
]
foto_widgets = [
self.camara_setting,
#self.video_out_setting,
self.rafagas_setting,
self.balance_config_widget,
self.widget_efectos
]
jamedia_widgets = [
#self.camara_setting,
#self.video_out_setting,
#self.rafagas_setting,
#self.balance_config_widget,
#self.widget_efectos,
self.playerlist,
self.player_control
]
jamediaimagenes_widgets = [
#self.camara_setting,
#self.video_out_setting,
#self.rafagas_setting,
#self.balance_config_widget,
#self.widget_efectos,
self.playerlist,
#self.player_control,
]
map(ocultar, video_widgets)
map(ocultar, foto_widgets)
map(ocultar, jamedia_widgets)
map(ocultar, jamediaimagenes_widgets)
if tipo == "camara":
map(mostrar, video_widgets)
self.camara_setting.label_ip.set_text(get_ip())
elif tipo == "foto":
map(mostrar, foto_widgets)
self.camara_setting.label_ip.set_text(get_ip())
elif tipo == "jamedia":
map(mostrar, jamedia_widgets)
elif tipo == "jamediaimagenes":
map(mostrar, jamediaimagenes_widgets)
else:
print self.config_show, "Falta definir:", tipo
if self.jamediawebcam:
self.__update_balance_toolbars(self.jamediawebcam.get_config())
self.emit("cancel-toolbars")
def pack_efectos(self):
"""
Empaqueta los widgets de efectos gstreamer.
"""
self.widget_efectos = WidgetsGstreamerVideoEfectos()
self.vbox_config.pack_start(self.widget_efectos, False, False, 0)
gobject.idle_add(self.__cargar_efectos,
list(get_jamedia_video_efectos()))
self.widget_efectos.connect("click_efecto", self.__set_efecto)
self.widget_efectos.connect("configurar_efecto", self.__set_efecto)
def salir(self):
if self.jamediawebcam:
try:
self.jamediawebcam.disconnect_by_func(self.__update_record)
self.jamediawebcam.disconnect_by_func(
self.__recibe_stop_rafaga)
self.jamediawebcam.disconnect_by_func(
self.__control_grabacion_end)
except:
pass
self.jamediawebcam.stop()
del (self.jamediawebcam)
self.jamediawebcam = False
if self.player:
try:
self.player.disconnect_by_func(self.__endfile)
self.player.disconnect_by_func(self.__cambioestadoreproductor)
self.player.disconnect_by_func(self.__update_progress)
#self.player.disconnect_by_func(self.__set_video)
except:
pass
self.player.stop()
del (self.player)
self.player = False
if self.imageplayer:
self.imageplayer.stop()
del (self.imageplayer)
self.imageplayer = False
self.jamediaconvert.reset()
class BasePanel(gtk.HPaned):
"""
izquierda:
visor
barra con efectos de video que se aplican
derecha:
Configuración de cámara y formato de salida ==> self.camara_setting
balance y efectos de video ==> self.video_widgets_config
efectos de audio ==> self.audio_widgets_config
"""
__gsignals__ = {
"accion-list": (gobject.SIGNAL_RUN_LAST,
gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,
gobject.TYPE_STRING, gobject.TYPE_PYOBJECT)),
"in-run": (gobject.SIGNAL_RUN_LAST,
gobject.TYPE_NONE, (gobject.TYPE_BOOLEAN, )),
"cancel-toolbars": (gobject.SIGNAL_RUN_LAST,
gobject.TYPE_NONE, ()),
"pendientes": (gobject.SIGNAL_RUN_LAST,
gobject.TYPE_NONE, (gobject.TYPE_STRING, ))}
def __init__(self):
gtk.HPaned.__init__(self)
self.modify_bg(0, get_colors("toolbars"))
self.control = True
self.jamediawebcam = False
self.player = False
self.imageplayer = False
self.pantalla = Visor()
self.info_label = Info_Label()
self.efectos_en_pipe = Efectos_en_Pipe()
self.progressplayer = ProgressPlayer()
self.jamediaconvert = WidgetConvert()
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_NEVER)
scroll.add_with_viewport(self.efectos_en_pipe)
scroll.get_child().modify_bg(0, get_colors("drawingplayer"))
vbox = gtk.VBox()
vbox.pack_start(self.info_label, False, False, 0)
vbox.pack_start(self.pantalla, True, True, 0)
vbox.pack_start(self.jamediaconvert, True, True, 0)
vbox.pack_start(scroll, False, False, 0)
vbox.pack_start(self.progressplayer, False, False, 0)
self.pack1(vbox, resize=True, shrink=True)
# Area Derecha del Panel
self.box_config = gtk.EventBox()
self.box_config.modify_bg(0, get_colors("window"))
self.vbox_config = gtk.VBox()
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scroll.add_with_viewport(self.vbox_config)
scroll.get_child().modify_bg(0, get_colors("window"))
self.box_config.add(scroll)
self.camara_setting = CamaraConfig()
self.video_out_setting = Video_out_Config()
self.rafagas_setting = Rafagas_Config()
self.balance_config_widget = ToolbarConfig()
self.playerlist = PlayerList()
self.player_control = PlayerControls()
self.widget_efectos = False # WidgetsGstreamerEfectos()
self.vbox_config.pack_start(self.camara_setting, False, False, 0)
self.vbox_config.pack_start(self.video_out_setting, False, False, 0)
self.vbox_config.pack_start(self.rafagas_setting, False, False, 0)
self.vbox_config.pack_start(self.balance_config_widget, False, False, 0)
#self.derecha_vbox.pack_start(self.widget_efectos, True, True, 0)
self.vbox_config.pack_start(self.playerlist, True, True, 0)
self.vbox_config.pack_end(self.player_control, False, True, 0)
self.pack2(self.box_config, resize=False, shrink=False)
self.show_all()
self.pantalla.connect("button_press_event", self.__clicks_en_pantalla)
self.balance_config_widget.connect('valor', self.__set_balance)
self.camara_setting.connect("set_camara", self.__set_camara)
self.video_out_setting.connect("set_video_out", self.__set_video_out)
self.player_control.connect("accion-controls", self.__accion_player)
self.playerlist.connect("nueva-seleccion", self.__play_item)
self.playerlist.connect("accion", self.__re_emit_accion_list)
self.progressplayer.connect("seek", self.__user_set_progress)
self.progressplayer.connect("volumen", self.__set_volumen)
self.jamediaconvert.connect("accion-list", self.__re_emit_accion_list)
self.jamediaconvert.connect("in-run", self.__jamediaconvert_in_run)
self.jamediaconvert.connect("pendientes", self.__jamediaconvert_info)
self.control = False
def __jamediaconvert_info(self, widget, info):
self.emit("pendientes", info)
def __jamediaconvert_in_run(self, widget, valor):
self.emit("in-run", valor)
def __re_emit_accion_list(self, widget, lista, accion, _iter):
self.emit("accion-list", lista, accion, _iter)
def __set_volumen(self, widget, valor):
"""
REPRODUCTOR:
Cuando el usuario cambia el volumen.
"""
if self.player:
self.player.set_volumen(valor)
self.emit("cancel-toolbars")
def __user_set_progress(self, widget=None, valor=None):
"""
REPRODUCTOR:
Recibe la posicion en la barra de progreso cuando
el usuario la desplaza y hace "seek" sobre el reproductor.
"""
if self.player:
self.player.set_position(valor)
self.emit("cancel-toolbars")
def __accion_player(self, widget, senial):
"""
REPRODUCTOR:
Acciones sobre pistas en lista de reproducción.
"""
if senial == "atras":
self.playerlist.seleccionar_anterior()
elif senial == "siguiente":
self.playerlist.seleccionar_siguiente()
elif senial == "stop":
if self.player:
self.player.stop()
elif senial == "pausa-play":
if self.player:
self.player.pause_play()
self.emit("cancel-toolbars")
def __play_item(self, widget, path):
"""
REPRODUCTOR y VISOR de IMAGENES:
"""
if self.player:
volumen = 1.0
volumen = float("{:.1f}".format(
self.progressplayer.volumen.get_value() * 10))
try:
self.player.disconnect_by_func(self.__endfile)
self.player.disconnect_by_func(self.__cambioestadoreproductor)
self.player.disconnect_by_func(self.__update_progress)
#self.player.disconnect_by_func(self.__set_video)
except:
pass
self.player.stop()
del(self.player)
xid = self.pantalla.get_property('window').xid
self.player = JAMediaReproductor(xid)
self.player.connect("endfile", self.__endfile)
self.player.connect("estado", self.__cambioestadoreproductor)
self.player.connect("newposicion", self.__update_progress)
#self.player.connect("video", self.__set_video)
if path:
self.player.load(path)
self.player.set_volumen(volumen)
self.progressplayer.volumen.set_value(volumen / 10)
elif self.imageplayer:
self.imageplayer.load(path)
else:
print self.__play_item, path
def __endfile(self, widget=None, senial=None):
"""
REPRODUCTOR:
Recibe la señal de fin de archivo desde el reproductor
y llama a seleccionar_siguiente en la lista de reproduccion.
"""
self.player_control.set_paused()
gobject.idle_add(self.playerlist.seleccionar_siguiente)
def __cambioestadoreproductor(self, widget=None, valor=None):
"""
REPRODUCTOR:
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.player_control.set_playing()
elif "paused" in valor or "None" in valor:
self.player_control.set_paused()
else:
print "Estado del Reproductor desconocido:", valor
def __update_progress(self, objetoemisor, valor):
"""
REPRODUCTOR:
Recibe el progreso de la reproduccion desde el reproductor
y actualiza la barra de progreso.
"""
self.progressplayer.set_progress(float(valor))
def __set_efecto(self, widget, efecto, propiedad=None, valor=None):
"""
Agrega o configura efectos en la cámara de video o fotografía.
"""
if self.control:
return
if propiedad == True:
self.efectos_en_pipe.add_efecto(efecto)
self.__re_init_video_web_cam()
elif propiedad == False:
self.efectos_en_pipe.remover_efecto(efecto)
self.__re_init_video_web_cam()
else:
self.jamediawebcam.set_efecto(efecto, propiedad, valor)
self.emit("cancel-toolbars")
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 __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()
ventana.set_sensitive(False)
screen = ventana.get_screen()
w, h = ventana.get_size()
ww, hh = (screen.get_width(), screen.get_height())
ventana.toolbar_salir.hide()
color = get_colors("toolbars")
if ww == w and hh == h:
ventana.set_border_width(4)
color = get_colors("toolbars")
gobject.idle_add(ventana.unfullscreen)
else:
ventana.set_border_width(0)
color = get_colors("drawingplayer")
gobject.idle_add(ventana.fullscreen)
ventana.modify_bg(0, color)
ventana.toolbar.modify_bg(0, color)
ventana.toolbar.toolbar_principal.modify_bg(0, color)
ventana.toolbar.toolbar_video.modify_bg(0, color)
ventana.toolbar.toolbar_fotografia.modify_bg(0, color)
ventana.toolbar.toolbar_jamedia.modify_bg(0, color)
ventana.toolbar.toolbar_jamediaimagenes.modify_bg(0, color)
ventana.set_sensitive(True)
self.emit("cancel-toolbars")
def __set_balance(self, widget, valor, tipo):
"""
Setea valores en Balance de Video. valor es % float
"""
if tipo == "saturacion":
self.jamediawebcam.set_balance(saturacion=valor)
elif tipo == "contraste":
self.jamediawebcam.set_balance(contraste=valor)
elif tipo == "brillo":
self.jamediawebcam.set_balance(brillo=valor)
elif tipo == "hue":
self.jamediawebcam.set_balance(hue=valor)
elif tipo == "gamma":
self.jamediawebcam.set_balance(gamma=valor)
self.emit("cancel-toolbars")
def __jamediaconvert_run(self):
"""
Cambia a modo Conversor y Extractor.
"""
if PR:
print "__jamediaconvert_run"
self.pantalla.hide()
self.box_config.hide()
self.jamediaconvert.show()
self.emit("in-run", False)
def __jamediaimagenes_run(self):
"""
Cambia a modo visor de imágenes.
"""
if PR:
print "__jamediaimagenes_run"
self.imageplayer = ImagePlayer(self.pantalla)
self.playerlist.set_mime_types(["image/*"])
def __jamedia_run(self):
"""
Cambia a modo reproductor.
"""
if PR:
print "__jamedia_run"
xid = self.pantalla.get_property('window').xid
self.player = JAMediaReproductor(xid)
self.playerlist.set_mime_types(["audio/*", "video/*"])
self.progressplayer.show()
def __camara_menu_run(self):
"""
Cambia a modo Cámara básica del menú.
"""
if PR:
print "__camara_menu_run"
self.control = True
device = self.camara_setting.device
xid = self.pantalla.get_property('window').xid
self.jamediawebcam = JAMediaWebCamMenu(xid, device=device)
self.jamediawebcam.play()
self.control = False
def __camara_video_run(self):
"""
Cambia modo Cámara de video.
"""
if PR:
print "__camara_video_run"
self.control = True
device = self.camara_setting.device
salida = self.video_out_setting.formato
xid = self.pantalla.get_property('window').xid
self.jamediawebcam = JAMediaWebCamVideo(xid, device=device,
formato=salida, efectos=[])
self.jamediawebcam.connect("update", self.__update_record)
self.jamediawebcam.connect("stop-rafaga", self.__recibe_stop_rafaga)
self.jamediawebcam.connect("endfile", self.__control_grabacion_end)
if "Escritorio" in device:
self.get_toplevel().toolbar.permitir_filmar(True)
else:
if "/dev/video" in device:
self.get_toplevel().toolbar.permitir_filmar(True)
else:
self.get_toplevel().toolbar.permitir_filmar(False)
self.jamediawebcam.play()
self.control = False
def __control_grabacion_end(self, widget):
self.mode_change("video")
def __camara_foto_run(self):
"""
Cambia a modo Cámara de Fotografía.
"""
if PR:
print "__camara_foto_run"
self.control = True
device = self.camara_setting.device
salida = self.video_out_setting.formato
xid = self.pantalla.get_property('window').xid
self.jamediawebcam = JAMediaWebCamVideo(xid, device=device,
formato=salida, efectos=[])
self.jamediawebcam.connect("update", self.__update_record)
self.jamediawebcam.connect("stop-rafaga", self.__recibe_stop_rafaga)
gobject.idle_add(self.jamediawebcam.play)
self.control = False
def __recibe_stop_rafaga(self, widget):
"""
Cuando la camara dejará de fotografiar.
"""
self.info_label.set_text("")
self.info_label.hide()
gobject.timeout_add(500, self.__resensitive_foto)
def __resensitive_foto(self):
toolbar = self.get_toplevel().toolbar
toolbar.toolbar_fotografia.set_estado("Stop")
return False
def __update_balance_toolbars(self, config):
"""
Actualiza las toolbars de balance en video.
"""
self.balance_config_widget.set_balance(
brillo=config.get('brillo', False),
contraste=config.get('contraste', False),
saturacion=config.get('saturacion', False),
hue=config.get('hue', False),
gamma=config.get('gamma', False))
def __set_video_out(self, widget, tipo, formato):
"""
Setea la salida de video para camara de filmación y fotografía.
"""
self.jamediawebcam.set_formato(formato)
self.emit("cancel-toolbars")
def __set_camara(self, widget, tipo, device):
"""
Setea la entrada de video para camara de filmación y fotografía.
Si la entrada de video es la red lan, deshabilita el volcado a la
red y la grabación.
"""
if "Escritorio" in device:
self.video_out_setting.set_sensitive(True)
self.get_toplevel().toolbar.permitir_filmar(True)
else:
if "/dev/video" in device:
self.video_out_setting.set_sensitive(True)
self.get_toplevel().toolbar.permitir_filmar(True)
else:
#FIXME: Anular Grabación para cámara Remota:
self.video_out_setting.set_sensitive(False)
self.get_toplevel().toolbar.permitir_filmar(False)
self.__re_init_video_web_cam(device=device)
self.emit("cancel-toolbars")
def __re_init_video_web_cam(self, device=False, salida=False):
"""
Cuando se agregan o quitan efectos o se cambia la fuente de video,
se crea un nuevo objeto gstreamer que mantiene las configuraciones
realizadas hasta el momento.
"""
if PR:
print "__re_init_video_web_cam", device, salida
rot = 0
config = {}
if self.jamediawebcam:
rot = self.jamediawebcam.get_rotacion()
config = self.jamediawebcam.get_config()
efectos = self.efectos_en_pipe.get_efectos()
if not device:
device = self.camara_setting.device
if not salida:
salida = self.video_out_setting.formato
if self.jamediawebcam:
try:
self.jamediawebcam.disconnect_by_func(self.__update_record)
self.jamediawebcam.disconnect_by_func(self.__recibe_stop_rafaga)
self.jamediawebcam.disconnect_by_func(
self.__control_grabacion_end)
except:
pass
self.jamediawebcam.stop()
del(self.jamediawebcam)
self.jamediawebcam = False
time.sleep(3)
xid = self.pantalla.get_property('window').xid
self.jamediawebcam = JAMediaWebCamVideo(xid, device=device,
formato=salida, efectos=efectos)
self.jamediawebcam.connect("update", self.__update_record)
self.jamediawebcam.connect("stop-rafaga", self.__recibe_stop_rafaga)
self.jamediawebcam.connect("endfile", self.__control_grabacion_end)
self.jamediawebcam.play()
self.__re_config(rot, config, efectos)
def __re_config(self, rot, config, efectos):
if PR:
print "__re_config", rot, config, efectos
self.jamediawebcam.set_balance(
brillo=config.get("brillo", False),
contraste=config.get("contraste", False),
saturacion=config.get("saturacion", False),
hue=config.get("hue", False),
gamma=config.get("gamma", False))
if rot:
self.jamediawebcam.set_rotacion(rot)
for efecto in efectos:
self.widget_efectos.reemit_config_efecto(efecto)
self.__update_balance_toolbars(config)
return False
def __update_record(self, widget, info):
self.info_label.show()
self.info_label.set_text(info)
def __re_sensitive(self):
self.get_toplevel().toolbar.set_sensitive(True)
return False
def update_accions(self, accion, uri):
"""
Cuando se quita un archivo de su lugar a través de la lista,
se detienen los reproductores y se quita la tarea de ese
archivo en el conversor.
"""
if accion in ["Quitar", "Borrar", "Mover"]:
if self.player:
self.player.stop()
if self.imageplayer:
self.imageplayer.stop()
self.jamediaconvert.quitar(uri)
def mode_change(self, tipo):
"""
Cambia el modo de la aplicación.
"""
if PR:
print "Mode_Change:", tipo
self.get_toplevel().toolbar.set_sensitive(False)
self.jamediaconvert.reset()
self.jamediaconvert.hide()
self.pantalla.show()
if self.jamediawebcam:
try:
self.jamediawebcam.disconnect_by_func(self.__update_record)
self.jamediawebcam.disconnect_by_func(
self.__recibe_stop_rafaga)
self.jamediawebcam.disconnect_by_func(
self.__control_grabacion_end)
except:
pass
self.jamediawebcam.stop()
del(self.jamediawebcam)
self.jamediawebcam = False
if self.player:
try:
self.player.disconnect_by_func(self.__endfile)
self.player.disconnect_by_func(self.__cambioestadoreproductor)
self.player.disconnect_by_func(self.__update_progress)
#self.player.disconnect_by_func(self.__set_video)
except:
pass
self.player.stop()
del(self.player)
self.player = False
if self.imageplayer:
self.imageplayer.stop()
del(self.imageplayer)
self.imageplayer = False
if self.widget_efectos:
self.widget_efectos.clear()
self.info_label.set_text("")
self.info_label.hide()
self.efectos_en_pipe.clear()
self.playerlist.limpiar()
self.progressplayer.hide()
if tipo == "menu":
#self.__camara_menu_run()
pass
elif tipo == "video":
self.__camara_video_run()
elif tipo == "foto":
self.__camara_foto_run()
elif tipo == "jamedia":
self.__jamedia_run()
elif tipo == "jamediaimagenes":
self.__jamediaimagenes_run()
elif tipo == "converter":
self.__jamediaconvert_run()
else:
print "BasePanel Nuevo Modo:", tipo
gobject.timeout_add(1000, self.__re_sensitive)
def set_accion(self, modo, accion):
"""
Le pasa a la camara las ordenes seleccionadas por el
usuario en la toolbar correspondiente de la aplicacion.
"""
self.emit("cancel-toolbars")
if accion == "Izquierda" or accion == "Derecha":
if self.jamediawebcam:
self.jamediawebcam.rotar(accion)
elif self.player:
self.player.rotar(accion)
elif self.imageplayer:
self.imageplayer.rotar(accion)
else:
print "Accion sin definir:", self.set_accion, modo, accion
elif accion == "Stop":
if modo == "video":
self.get_toplevel().toolbar.set_sensitive(False)
self.__re_init_video_web_cam()
self.info_label.set_text("")
self.info_label.hide()
gobject.timeout_add(1000, self.__re_sensitive)
elif modo == "foto":
self.get_toplevel().toolbar.set_sensitive(False)
self.__re_init_video_web_cam()
self.info_label.set_text("")
self.info_label.hide()
gobject.timeout_add(300, self.__re_sensitive)
elif modo == "jamediaconverter":
self.jamediaconvert.tareas_pendientes = []
# FIXME: Considerar detener la conversíon en progreso
else:
print "Accion sin definir:", self.set_accion, modo, accion
elif accion == "Filmar": # and modo == "video":
self.get_toplevel().toolbar.set_sensitive(False)
hora = time.strftime("%H-%M-%S")
fecha = str(datetime.date.today())
archivo = "JV_%s_%s" % (fecha, hora)
archivo = os.path.join(get_video_directory(), archivo)
self.jamediawebcam.filmar(archivo)
gobject.timeout_add(1000, self.__re_sensitive)
elif accion == "Fotografiar":
self.get_toplevel().toolbar.set_sensitive(False)
rafaga = self.rafagas_setting.get_rafaga()
self.jamediawebcam.fotografiar(get_imagenes_directory(), rafaga)
gobject.timeout_add(300, self.__re_sensitive)
# FIXME: Desactivadas por ahora
#elif accion == "Centrar" or accion == "Acercar" or accion == "Alejar":
# self.imageplayer.set_zoom(accion)
else:
print "Accion sin definir:", self.set_accion, modo, accion
def config_show(self, tipo):
"""
Muestra u oculta los widgets de configuración.
"""
if tipo:
if self.box_config.get_visible():
self.box_config.hide()
else:
self.box_config.show()
else:
self.box_config.hide()
return
video_widgets = [
self.camara_setting,
self.video_out_setting,
self.balance_config_widget,
self.widget_efectos]
foto_widgets = [
self.camara_setting,
#self.video_out_setting,
self.rafagas_setting,
self.balance_config_widget,
self.widget_efectos]
jamedia_widgets = [
#self.camara_setting,
#self.video_out_setting,
#self.rafagas_setting,
#self.balance_config_widget,
#self.widget_efectos,
self.playerlist,
self.player_control]
jamediaimagenes_widgets = [
#self.camara_setting,
#self.video_out_setting,
#self.rafagas_setting,
#self.balance_config_widget,
#self.widget_efectos,
self.playerlist,
#self.player_control,
]
map(ocultar, video_widgets)
map(ocultar, foto_widgets)
map(ocultar, jamedia_widgets)
map(ocultar, jamediaimagenes_widgets)
if tipo == "camara":
map(mostrar, video_widgets)
self.camara_setting.label_ip.set_text(get_ip())
elif tipo == "foto":
map(mostrar, foto_widgets)
self.camara_setting.label_ip.set_text(get_ip())
elif tipo == "jamedia":
map(mostrar, jamedia_widgets)
elif tipo == "jamediaimagenes":
map(mostrar, jamediaimagenes_widgets)
else:
print self.config_show, "Falta definir:", tipo
if self.jamediawebcam:
self.__update_balance_toolbars(self.jamediawebcam.get_config())
self.emit("cancel-toolbars")
def pack_efectos(self):
"""
Empaqueta los widgets de efectos gstreamer.
"""
self.widget_efectos = WidgetsGstreamerVideoEfectos()
self.vbox_config.pack_start(self.widget_efectos, False, False, 0)
gobject.idle_add(self.__cargar_efectos,
list(get_jamedia_video_efectos()))
self.widget_efectos.connect("click_efecto", self.__set_efecto)
self.widget_efectos.connect("configurar_efecto", self.__set_efecto)
def salir(self):
if self.jamediawebcam:
try:
self.jamediawebcam.disconnect_by_func(self.__update_record)
self.jamediawebcam.disconnect_by_func(
self.__recibe_stop_rafaga)
self.jamediawebcam.disconnect_by_func(
self.__control_grabacion_end)
except:
pass
self.jamediawebcam.stop()
del(self.jamediawebcam)
self.jamediawebcam = False
if self.player:
try:
self.player.disconnect_by_func(self.__endfile)
self.player.disconnect_by_func(self.__cambioestadoreproductor)
self.player.disconnect_by_func(self.__update_progress)
#self.player.disconnect_by_func(self.__set_video)
except:
pass
self.player.stop()
del(self.player)
self.player = False
if self.imageplayer:
self.imageplayer.stop()
del(self.imageplayer)
self.imageplayer = False
self.jamediaconvert.reset()
class JAMediaPlayer(Gtk.EventBox):
"""
JAMedia:
Interfaz grafica de:
JAMediaReproductor y MplayerReproductor.
Implementado sobre:
python 2.7.3 y Gtk 3
"""
__gsignals__ = {"salir": (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, [])}
def __init__(self):
Gtk.EventBox.__init__(self)
self.modify_bg(0, get_colors("window"))
self.pantalla = None
self.barradeprogreso = None
self.volumen = None
self.lista_de_reproduccion = None
self.controlesrepro = None
self.toolbar = None
self.toolbar_list = None
self.toolbar_config = None
self.widget_efectos = None
self.toolbar_accion = None
self.toolbar_grabar = None
self.toolbar_info = None
self.toolbaraddstream = None
self.toolbar_salir = None
self.derecha_vbox = None
self.hbox_efectos_en_pipe = None
self.vbox_config = None
self.scroll_config = None
# FIXME: solo mantiene el gris de fondo
self.evnt_box_lista_reproduccion = None
self.scroll_list = None
self.controles_dinamicos = None
self.mplayerreproductor = None
self.jamediareproductor = None
self.mplayergrabador = None
self.jamediagrabador = None
self.player = None
self.grabador = None
self.cursor_root = None
self.jamedia_cursor = None
self.mouse_in_visor = False
self.show_all()
def setup_init(self):
"""
Se crea la interfaz grafica,
se setea y se empaqueta todo.
"""
self.get_toplevel().set_sensitive(False)
#from Globales import get_color
from Widgets import Visor
from Widgets import BarraProgreso
from Widgets import ControlVolumen
from PlayerList import Lista
from PlayerControls import PlayerControl
from GstreamerWidgets.Widgets import WidgetsGstreamerEfectos
from Toolbars import ToolbarSalir
from Toolbars import Toolbar
from Toolbars import ToolbarAccion
from Toolbars import ToolbarConfig
from Toolbars import ToolbarGrabar
from Toolbars import ToolbarInfo
from Toolbars import ToolbarAddStream
self.pantalla = Visor()
self.barradeprogreso = BarraProgreso()
self.volumen = ControlVolumen()
self.lista_de_reproduccion = Lista()
self.controlesrepro = PlayerControl()
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.Box(orientation=Gtk.Orientation.VERTICAL)
hpanel = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
hpanel.modify_bg(0, get_colors("window"))
eventbox = Gtk.EventBox() # FIXME: Para poder pintar el fondo
eventbox.modify_bg(0, get_colors("barradeprogreso"))
eventbox.add(self.toolbar)
basebox.pack_start(eventbox, False, False, 3)
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.
eventbox = Gtk.EventBox() # FIXME: Para poder pintar el fondo
eventbox.modify_bg(0, get_colors("drawingplayer"))
self.hbox_efectos_en_pipe = Gtk.Box(
orientation=Gtk.Orientation.HORIZONTAL)
self.hbox_efectos_en_pipe.set_size_request(-1, 24)
eventbox.add(self.hbox_efectos_en_pipe)
scroll = Gtk.ScrolledWindow()
scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER)
scroll.add_with_viewport(eventbox)
# Barra de Progreso + Volúmen
ev_box = Gtk.EventBox() # FIXME: Para poder pintar el fondo
ev_box.modify_bg(0, get_colors("barradeprogreso"))
hbox_barra_progreso = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
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.Box(orientation=Gtk.Orientation.VERTICAL)
vbox.pack_start(self.toolbar_grabar, False, False, 0)
vbox.pack_start(self.pantalla, True, True, 0)
vbox.pack_start(scroll, False, False, 0)
eventbox = Gtk.EventBox() # FIXME: Para poder pintar el fondo
eventbox.modify_bg(0, get_colors("barradeprogreso"))
eventbox.add(self.toolbar_info)
vbox.pack_start(eventbox, False, False, 3)
vbox.pack_start(ev_box, False, True, 0)
hpanel.pack1(vbox, resize=True, shrink=True)
# Area Derecha del Panel
self.derecha_vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
# Configuración de balanace y efectos
self.vbox_config = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.scroll_config = Gtk.ScrolledWindow()
self.scroll_config.set_policy(Gtk.PolicyType.NEVER,
Gtk.PolicyType.AUTOMATIC)
self.scroll_config.add_with_viewport(self.vbox_config)
self.scroll_config.get_child().modify_bg(0, get_colors("window"))
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.evnt_box_lista_reproduccion.modify_bg(
0, get_colors("barradeprogreso"))
self.vbox_lista_reproduccion = Gtk.Box(
orientation=Gtk.Orientation.VERTICAL)
self.scroll_list = Gtk.ScrolledWindow()
self.scroll_list.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.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)
from gi.repository import GdkX11
xid = self.pantalla.get_property('window').get_xid()
# HACK: La aplicación nunca debe explotar :P
if get_programa("mplayer"):
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.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.
icono = os.path.join(BASE_PATH, "Iconos", "jamedia_cursor.svg")
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(icono, -1, 24)
self.jamedia_cursor = Gdk.Cursor.new_from_pixbuf(
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 Widgets 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 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 Globales import set_listas_default
set_listas_default()
from Toolbars 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.vbox_config.pack_start(self.widget_efectos, False, False, 0)
from GstreamerWidgets.VideoEfectos import get_jamedia_video_efectos
GLib.idle_add(self.__cargar_efectos, list(get_jamedia_video_efectos()))
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 False
if self.player:
self.player.stop()
if self.toolbar_list:
self.toolbar_list.label.set_text("")
self.lista_de_reproduccion.limpiar()
GLib.idle_add(self.lista_de_reproduccion.agregar_items, lista)
return False
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.
"""
self.__cancel_toolbars_flotantes()
self.toolbar_salir.run("JAMedia")
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)
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.get_selection(
).get_selected()
valor = model.get_value(iter, 2)
if self.player:
self.player.load(valor)
except:
pass
self.get_toplevel().set_sensitive(True)
def __hide_show_parent(self, widget):
"""
Controlador del mouse funcionará solo si
JAMedia es Visible.
"""
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(
) != Gdk.CursorType.BLANK_CURSOR:
self.get_parent_window().set_cursor(
Gdk.Cursor(Gdk.CursorType.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 estado == "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.
"""
if not self.player:
return
# 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.
"""
if not self.player:
return
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)
botonefecto.set_tamanio(16, 16)
archivo = os.path.join(BASE_PATH, "Iconos", 'configurar.svg')
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(archivo, 16, 16)
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()
# FIXME: Agregar control de conexión para evitar errores.
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 Globales import eliminar_streaming
from Globales import add_stream
if accion == "Borrar":
eliminar_streaming(url, lista)
print "Streaming Eliminado:", url
elif accion == "Copiar":
modelo, iter = self.lista_de_reproduccion.get_selection(
).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.get_selection(
).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 Globales 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.
"""
if not self.player:
return
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).
"""
if not self.player:
return
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)
GLib.idle_add(ventana.unfullscreen)
else:
ventana.set_border_width(0)
GLib.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()
GLib.idle_add(self.__update_balance_toolbars)
self.get_toplevel().set_sensitive(True)
'''
# 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
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
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.
"""
if not self.lista_de_reproduccion.get_model().get_iter_first():
return
self.get_toplevel().set_sensitive(False)
self.__cancel_toolbars_flotantes()
if senial == "atras":
self.lista_de_reproduccion.seleccionar_anterior()
elif senial == "siguiente":
self.lista_de_reproduccion.seleccionar_siguiente()
elif senial == "stop":
if self.player:
self.player.stop()
elif senial == "pausa-play":
if self.player:
self.player.pause_play()
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()
GLib.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
GLib.idle_add(self.__update_balance_toolbars)
def __update_balance_toolbars(self):
"""
Actualiza las toolbars de balance en video.
"""
if not self.player:
return False
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()
if self.player:
self.player.set_position(valor)
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 __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()
if self.player:
self.player.load(path)
if visible:
self.scroll_config.show()
self.get_toplevel().set_sensitive(True)
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:
self.grabador.stop()
if self.player:
self.player.stop()
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.get_selection().get_selected()
ultimopath = False
if model and iter:
valor = model.get_value(iter, 2)
if valor:
from Globales 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 Globales import get_data_directory
from Globales import get_my_files_directory
from Globales import get_tube_directory
from Globales import get_audio_directory
from Globales 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:
# HACK: Tv no funciona con JAMediaReproductor.
#if self.player == self.jamediareproductor:
# self.switch_reproductor(None, "MplayerReproductor")
archivo = os.path.join(get_data_directory(),
'JAMediaWebCams.JAMedia')
self.__seleccionar_lista_de_stream(archivo, "WebCams")
#self.toolbar_list.boton_agregar.show()
elif indice == 5:
self.__seleccionar_lista_de_archivos(get_my_files_directory(),
"Archivos")
elif indice == 6:
self.__seleccionar_lista_de_archivos(get_tube_directory(),
"JAM-Tube")
elif indice == 7:
self.__seleccionar_lista_de_archivos(get_audio_directory(),
"JAM-Audio")
elif indice == 8:
self.__seleccionar_lista_de_archivos(get_video_directory(),
"JAM-Video")
elif indice == 9:
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.FileChooserAction.OPEN,
mime=["audio/*", "video/*"],
title="Abrir Archivos.",
path=directorio,
filter=[])
selector.connect('archivos-seleccionados',
self.__cargar_directorio)
selector.run()
if selector:
selector.destroy()
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.
"""
if self.player:
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()
GLib.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.
"""
if self.player:
self.player.stop()
self.__cancel_toolbars_flotantes()
from Globales import get_streamings
items = get_streamings(archivo)
self.toolbar_list.label.set_text(titulo)
self.lista_de_reproduccion.limpiar()
GLib.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.get_model())
menu.connect('accion', self.__set_accion)
menu.popup(None, 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.
"""
if not self.player:
return
self.get_toplevel().set_sensitive(False)
self.__detener_grabacion()
tipo = "video"
if "TV" in self.toolbar_list.label.get_text() or \
"Tv" in self.toolbar_list.label.get_text():
tipo = "video"
else:
tipo = "audio"
import time
import datetime
hora = time.strftime("%H-%M-%S")
fecha = str(datetime.date.today())
from Globales import get_my_files_directory
archivo = "%s-%s" % (fecha, hora)
archivo = os.path.join(get_my_files_directory(), archivo)
if self.player == self.jamediareproductor:
self.grabador = JAMediaGrabador(uri, archivo, tipo)
elif self.player == self.mplayerreproductor:
self.grabador = MplayerGrabador(uri, archivo, tipo)
self.grabador.connect('update', self.__update_grabador)
self.grabador.connect('endfile', self.__detener_grabacion)
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
if self.player:
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 . . .
"""
# FIXME: La idea es iniciar visualizador de audio.
print "Video en la Fuente:", valor
class JAMediaPlayer(Gtk.EventBox):
"""
JAMedia:
Interfaz grafica de:
JAMediaReproductor y MplayerReproductor.
Implementado sobre:
python 2.7.3 y Gtk 3
"""
__gsignals__ = {
"salir": (GObject.SIGNAL_RUN_LAST,
GObject.TYPE_NONE, [])}
def __init__(self):
Gtk.EventBox.__init__(self)
self.modify_bg(0, get_colors("window"))
self.pantalla = None
self.barradeprogreso = None
self.volumen = None
self.lista_de_reproduccion = None
self.controlesrepro = None
self.toolbar = None
self.toolbar_list = None
self.toolbar_config = None
self.widget_efectos = None
self.toolbar_accion = None
self.toolbar_grabar = None
self.toolbar_info = None
self.toolbaraddstream = None
self.toolbar_salir = None
self.derecha_vbox = None
self.hbox_efectos_en_pipe = None
self.vbox_config = None
self.scroll_config = None
# FIXME: solo mantiene el gris de fondo
self.evnt_box_lista_reproduccion = None
self.scroll_list = None
self.controles_dinamicos = None
self.mplayerreproductor = None
self.jamediareproductor = None
self.mplayergrabador = None
self.jamediagrabador = None
self.player = None
self.grabador = None
self.cursor_root = None
self.jamedia_cursor = None
self.mouse_in_visor = False
self.show_all()
def setup_init(self):
"""
Se crea la interfaz grafica,
se setea y se empaqueta todo.
"""
self.get_toplevel().set_sensitive(False)
#from Globales import get_color
from Widgets import Visor
from Widgets import BarraProgreso
from Widgets import ControlVolumen
from PlayerList import Lista
from PlayerControls import PlayerControl
from GstreamerWidgets.Widgets import WidgetsGstreamerEfectos
from Toolbars import ToolbarSalir
from Toolbars import Toolbar
from Toolbars import ToolbarAccion
from Toolbars import ToolbarConfig
from Toolbars import ToolbarGrabar
from Toolbars import ToolbarInfo
from Toolbars import ToolbarAddStream
self.pantalla = Visor()
self.barradeprogreso = BarraProgreso()
self.volumen = ControlVolumen()
self.lista_de_reproduccion = Lista()
self.controlesrepro = PlayerControl()
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.Box(orientation=Gtk.Orientation.VERTICAL)
hpanel = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
hpanel.modify_bg(0, get_colors("window"))
eventbox = Gtk.EventBox() # FIXME: Para poder pintar el fondo
eventbox.modify_bg(0, get_colors("barradeprogreso"))
eventbox.add(self.toolbar)
basebox.pack_start(eventbox, False, False, 3)
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.
eventbox = Gtk.EventBox() # FIXME: Para poder pintar el fondo
eventbox.modify_bg(0, get_colors("drawingplayer"))
self.hbox_efectos_en_pipe = Gtk.Box(
orientation=Gtk.Orientation.HORIZONTAL)
self.hbox_efectos_en_pipe.set_size_request(-1, 24)
eventbox.add(self.hbox_efectos_en_pipe)
scroll = Gtk.ScrolledWindow()
scroll.set_policy(
Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.NEVER)
scroll.add_with_viewport(eventbox)
# Barra de Progreso + Volúmen
ev_box = Gtk.EventBox() # FIXME: Para poder pintar el fondo
ev_box.modify_bg(0, get_colors("barradeprogreso"))
hbox_barra_progreso = Gtk.Box(
orientation=Gtk.Orientation.HORIZONTAL)
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.Box(orientation=Gtk.Orientation.VERTICAL)
vbox.pack_start(self.toolbar_grabar, False, False, 0)
vbox.pack_start(self.pantalla, True, True, 0)
vbox.pack_start(scroll, False, False, 0)
eventbox = Gtk.EventBox() # FIXME: Para poder pintar el fondo
eventbox.modify_bg(0, get_colors("barradeprogreso"))
eventbox.add(self.toolbar_info)
vbox.pack_start(eventbox, False, False, 3)
vbox.pack_start(ev_box, False, True, 0)
hpanel.pack1(vbox, resize=True, shrink=True)
# Area Derecha del Panel
self.derecha_vbox = Gtk.Box(
orientation=Gtk.Orientation.VERTICAL)
# Configuración de balanace y efectos
self.vbox_config = Gtk.Box(
orientation=Gtk.Orientation.VERTICAL)
self.scroll_config = Gtk.ScrolledWindow()
self.scroll_config.set_policy(
Gtk.PolicyType.NEVER,
Gtk.PolicyType.AUTOMATIC)
self.scroll_config.add_with_viewport(self.vbox_config)
self.scroll_config.get_child().modify_bg(0, get_colors("window"))
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.evnt_box_lista_reproduccion.modify_bg(
0, get_colors("barradeprogreso"))
self.vbox_lista_reproduccion = Gtk.Box(
orientation=Gtk.Orientation.VERTICAL)
self.scroll_list = Gtk.ScrolledWindow()
self.scroll_list.set_policy(
Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.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)
from gi.repository import GdkX11
xid = self.pantalla.get_property('window').get_xid()
# HACK: La aplicación nunca debe explotar :P
if get_programa("mplayer"):
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.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.
icono = os.path.join(BASE_PATH,
"Iconos", "jamedia_cursor.svg")
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(icono,
-1, 24)
self.jamedia_cursor = Gdk.Cursor.new_from_pixbuf(
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 Widgets 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 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 Globales import set_listas_default
set_listas_default()
from Toolbars 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.vbox_config.pack_start(
self.widget_efectos, False, False, 0)
from GstreamerWidgets.VideoEfectos import get_jamedia_video_efectos
GLib.idle_add(self.__cargar_efectos,
list(get_jamedia_video_efectos()))
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 False
if self.player:
self.player.stop()
if self.toolbar_list:
self.toolbar_list.label.set_text("")
self.lista_de_reproduccion.limpiar()
GLib.idle_add(self.lista_de_reproduccion.agregar_items, lista)
return False
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.
"""
self.__cancel_toolbars_flotantes()
self.toolbar_salir.run("JAMedia")
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)
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.get_selection(
).get_selected()
valor = model.get_value(iter, 2)
if self.player:
self.player.load(valor)
except:
pass
self.get_toplevel().set_sensitive(True)
def __hide_show_parent(self, widget):
"""
Controlador del mouse funcionará solo si
JAMedia es Visible.
"""
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() != Gdk.CursorType.BLANK_CURSOR:
self.get_parent_window().set_cursor(
Gdk.Cursor(Gdk.CursorType.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 estado == "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.
"""
if not self.player:
return
# 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.
"""
if not self.player:
return
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)
botonefecto.set_tamanio(16, 16)
archivo = os.path.join(BASE_PATH,
"Iconos", 'configurar.svg')
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(
archivo, 16, 16)
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()
# FIXME: Agregar control de conexión para evitar errores.
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 Globales import eliminar_streaming
from Globales import add_stream
if accion == "Borrar":
eliminar_streaming(url, lista)
print "Streaming Eliminado:", url
elif accion == "Copiar":
modelo, iter = self.lista_de_reproduccion.get_selection().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.get_selection().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 Globales 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.
"""
if not self.player:
return
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).
"""
if not self.player:
return
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)
GLib.idle_add(ventana.unfullscreen)
else:
ventana.set_border_width(0)
GLib.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()
GLib.idle_add(self.__update_balance_toolbars)
self.get_toplevel().set_sensitive(True)
'''
# 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
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
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.
"""
if not self.lista_de_reproduccion.get_model().get_iter_first():
return
self.get_toplevel().set_sensitive(False)
self.__cancel_toolbars_flotantes()
if senial == "atras":
self.lista_de_reproduccion.seleccionar_anterior()
elif senial == "siguiente":
self.lista_de_reproduccion.seleccionar_siguiente()
elif senial == "stop":
if self.player:
self.player.stop()
elif senial == "pausa-play":
if self.player:
self.player.pause_play()
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()
GLib.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
GLib.idle_add(self.__update_balance_toolbars)
def __update_balance_toolbars(self):
"""
Actualiza las toolbars de balance en video.
"""
if not self.player:
return False
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()
if self.player:
self.player.set_position(valor)
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 __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()
if self.player:
self.player.load(path)
if visible:
self.scroll_config.show()
self.get_toplevel().set_sensitive(True)
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:
self.grabador.stop()
if self.player:
self.player.stop()
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.get_selection().get_selected()
ultimopath = False
if model and iter:
valor = model.get_value(iter, 2)
if valor:
from Globales 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 Globales import get_data_directory
from Globales import get_my_files_directory
from Globales import get_tube_directory
from Globales import get_audio_directory
from Globales 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:
# HACK: Tv no funciona con JAMediaReproductor.
#if self.player == self.jamediareproductor:
# self.switch_reproductor(None, "MplayerReproductor")
archivo = os.path.join(
get_data_directory(),
'JAMediaWebCams.JAMedia')
self.__seleccionar_lista_de_stream(archivo, "WebCams")
#self.toolbar_list.boton_agregar.show()
elif indice == 5:
self.__seleccionar_lista_de_archivos(
get_my_files_directory(),
"Archivos")
elif indice == 6:
self.__seleccionar_lista_de_archivos(
get_tube_directory(),
"JAM-Tube")
elif indice == 7:
self.__seleccionar_lista_de_archivos(
get_audio_directory(),
"JAM-Audio")
elif indice == 8:
self.__seleccionar_lista_de_archivos(
get_video_directory(),
"JAM-Video")
elif indice == 9:
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.FileChooserAction.OPEN,
mime=["audio/*", "video/*"],
title="Abrir Archivos.",
path=directorio,
filter=[])
selector.connect(
'archivos-seleccionados', self.__cargar_directorio)
selector.run()
if selector:
selector.destroy()
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.
"""
if self.player:
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()
GLib.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.
"""
if self.player:
self.player.stop()
self.__cancel_toolbars_flotantes()
from Globales import get_streamings
items = get_streamings(archivo)
self.toolbar_list.label.set_text(titulo)
self.lista_de_reproduccion.limpiar()
GLib.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.get_model())
menu.connect('accion', self.__set_accion)
menu.popup(None, 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.
"""
if not self.player:
return
self.get_toplevel().set_sensitive(False)
self.__detener_grabacion()
tipo = "video"
if "TV" in self.toolbar_list.label.get_text() or \
"Tv" in self.toolbar_list.label.get_text():
tipo = "video"
else:
tipo = "audio"
import time
import datetime
hora = time.strftime("%H-%M-%S")
fecha = str(datetime.date.today())
from Globales import get_my_files_directory
archivo = "%s-%s" % (fecha, hora)
archivo = os.path.join(get_my_files_directory(), archivo)
if self.player == self.jamediareproductor:
self.grabador = JAMediaGrabador(uri, archivo, tipo)
elif self.player == self.mplayerreproductor:
self.grabador = MplayerGrabador(uri, archivo, tipo)
self.grabador.connect('update', self.__update_grabador)
self.grabador.connect('endfile', self.__detener_grabacion)
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
if self.player:
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 . . .
"""
# FIXME: La idea es iniciar visualizador de audio.
print "Video en la Fuente:", valor
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)