def setup_init(self):
"""
Se crea la interfaz grafica,
se setea y se empaqueta todo.
"""
from Widgets import ToolbarVideo
# Widgets Base: - vbox - toolbars - panel
basebox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.toolbar_salir = ToolbarSalir()
self.toolbar = ToolbarVideo()
hpanel = Gtk.HPaned()
basebox.pack_start(self.toolbar_salir, False, True, 0)
basebox.pack_start(self.toolbar, False, True, 0)
basebox.pack_start(hpanel, True, True, 0)
self.add(basebox)
# Panel lado Izquierdo: vbox - pantalla - hbox_efectos_aplicados
vbox_izq_panel = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.pantalla = Visor()
eventbox = Gtk.EventBox()
eventbox.modify_bg(0, get_color("NEGRO"))
self.hbox_efectos_en_pipe = Gtk.Box(
orientation=Gtk.Orientation.HORIZONTAL)
self.hbox_efectos_en_pipe.set_size_request(-1, get_pixels(0.5))
scroll = Gtk.ScrolledWindow()
scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER)
scroll.add_with_viewport(eventbox)
eventbox.add(self.hbox_efectos_en_pipe)
vbox_izq_panel.pack_start(self.pantalla, True, True, 0)
vbox_izq_panel.pack_start(scroll, False, False, 0)
hpanel.pack1(vbox_izq_panel, resize=True, shrink=True)
# Panel lado Derecho: eventbox - vbox - scroll
# - balance_widget - widget_efectos
self.box_config = Gtk.EventBox()
self.box_config.set_size_request(get_pixels(5.0), -1)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.balance_widget = ToolbarBalanceConfig()
scroll = Gtk.ScrolledWindow()
scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
scroll.add_with_viewport(vbox)
self.box_config.add(scroll)
self.widget_efectos = WidgetsGstreamerEfectos()
vbox.pack_start(self.balance_widget, False, True, 0)
vbox.pack_start(self.widget_efectos, False, True, 0)
hpanel.pack2(self.box_config, resize=False, shrink=False)
self.show_all()
self.realize()
from gi.repository import GdkX11
xid = self.pantalla.get_property('window').get_xid()
self.jamediawebcam = JAMediaWebCam(xid)
self.controles_dinamicos = [
self.toolbar_salir,
self.box_config,
]
map(self.ocultar, self.controles_dinamicos)
self.jamediawebcam.connect('estado', self.set_estado)
self.pantalla.connect("button_press_event", self.clicks_en_pantalla)
self.toolbar.connect("rotar", self.set_rotacion)
self.toolbar.connect("accion", self.set_accion)
self.toolbar.connect('salir', self.confirmar_salir)
self.balance_widget.connect('valor', self.set_balance)
self.widget_efectos.connect("click_efecto", self.click_efecto)
self.widget_efectos.connect('configurar_efecto',
self.configurar_efecto)
self.toolbar_salir.connect('salir', self.emit_salir)
class JAMediaVideoWidget(Gtk.Plug):
"""
Plug - Interfaz para Webcam con grabación de audio y video.
"""
__gsignals__ = {"salir": (GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, [])}
def __init__(self):
"""
JAMediaVideoWidget: Gtk.Plug para embeber en otra aplicacion.
"""
Gtk.Plug.__init__(self, 0L)
self.toolbar_salir = None
self.toolbar = None
self.pantalla = None
self.balance_widget = None
self.controles_dinamicos = []
self.jamediawebcam = None
self.box_config = None
self.widget_efectos = None
self.hbox_efectos_en_pipe = None
self.show_all()
def setup_init(self):
"""
Se crea la interfaz grafica,
se setea y se empaqueta todo.
"""
from Widgets import ToolbarVideo
# Widgets Base: - vbox - toolbars - panel
basebox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.toolbar_salir = ToolbarSalir()
self.toolbar = ToolbarVideo()
hpanel = Gtk.HPaned()
basebox.pack_start(self.toolbar_salir, False, True, 0)
basebox.pack_start(self.toolbar, False, True, 0)
basebox.pack_start(hpanel, True, True, 0)
self.add(basebox)
# Panel lado Izquierdo: vbox - pantalla - hbox_efectos_aplicados
vbox_izq_panel = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.pantalla = Visor()
eventbox = Gtk.EventBox()
eventbox.modify_bg(0, get_color("NEGRO"))
self.hbox_efectos_en_pipe = Gtk.Box(
orientation=Gtk.Orientation.HORIZONTAL)
self.hbox_efectos_en_pipe.set_size_request(-1, get_pixels(0.5))
scroll = Gtk.ScrolledWindow()
scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER)
scroll.add_with_viewport(eventbox)
eventbox.add(self.hbox_efectos_en_pipe)
vbox_izq_panel.pack_start(self.pantalla, True, True, 0)
vbox_izq_panel.pack_start(scroll, False, False, 0)
hpanel.pack1(vbox_izq_panel, resize=True, shrink=True)
# Panel lado Derecho: eventbox - vbox - scroll
# - balance_widget - widget_efectos
self.box_config = Gtk.EventBox()
self.box_config.set_size_request(get_pixels(5.0), -1)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.balance_widget = ToolbarBalanceConfig()
scroll = Gtk.ScrolledWindow()
scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
scroll.add_with_viewport(vbox)
self.box_config.add(scroll)
self.widget_efectos = WidgetsGstreamerEfectos()
vbox.pack_start(self.balance_widget, False, True, 0)
vbox.pack_start(self.widget_efectos, False, True, 0)
hpanel.pack2(self.box_config, resize=False, shrink=False)
self.show_all()
self.realize()
from gi.repository import GdkX11
xid = self.pantalla.get_property('window').get_xid()
self.jamediawebcam = JAMediaWebCam(xid)
self.controles_dinamicos = [
self.toolbar_salir,
self.box_config,
]
map(self.ocultar, self.controles_dinamicos)
self.jamediawebcam.connect('estado', self.set_estado)
self.pantalla.connect("button_press_event", self.clicks_en_pantalla)
self.toolbar.connect("rotar", self.set_rotacion)
self.toolbar.connect("accion", self.set_accion)
self.toolbar.connect('salir', self.confirmar_salir)
self.balance_widget.connect('valor', self.set_balance)
self.widget_efectos.connect("click_efecto", self.click_efecto)
self.widget_efectos.connect('configurar_efecto',
self.configurar_efecto)
self.toolbar_salir.connect('salir', self.emit_salir)
def reset(self):
"""
Resetea la cámara quitando los efectos y
actualiza los widgets correspondientes.
"""
for efecto in self.hbox_efectos_en_pipe.get_children():
efecto.destroy()
for button in self.widget_efectos.gstreamer_efectos.get_children():
button.des_seleccionar()
self.jamediawebcam.reset()
def set_estado(self, widget, valor):
if valor == 'playing':
self.toolbar.set_estado("detenido")
GLib.idle_add(self.update_balance_toolbars)
elif valor == 'stoped':
self.toolbar.set_estado("detenido")
GLib.idle_add(self.update_balance_toolbars)
elif valor == 'GrabandoAudioVideo':
self.toolbar.set_estado("grabando")
GLib.idle_add(self.update_balance_toolbars)
# FIXME: Solo por JAMediaAudio - JAMediaAudioWidget. por ahora
elif valor == 'GrabandoAudio':
self.toolbar.set_estado("grabando")
GLib.idle_add(self.update_balance_toolbars)
# FIXME: Para JAMediaFotografiaWidget. Pero por ahora no se utiliza
elif valor == 'Fotografiando':
self.toolbar.set_estado("grabando")
GLib.idle_add(self.update_balance_toolbars)
else:
print "### Estado:", valor
def cargar_efectos(self, efectos):
"""
Agrega los widgets con efectos a la paleta de configuración.
"""
self.widget_efectos.cargar_efectos(efectos)
def configurar_efecto(self, widget, nombre_efecto, propiedad, valor):
"""
Configura un efecto en el pipe, si no está en eĺ, lo agrega.
"""
# Si el efecto no está agregado al pipe, lo agrega
if self.jamediawebcam.efectos:
if not nombre_efecto in self.jamediawebcam.efectos:
# HACK: si se agregan o quitan efectos mientras se graba,
# las grabaciones se reinician.
if self.jamediawebcam.estado == "GrabandoAudioVideo" or \
self.jamediawebcam.estado == "GrabandoAudio":
return
self.click_efecto(None, nombre_efecto)
self.widget_efectos.seleccionar_efecto(nombre_efecto)
else:
# HACK: si se agregan o quitan efectos mientras se graba,
# las grabaciones se reinician.
if self.jamediawebcam.estado == "GrabandoAudioVideo" or \
self.jamediawebcam.estado == "GrabandoAudio":
return
self.click_efecto(None, nombre_efecto)
self.widget_efectos.seleccionar_efecto(nombre_efecto)
# Setea el efecto
self.jamediawebcam.configurar_efecto(nombre_efecto, propiedad, valor)
def click_efecto(self, widget, nombre_efecto):
"""
Recibe el nombre del efecto sobre el que
se ha hecho click y decide si debe agregarse
al pipe de JAMediaWebcam.
"""
# HACK: si se agregan o quitan efectos mientras se graba,
# las grabaciones se reinician.
if self.jamediawebcam.estado == "GrabandoAudioVideo" or \
self.jamediawebcam.estado == "GrabandoAudio":
for efecto in self.hbox_efectos_en_pipe.get_children():
n_efecto = efecto.get_tooltip_text()
if n_efecto == nombre_efecto:
self.widget_efectos.seleccionar_efecto(nombre_efecto)
return
self.widget_efectos.des_seleccionar_efecto(nombre_efecto)
return
agregar = False
if self.jamediawebcam.efectos:
if not nombre_efecto in self.jamediawebcam.efectos:
# Si el efecto no está en el pipe.
agregar = True
else:
# Si no se han agregado efectos.
agregar = True
if agregar:
#if self.jamediawebcam.estado == "GrabandoAudioVideo":
# self.jamediawebcam.re_init()
# pass
from Widgets import WidgetEfecto_en_Pipe
self.jamediawebcam.agregar_efecto(nombre_efecto)
# Agrega un widget a self.hbox_efectos_en_pipe
botonefecto = WidgetEfecto_en_Pipe()
botonefecto.set_tooltip(nombre_efecto)
botonefecto.connect('clicked', self.clicked_mini_efecto)
lado = get_pixels(0.5)
botonefecto.set_tamanio(lado, lado)
archivo = os.path.join(JAMediaObjectsPath, "Iconos",
'configurar.svg')
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(
archivo, lado, lado)
botonefecto.imagen.set_from_pixbuf(pixbuf)
self.hbox_efectos_en_pipe.pack_start(botonefecto, False, False, 0)
else:
# Si el usuario hace click sobre el botón de un efecto
# que ya se encuentra en el pipe de la camara, se quita
# el efecto del pipe y se deselecciona el botón correspondiente.
#if self.jamediawebcam.estado == "GrabandoAudioVideo":
# self.jamediawebcam.re_init()
# pass
self.jamediawebcam.quitar_efecto(nombre_efecto)
self.widget_efectos.des_seleccionar_efecto(nombre_efecto)
# Quitar el widget de self.hbox_efectos_en_pipe
for efecto in self.hbox_efectos_en_pipe.get_children():
if efecto.get_tooltip_text() == nombre_efecto:
efecto.destroy()
break
def clicked_mini_efecto(self, widget, void=None):
"""
Cuando se hace click en el mini objeto en pantalla
para efecto agregado, este se quita del pipe de la cámara.
"""
# HACK: si se agregan o quitan efectos mientras se graba,
# las grabaciones se reinician.
if self.jamediawebcam.estado == "GrabandoAudioVideo" or \
self.jamediawebcam.estado == "GrabandoAudio":
return
nombre_efecto = widget.get_tooltip_text()
self.jamediawebcam.quitar_efecto(nombre_efecto)
self.widget_efectos.des_seleccionar_efecto(nombre_efecto)
widget.destroy()
def update_balance_toolbars(self):
"""
Actualiza las toolbars de balance en video.
"""
config = self.jamediawebcam.get_balance()
self.balance_widget.set_balance(brillo=config['brillo'],
contraste=config['contraste'],
saturacion=config['saturacion'],
hue=config['hue'],
gamma=config['gamma'])
def set_balance(self, widget, valor, tipo):
"""
Setea valores en Balance de Video.
valor es % float
"""
if tipo == "saturacion":
self.jamediawebcam.set_balance(saturacion=valor)
elif tipo == "contraste":
self.jamediawebcam.set_balance(contraste=valor)
elif tipo == "brillo":
self.jamediawebcam.set_balance(brillo=valor)
elif tipo == "hue":
self.jamediawebcam.set_balance(hue=valor)
elif tipo == "gamma":
self.jamediawebcam.set_balance(gamma=valor)
def set_rotacion(self, widget, valor):
"""
Recibe rotación y la pasa a la webcam.
"""
self.jamediawebcam.rotar(valor)
def set_accion(self, widget, senial):
"""
Cuando se hace click en filmar o
en configurar filmacion.
"""
if senial == 'filmar':
if self.jamediawebcam.estado != "GrabandoAudioVideo":
self.jamediawebcam.grabar()
else:
self.jamediawebcam.stop_grabar()
elif senial == 'configurar':
if self.box_config.get_visible():
self.box_config.hide()
else:
self.box_config.show()
GLib.idle_add(self.update_balance_toolbars)
elif senial == 'Reset':
self.reset()
def play(self):
"""
Comienza a correr la aplicación.
"""
GLib.idle_add(self.jamediawebcam.reset)
def ocultar(self, objeto):
if objeto.get_visible():
objeto.hide()
def mostrar(self, objeto):
if not objeto.get_visible():
objeto.show()
def clicks_en_pantalla(self, widget, event):
"""
Hace fullscreen y unfullscreen sobre la
ventana principal cuando el usuario hace
doble click en el visor.
"""
if event.type.value_name == "GDK_2BUTTON_PRESS":
ventana = self.get_toplevel()
screen = ventana.get_screen()
w, h = ventana.get_size()
ww, hh = (screen.get_width(), screen.get_height())
if ww == w and hh == h:
ventana.unfullscreen()
else:
ventana.fullscreen()
def confirmar_salir(self, widget=None, senial=None):
"""
Recibe salir y lo pasa a la toolbar de confirmación.
"""
self.toolbar_salir.run("Menú Video.")
def emit_salir(self, widget):
"""
Emite salir para que cuando esta embebida, la
aplicacion decida que hacer, si salir, o cerrar solo
la aplicacion embebida.
"""
self.reset()
self.jamediawebcam.stop()
# FIXME: emitir la señal directamente se ve mejor,
# pero aveces falla la cámara, la segunda opcion
# evita esto, pero no se ve bien.
GLib.idle_add(self.emit, 'salir') # self.emit('salir')
class JAMediaAudioWidget(JAMediaVideoWidget):
"""
Plug - Interfaz para Webcam con grabación de audio.
"""
def __init__(self):
"""
JAMediaAudioWidget: Gtk.Plug para embeber en otra aplicacion.
"""
JAMediaVideoWidget.__init__(self)
self.toolbar_salir = None
self.toolbar = None
self.pantalla = None
self.balance_widget = None
self.controles_dinamicos = []
self.jamediawebcam = None
self.box_config = None
self.widget_efectos = None
self.widget_visualizadores_de_audio = None
self.hbox_efectos_en_pipe = None
self.show_all()
def setup_init(self):
"""
Se crea la interfaz grafica,
se setea y se empaqueta todo.
"""
from JAMediaObjects.JAMediaWidgets import WidgetsGstreamerAudioVisualizador
from JAMediaObjects.JAMediaGstreamer.JAMediaAudio import JAMediaAudio
from Widgets import ToolbarGrabarAudio
# Widgets Base: - vbox - toolbars - panel
basebox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.toolbar_salir = ToolbarSalir()
self.toolbar = ToolbarGrabarAudio()
hpanel = Gtk.HPaned()
basebox.pack_start(self.toolbar_salir, False, True, 0)
basebox.pack_start(self.toolbar, False, True, 0)
basebox.pack_start(hpanel, True, True, 0)
self.add(basebox)
# Panel lado Izquierdo: vbox - pantalla - hbox_efectos_aplicados
vbox_izq_panel = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.pantalla = Visor()
eventbox = Gtk.EventBox()
eventbox.modify_bg(0, get_color("NEGRO"))
self.hbox_efectos_en_pipe = Gtk.Box(
orientation=Gtk.Orientation.HORIZONTAL)
self.hbox_efectos_en_pipe.set_size_request(-1, get_pixels(0.5))
scroll = Gtk.ScrolledWindow()
scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER)
scroll.add_with_viewport(eventbox)
eventbox.add(self.hbox_efectos_en_pipe)
vbox_izq_panel.pack_start(self.pantalla, True, True, 0)
vbox_izq_panel.pack_start(scroll, False, False, 0)
hpanel.pack1(vbox_izq_panel, resize=True, shrink=True)
# Panel lado Derecho: eventbox - vbox - scroll
# - balance_widget - widget_efectos
self.box_config = Gtk.EventBox()
self.box_config.set_size_request(get_pixels(5.0), -1)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.widget_visualizadores_de_audio = WidgetsGstreamerAudioVisualizador(
)
scroll = Gtk.ScrolledWindow()
scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER)
scroll.add_with_viewport(self.widget_visualizadores_de_audio)
self.balance_widget = ToolbarBalanceConfig()
vbox.pack_start(self.balance_widget, False, True, 0)
vbox.pack_start(scroll, False, True, 0)
scroll = Gtk.ScrolledWindow()
scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
scroll.add_with_viewport(vbox)
self.box_config.add(scroll)
self.widget_efectos = WidgetsGstreamerEfectos()
vbox.pack_start(self.widget_efectos, False, True, 0)
hpanel.pack2(self.box_config, resize=False, shrink=False)
self.show_all()
self.realize()
from gi.repository import GdkX11
xid = self.pantalla.get_property('window').get_xid()
self.jamediawebcam = JAMediaAudio(xid)
self.controles_dinamicos = [
self.toolbar_salir,
self.box_config,
]
map(self.ocultar, self.controles_dinamicos)
self.jamediawebcam.connect('estado', self.set_estado)
self.pantalla.connect("button_press_event", self.clicks_en_pantalla)
self.toolbar.connect("rotar", self.set_rotacion)
self.toolbar.connect("accion", self.set_accion)
self.toolbar.connect('salir', self.confirmar_salir)
self.balance_widget.connect('valor', self.set_balance)
self.widget_efectos.connect("click_efecto", self.click_efecto)
self.widget_efectos.connect('configurar_efecto',
self.configurar_efecto)
self.widget_visualizadores_de_audio.connect("click_efecto",
self.click_visualizador)
#self.widget_visualizadores_de_audio.connect(
# 'configurar_efecto', self.configurar_visualizador)
self.toolbar_salir.connect('salir', self.emit_salir)
def set_accion(self, widget, senial):
"""
Cuando se hace click en grabar o
en configurar.
"""
if senial == 'grabar':
if self.jamediawebcam.estado != "GrabandoAudio":
self.jamediawebcam.grabar()
else:
self.jamediawebcam.stop_grabar()
elif senial == 'configurar':
if self.box_config.get_visible():
self.box_config.hide()
else:
self.box_config.show()
GLib.idle_add(self.update_balance_toolbars)
elif senial == 'Reset':
self.reset()
def cargar_visualizadores(self, efectos):
"""
Agrega los widgets con efectos a la paleta de configuración.
"""
self.widget_visualizadores_de_audio.cargar_efectos(efectos)
#def configurar_visualizador(self, widget, nombre_efecto, propiedad, valor):
# """Configura un efecto en el pipe, si no está en eĺ, lo agrega."""
# self.jamediawebcam.configurar_visualizador(nombre_efecto, propiedad, valor)
def click_visualizador(self, widget, nombre_efecto):
if self.jamediawebcam.estado != "GrabandoAudio":
self.jamediawebcam.set_visualizador(nombre_efecto)
# FIXME: Agregar seleccionar visualizador actual
def confirmar_salir(self, widget=None, senial=None):
"""
Recibe salir y lo pasa a la toolbar de confirmación.
"""
self.toolbar_salir.run("Menú Audio.")
class JAMediaFotografiaWidget(JAMediaVideoWidget):
"""
Plug - Interfaz para Webcam con cámara fotográfica.
"""
def __init__(self):
JAMediaVideoWidget.__init__(self)
def setup_init(self):
"""
Se crea la interfaz grafica,
se setea y se empaqueta todo.
"""
from Widgets import ToolbarFotografia
from Widgets import ToolbarRafagas
# Widgets Base: - vbox - toolbars - panel
basebox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.toolbar_salir = ToolbarSalir()
self.toolbar = ToolbarFotografia()
hpanel = Gtk.HPaned()
basebox.pack_start(self.toolbar_salir, False, True, 0)
basebox.pack_start(self.toolbar, False, True, 0)
basebox.pack_start(hpanel, True, True, 0)
self.add(basebox)
# Panel lado Izquierdo: vbox - pantalla - hbox_efectos_aplicados
vbox_izq_panel = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.pantalla = Visor()
eventbox = Gtk.EventBox()
eventbox.modify_bg(0, get_color("NEGRO"))
self.hbox_efectos_en_pipe = Gtk.Box(
orientation=Gtk.Orientation.HORIZONTAL)
self.hbox_efectos_en_pipe.set_size_request(-1, get_pixels(0.5))
scroll = Gtk.ScrolledWindow()
scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER)
scroll.add_with_viewport(eventbox)
eventbox.add(self.hbox_efectos_en_pipe)
vbox_izq_panel.pack_start(self.pantalla, True, True, 0)
vbox_izq_panel.pack_start(scroll, False, False, 0)
hpanel.pack1(vbox_izq_panel, resize=True, shrink=True)
# Panel lado Derecho: eventbox - vbox - scroll
# - balance_widget - widget_efectos
self.box_config = Gtk.EventBox()
self.box_config.set_size_request(get_pixels(5.0), -1)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.balance_widget = ToolbarBalanceConfig()
scroll = Gtk.ScrolledWindow()
scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
scroll.add_with_viewport(vbox)
self.box_config.add(scroll)
self.widget_efectos = WidgetsGstreamerEfectos()
self.toolbar_rafagas = ToolbarRafagas()
vbox.pack_start(self.balance_widget, False, True, 0)
vbox.pack_start(self.toolbar_rafagas, False, True, 0)
vbox.pack_start(self.widget_efectos, False, True, 0)
hpanel.pack2(self.box_config, resize=False, shrink=False)
self.show_all()
self.realize()
from gi.repository import GdkX11
xid = self.pantalla.get_property('window').get_xid()
self.jamediawebcam = JAMediaWebCam(xid)
self.controles_dinamicos = [
self.toolbar_salir,
self.box_config,
]
map(self.ocultar, self.controles_dinamicos)
self.jamediawebcam.connect('estado', self.set_estado)
self.pantalla.connect("button_press_event", self.clicks_en_pantalla)
self.toolbar.connect("rotar", self.set_rotacion)
self.toolbar.connect("accion", self.set_accion)
self.toolbar.connect('salir', self.confirmar_salir)
self.balance_widget.connect('valor', self.set_balance)
self.widget_efectos.connect("click_efecto", self.click_efecto)
self.widget_efectos.connect('configurar_efecto',
self.configurar_efecto)
self.toolbar_rafagas.connect('run_rafaga', self.set_rafaga)
self.toolbar_salir.connect('salir', self.emit_salir)
def set_rafaga(self, widget, valor):
"""
Cuando se hace click en play de la toolbar
de ráfagas se setea y comienza a fotografiar.
"""
self.jamediawebcam.set_rafaga(valor)
def set_accion(self, widget, senial):
"""
Cuando se hace click en fotografiar o
en configurar filmacion.
"""
if senial == 'fotografiar':
if self.jamediawebcam.estado != "Fotografiando":
self.jamediawebcam.fotografiar()
else:
# Solo puede estar en estado Fotografiando
# si hay ráfagas en proceso.
self.jamediawebcam.stop_rafagas()
elif senial == 'configurar':
if self.box_config.get_visible():
self.box_config.hide()
else:
self.box_config.show()
GLib.idle_add(self.update_balance_toolbars)
elif senial == 'Reset':
self.reset()
def confirmar_salir(self, widget=None, senial=None):
"""
Recibe salir y lo pasa a la toolbar de confirmación.
"""
self.toolbar_salir.run("Menú Fotografía.")