"""

CLASE PRINCIPAL, POSIBLEMENTE DEBE DESGLOBARSE EN DISTINTAS CLASES (REVEER ESTO)

"""

####################################################################################################################################################################

#VARIABLES DE INSTANCIA Y PEQUEÑA DESCRIPCION: #

#self.directorioContenidoLibre: path del directorio donde se encuentra el contenido libre #

#self.directorioProy: path del directorio raiz del proyecto #

#self.dispositivoSeleccionado: representa al dispositivo (usb, cd, dvd o etc) seleccionado con todas sus caracteristicas. Es de tipo Dispositivo #

#self.manejadorDispositivo: es de tipo base ManejadorDispositivo y tiene metodos para saber que dispositivos hay (de su tipo) y para grabar en un dipositivo #

#self.timerDispositivo: es el encargado de cada X tiempo llamar a un metodo para actualizar los dispositivos disponibles #

#self.timerPresentacion: es el encargado de cada X tiempo llamar a un metodo para actualizar la imagen que se muestra en la presentacion en el panel de grabacion #

#self.timerBarraDeProgreso: es el encargado de cada X tiempo llamar a un metodo para actuailzar la barra de progreso que muestra el porcentaje grabado #

#self.presentacion: es una lista de QPixmap con todas las imagenes para la presentacion a mostrar en el panel de grabacion #

#self.presentacionImagenActual: es un entero entre 0 y len(self.presentacion)-1, que guarda la imagen que se esta mostrando actualmente en la presentacion #

#self.app: variable necesaria para refrescar las animaciones en el panel de grabacion (en el metodo mostrarPanelGrabacion) #

# #

#A continuacion nombro los paneles, los cuales tienen, todos, tanto una clase como un widget. #

#El widget es el panel en si, la clase es donde se encuentran todos los componentes del panel (ver los metodos de configuracion de panel) #

#self.panelIzquierdo: donde se muestra en que panel se esta #

#self.panelIzquierdoWidget #

#(no pongo mas los widget, pero estan de todos y tienen sintaxis semejante) #

#self.panelBienvenido: muestra una pantall de bienvenida con una descripcion de que hace el programa, etc. #

#self.panelDispositivos: muestra opciones para seleccionar el dispositivo en el que grabar el contenido (pendrive, cd/dvd, etc) #

#self.panelContenidos: muestra todo el contenido para poder seleccionar el que se quiere grabar (musica, peliculas, software, etc) #

#self.panelVerificacion: muestra el dispositivo y los datos seleccionados, y botones para volver atras y cambiarlos o para grabar #

#self.panelGrabacion: panel donde se graba el contenido elegido en el dispositivo seleccionado mientras su progreso y una presentacion con informacion variada #

#self.paletaPanelActivo: representa la paleta (colores) para el "boton" o "label" del panel izquierdo cuando el panel al que representa es el que se muestra #

#self.paletaPanelNoActivo: representa la paleta (colores) para el "boton" o "label" del panel izquierdo cuando el panel al que representa no es el que se muestra #

#self.paletaLabel: representa la paleta (colores) para los labels dentro de los frames en el panel izquierdo. Se utiliza para que su letra sea negra y no marron #

####################################################################################################################################################################

def __init__(self, app, parent = None):

QMainWindow.__init__(self, parent)

#Se necesita para refrescar los paneles en el metodo mostrarPanelGrabacion

self.app=app

#Variables para el directorio donde se guarda todo el contenido libre y para el directorio del proyecto

self.directorioContenidoLibre=os.getcwd()+'/Contenido-Libre'

self.directorioProy=os.getcwd()

#Inicializacion de la Ventana principal, que es donde se colocan los demas paneles

#(sobre esta solo van los paneles y una linea que separa el panel izquierdo de los demas)

self.UiVentanaPrincipal=Ui_MainWindow()

self.UiVentanaPrincipal.setupUi(self)

#Inicializo y configuro todos los paneles:

self.configurarPanelIzquierdo()

#Creo una linea para separar el panelIzquierdo de los demas

self.line = QtGui.QFrame()

self.line.setFrameShape(QtGui.QFrame.VLine)

self.line.setFrameShadow(QtGui.QFrame.Sunken)

self.line.setObjectName("line")

self.UiVentanaPrincipal.horizontalLayout.addWidget(self.line)

self.configurarPanelBienvenido()

self.configurarPanelDispositivos()

self.configurarPanelContenidos()

self.configurarPanelVerificacion()

self.configurarPanelGrabacion()

#Dejo solo el panel de bienvenida en la parte derecha de la pantalla (ocultando los demas salvo el Izquierdo)

self.mostrarPanelBienvenido()

#Conecto los botones con sus funciones respectivas (slots)

QtCore.QMetaObject.connectSlotsByName(self)

#Metodo usado por configurarPanelContenidos

#Dado el path de un directorio y un nodo QTreeWidgetItem (de un arbol) crea los nodos de todos sus archivos y subdirectorios recursivamente

def recorrerDirectorioCreandoQTreeWidgetItems(self, dirDirectorio, itemDirectorio):

size=0

for nombreArchivo in os.listdir(dirDirectorio):

itemArchivo=self.crearQTreeWidgetItemModificado(itemDirectorio, dirDirectorio+'/'+nombreArchivo)

if os.path.isdir(dirDirectorio+'/'+nombreArchivo):

self.recorrerDirectorioCreandoQTreeWidgetItems(dirDirectorio+'/'+nombreArchivo, itemArchivo)

size=size+itemArchivo.getTamanioBytes()

if os.path.isdir(dirDirectorio):

itemDirectorio.setTamanioBytes(size)

sizeUnidad=Aux.convertirTamanio(itemDirectorio.getTamanioBytes())

itemDirectorio.setText(0, os.path.basename(dirDirectorio)+' ('+str(sizeUnidad[0])+' '+sizeUnidad[1]+')')

#Metodo usado po configurarPanelContenidos y recorrerDirectorioCreandoQTreeWidgetItems

#Dado un QTreeWidgetItemModificado (o un QTreeWidget en el caso de los elementos del arbol que no tienen padre) y el path del archivo/directorio

#crea un QTreeWidgetItemModificado (que extiende a QTreeWidgetItem agregando el path y el tamaño en bytes del archivo o directorio (ver QTreeWidgetItemModificado))

def crearQTreeWidgetItemModificado(self, itemPadre, direccion):

size=os.path.getsize(direccion)

item = QTreeWidgetItemModificado(itemPadre, direccion, size)

item.setCheckState(0, QtCore.Qt.Unchecked)

item.setFlags(QtCore.Qt.ItemIsSelectable|QtCore.Qt.ItemIsEditable|QtCore.Qt.ItemIsDragEnabled|QtCore.Qt.ItemIsDropEnabled|QtCore.Qt.ItemIsUserCheckable|QtCore.Qt.ItemIsEnabled|QtCore.Qt.ItemIsTristate)

#le pongo como nombre del item: "nombre del archivo" ("tamaño" "unidad") ej: Fito (150 MiB)

sizeUnidad=Aux.convertirTamanio(item.getTamanioBytes())

item.setText(0, QtGui.QApplication.translate("MainWindow", os.path.basename(direccion)+' ('+str(sizeUnidad[0])+' '+sizeUnidad[1]+')', None, QtGui.QApplication.UnicodeUTF8))

return item

#actualiza los dispositivos y los botones con la informacion adecuada

def actualizarDispositivos(self):

#creo variables para cada dispositivo asi los actualizo

usb=Usb()

cd=CdRom()

usbDev = usb.hayDispositivos()

if usbDev: #si hay algun usb

path=usbDev.getPath()

nombreUsb=path[path.rfind("/")+1:]

self.panelDispositivos.pendriveRadio.setText("Pendrive insertado: "+nombreUsb+"\nespacio libre: "+(str(Aux.convertirTamanio(usbDev.getLibre()))))

self.panelDispositivos.pendriveRadio.setEnabled(True)

else:

self.panelDispositivos.pendriveRadio.setText("Insertar Pendrive")

self.panelDispositivos.pendriveRadio.setEnabled(False)

cdDev=cd.hayDispositivos()

if cdDev: #si hay algun cd/dvd

path=cdDev.getPath()

nombreCd=path

self.panelDispositivos.cdRadio.setText(cdDev.getTipo()+" insertado: "+nombreCd+"\nespacio libre: "+(str(Aux.convertirTamanio(cdDev.getLibre()))))

self.panelDispositivos.cdRadio.setEnabled(True)

else:

self.panelDispositivos.cdRadio.setText("Insertar Cd/Dvd")

self.panelDispositivos.cdRadio.setEnabled(False)

#Este metodo se usa para devolver todas las direcciones de los archivos y directorios seleccionados para grabar

#(el path es relativo, ya que se le saca el self.directorioContenidoLibre)

#por ejemplo: musica/tema.mp3 (cuando el path completo seria algo asi: /home/.../Dispenser/contenido-libre/musica/tema.mp3)

def archivosYDirectoriosSeleccionados(self):

items=self.panelContenidos.treeWidget.findItems('', QtCore.Qt.MatchRecursive|QtCore.Qt.MatchContains) #items guarda todos los items del arbol

lista=[]

for item in items: #itero sobre todos los items del arbol

if (item.checkState(0)==2 or item.checkState(0)==1): #si el item esta marcado

lista.append(item.getDireccion().lstrip(self.directorioContenidoLibre))#por cada item agrego su direccion a la lista

return lista

#Este metodo se usa para devolver todas las direcciones de los archivos seleccionados para grabar

#(el path es relativo, ya que se le saca el self.directorioContenidoLibre)

#por ejemplo: musica/tema.mp3 (cuando el path completo seria algo asi: /home/.../Dispenser/contenido-libre/musica/tema.mp3)

def archivosSeleccionados(self):

items=self.panelContenidos.treeWidget.findItems('', QtCore.Qt.MatchRecursive|QtCore.Qt.MatchContains) #items guarda todos los items del arbol

lista=[]

for item in items: #itero sobre todos los items del arbol

if item.checkState(0)==2 and item.childCount()==0: #si el item esta marcado y es archivo (o sea que tiene 0 hijos)

lista.append("/"+item.getDireccion().lstrip(self.directorioProy))#por cada item agrego su direccion a la lista

return lista

def comprobarYMostrarDatos(self):

if self.dispositivoSeleccionado:

nombreDispositivo=self.dispositivoSeleccionado.getPath()[self.dispositivoSeleccionado.getPath().rfind("/")+1:]

self.panelVerificacion.dispositivoTextEdit.setPlainText("Dispositivo: "+nombreDispositivo+"\nespacio libre: "+(str(self.dispositivoSeleccionado.getLibre())))

else:

self.panelVerificacion.dispositivoTextEdit.setPlainText("DISPOSITIVO NO SELECCIONADO\nIMPOSIBLE GRABAR\nVOLVER PARA ATRAS Y SELECCIONAR UN DISPOSITIVO")

datos=""

for archivo in self.archivosYDirectoriosSeleccionados():

#le dejo solo el nombre del archivo o directorio y lo voy tabulando, asi queda mas entendible

aux=archivo.count("/")

archivo=archivo[archivo.rfind("/")+1:]

while aux>0:

archivo=" "+archivo

aux=aux-1

datos=datos+archivo+"\n"

self.panelVerificacion.datosTextEdit.setPlainText(datos)

def clickBotonPendrive(self):

#selecciono como dispositivo al usb y como manejador al manejador de usb

usb=Usb()

self.dispositivoSeleccionado=usb.hayDispositivos()

self.manejadorDispositivo=usb

def clickBotonCd(self):

cd=CdRom()

self.dispositivoSeleccionado=cd.hayDispositivos()

self.manejadorDispositivo=cd

def grabar(self):

self.manejadorDispositivo.grabar(self.directorioProy, self.archivosSeleccionados(), self.dispositivoSeleccionado)

def modificarBarraProgreso(self, item, colum):

#los parametros son para que enganche con la señal

i=0

for item in self.panelContenidos.treeWidget.findItems('', QtCore.Qt.MatchRecursive|QtCore.Qt.MatchContains) : #itero sobre todos los items del arbol

if item.checkState(0)==2 and item.childCount()==0: #si el item esta marcado y es archivo (o sea que tiene 0 hijos)

i=i+item.getTamanioBytes()

if self.dispositivoSeleccionado:

if (i>self.dispositivoSeleccionado.getLibre()):

#ACA DEVERIA CAMBIARSE EL TEXT DE LA PROGRESS BAR A LLENO

self.panelContenidos.progressBar.setValue(self.dispositivoSeleccionado.getLibre())

else:

self.panelContenidos.progressBar.setValue(i)

else:

self.panelContenidos.progressBar.setValue(100)

def actualizarPresentacion(self):

self.presentacionImagenActual=(self.presentacionImagenActual+1)%len(self.presentacion)

self.panelGrabacion.imagenLabel.setPixmap(self.presentacion[self.presentacionImagenActual])

def actualizarBarraDeProgreso(self):

self.app.processEvents()

#ESTO NO TIENE QUE IR, ES SOLO PARA MOSTRAR QUE LA BARRA FUNCIONA

self.textoBarraActual=(self.textoBarraActual+1)%len(self.textoBarra)

self.panelGrabacion.progressBar.setFormat(self.textoBarra[self.textoBarraActual])

self.panelGrabacion.progressBar.setValue(self.panelGrabacion.progressBar.value()+5)

##############################################################################################################

#Metodos que son llamados por los botones de los paneles (los que necesitan algo mas que mostrar los paneles)#

##############################################################################################################

def panelDispositivosBotonAnterior(self):

self.timerDispositivos.stop()

self.mostrarPanelBienvenido()

def panelDispositivosBotonSiguiente(self):

self.timerDispositivos.stop()

self.mostrarPanelContenidos()

def panelVerificacionBotonGrabar(self):

if (self.dispositivoSeleccionado):

self.mostrarPanelGrabacion()

else:

self.dialogErrorWidget.exec_()

#############################################################################################################

#Metodos encargados de inicializar y configurar los paneles. Son llamados desde el constructor de la clase #

#############################################################################################################

def configurarPanelIzquierdo(self):

self.panelIzquierdoWidget = QtGui.QWidget()

self.panelIzquierdo = Ui_panelIzquierdo()

self.panelIzquierdo.setupUi(self.panelIzquierdoWidget)

self.UiVentanaPrincipal.horizontalLayout.addWidget(self.panelIzquierdoWidget)

#Creo 2 variables para cambiar los frames del panel izquierdo segun el panel actual que se muestra.

self.paletaPanelNoActivo=QPalette(self.panelIzquierdo.bienvenidoFrame.palette())

self.paletaPanelActivo=QPalette(self.paletaPanelNoActivo)

#le cambio los colores al borde y al fondo (WindowText y Window respectivamente)de la paletaPanelActivo

self.paletaPanelActivo.setColor(0, 0, QColor(148, 134, 125))

self.paletaPanelActivo.setColor(0, 10, QColor(188, 183, 176))

#pongo las letras de los labels en negro, asi dejan de heredar del frame y no toman el color "marron" cuando se activa un panel

self.paletaLabel=QPalette(self.panelIzquierdo.bienvenidoLabel.palette())

self.paletaLabel.setColor(0, 0, QColor(50, 50, 50))

self.panelIzquierdo.bienvenidoLabel.setPalette(self.paletaLabel)

self.panelIzquierdo.dispositivosLabel.setPalette(self.paletaLabel)

self.panelIzquierdo.contenidosLabel.setPalette(self.paletaLabel)

self.panelIzquierdo.verificacionLabel.setPalette(self.paletaLabel)

self.panelIzquierdo.grabacionLabel.setPalette(self.paletaLabel)

def configurarPanelBienvenido(self):

self.panelBienvenidoWidget = QtGui.QWidget()

self.panelBienvenido = Ui_panelBienvenido()

self.panelBienvenido.setupUi(self.panelBienvenidoWidget)

self.UiVentanaPrincipal.horizontalLayout.addWidget(self.panelBienvenidoWidget)

#Configuro los botones

QtCore.QObject.connect(self.panelBienvenido.botonSiguiente, QtCore.SIGNAL("pressed()"), self.mostrarPanelDispositivos)

def configurarPanelDispositivos(self):

self.panelDispositivosWidget = QtGui.QWidget()

self.panelDispositivos = Ui_panelDonde()

self.panelDispositivos.setupUi(self.panelDispositivosWidget)

self.UiVentanaPrincipal.horizontalLayout.addWidget(self.panelDispositivosWidget)

#Configuro los botones

QtCore.QObject.connect(self.panelDispositivos.anteriorBoton, QtCore.SIGNAL("pressed()"), self.panelDispositivosBotonAnterior)

QtCore.QObject.connect(self.panelDispositivos.siguienteBoton, QtCore.SIGNAL("pressed()"), self.panelDispositivosBotonSiguiente)

QtCore.QObject.connect(self.panelDispositivos.pendriveRadio, QtCore.SIGNAL("clicked()"), self.clickBotonPendrive)

QtCore.QObject.connect(self.panelDispositivos.cdRadio, QtCore.SIGNAL("clicked()"), self.clickBotonCd)

#creo variable self.dispositivoSeleccionado (lo hago asi para poder comprovar si tiene valor o no

#en el metodo panelVerificacionBotonGrabar() y otros y se inicializa en los metodos clickBotonPendrive(), clickBoton...())

self.dispositivoSeleccionado=None

self.manejadorDispositivo=None

#inicializo un timer para actualizar los dispositivos conectados y conecto su timeout con un metodo

self.timerDispositivos = QTimer()

QtCore.QObject.connect(self.timerDispositivos, QtCore.SIGNAL("timeout()"), self.actualizarDispositivos)

def configurarPanelContenidos(self):

self.panelContenidosWidget = QtGui.QWidget()

self.panelContenidos = Ui_panelQue()

self.panelContenidos.setupUi(self.panelContenidosWidget)

self.UiVentanaPrincipal.horizontalLayout.addWidget(self.panelContenidosWidget)

#Configuro los botones

QtCore.QObject.connect(self.panelContenidos.anteriorBoton, QtCore.SIGNAL("pressed()"), self.mostrarPanelDispositivos)

QtCore.QObject.connect(self.panelContenidos.siguienteBoton, QtCore.SIGNAL("pressed()"), self.mostrarPanelVerificacion)

QtCore.QObject.connect(self.panelContenidos.treeWidget, QtCore.SIGNAL("itemChanged(QTreeWidgetItem*,int)"), self.modificarBarraProgreso)

#Lleno el objeto QTreeWidget (que es, en el panelContenidos, donde se ven los contenidos que se pueden grabar) con todo el contenido

for nombreArchivo in os.listdir(self.directorioContenidoLibre):

itemArchivo=self.crearQTreeWidgetItemModificado(self.panelContenidos.treeWidget, self.directorioContenidoLibre+'/'+nombreArchivo)

if (os.path.isdir(self.directorioContenidoLibre)):

self.recorrerDirectorioCreandoQTreeWidgetItems(self.directorioContenidoLibre+'/'+nombreArchivo, itemArchivo)

def configurarPanelVerificacion(self):

self.panelVerificacionWidget=QtGui.QWidget()

self.panelVerificacion=Ui_panelVerificacion()

self.panelVerificacion.setupUi(self.panelVerificacionWidget)

self.UiVentanaPrincipal.horizontalLayout.addWidget(self.panelVerificacionWidget)

#configuro los botones

QtCore.QObject.connect(self.panelVerificacion.volverBoton, QtCore.SIGNAL("pressed()"), self.mostrarPanelContenidos)

QtCore.QObject.connect(self.panelVerificacion.grabarBoton, QtCore.SIGNAL("pressed()"), self.panelVerificacionBotonGrabar)

#Inicializo un panel de dialogo de error, para cuando no se haya seleccionado un dispositivo o se haya desconectado

self.dialogErrorWidget=QtGui.QDialog()

self.dialogError=Ui_Dialog()

self.dialogError.setupUi(self.dialogErrorWidget)

def configurarPanelGrabacion(self):

self.panelGrabacionWidget = QtGui.QWidget()

self.panelGrabacion = Ui_panelAhora()

self.panelGrabacion.setupUi(self.panelGrabacionWidget)

self.UiVentanaPrincipal.horizontalLayout.addWidget(self.panelGrabacionWidget)

#Configuro los botones

QtCore.QObject.connect(self.panelGrabacion.principioBoton, QtCore.SIGNAL("pressed()"), self.mostrarPanelBienvenido)

#Para mostrar la presentacion con info del dispenser y para la barra de progreso que se va actualizando uso un QTimer

#inicializo el timer y conecto su timeout con un metodo

self.timerPresentacion = QTimer()

QtCore.QObject.connect(self.timerPresentacion, QtCore.SIGNAL("timeout()"), self.actualizarPresentacion)

#almaceno todas las imagenes de la presentacion en una lista de QPixmax self.presentacion,

#y una variable para la imagen actual de la presentacion self.presentacionImagenActual

presentacionArchivos=os.listdir(os.getcwd()+"/images-and-icons/")

self.presentacion=[]

for presentacionArchActual in presentacionArchivos:

self.presentacion.append(QPixmap(os.getcwd()+"/images-and-icons/"+presentacionArchActual))

self.presentacionImagenActual=0

self.timerBarraDeProgreso = QTimer()

QtCore.QObject.connect(self.timerBarraDeProgreso, QtCore.SIGNAL("timeout()"), self.actualizarBarraDeProgreso)

#ESTO NO TIENE QUE IR, ES SOLO PARA MOSTRAR QUE LA BARRA FUNCIONA

self.textoBarra=["grabando.", "grabando..", "grabando..."]

self.textoBarraActual=0

##############################################################################################################################

#Metodos para mostrar y ocultar paneles (son los que usan los botones "siguiente" y "anterior" de los botones de los paneles #

#Los botones del panel izquierdo no tienen funcionalidad, solo sirven para mostrar por que paso van #

#estos metodos tambien pueden hacer alguna que otra funcion como cambiar alguna variable para que se pause o inicie un hilo #

##############################################################################################################################

def mostrarPanelBienvenido(self):

self.panelBienvenidoWidget.show()

self.panelDispositivosWidget.hide()

self.panelContenidosWidget.hide()

self.panelVerificacionWidget.hide()

self.panelGrabacionWidget.hide()

self.panelIzquierdo.bienvenidoFrame.setPalette(self.paletaPanelActivo)

self.panelIzquierdo.dispositivosFrame.setPalette(self.paletaPanelNoActivo)

self.panelIzquierdo.grabacionFrame.setPalette(self.paletaPanelNoActivo)

def mostrarPanelDispositivos(self):

self.panelBienvenidoWidget.hide()

self.panelDispositivosWidget.show()

self.panelContenidosWidget.hide()

self.panelIzquierdo.bienvenidoFrame.setPalette(self.paletaPanelNoActivo)

self.panelIzquierdo.dispositivosFrame.setPalette(self.paletaPanelActivo)

self.panelIzquierdo.contenidosFrame.setPalette(self.paletaPanelNoActivo)

#Empiezo a ejecutar el timer para actualizar los dispositivos cada 1 segundo

#Llamo al metodo que va a llamar el timer al principio, para que no se tenga que esperar el tiempo inicial sin que se actualice

self.actualizarDispositivos()

self.timerDispositivos.start(1000)

def mostrarPanelContenidos(self):

self.panelDispositivosWidget.hide()

self.panelContenidosWidget.show()

self.panelVerificacionWidget.hide()

self.panelIzquierdo.dispositivosFrame.setPalette(self.paletaPanelNoActivo)

self.panelIzquierdo.contenidosFrame.setPalette(self.paletaPanelActivo)

self.panelIzquierdo.verificacionFrame.setPalette(self.paletaPanelNoActivo)

if self.dispositivoSeleccionado:

self.panelContenidos.progressBar.setRange(0, self.dispositivoSeleccionado.getLibre())

def mostrarPanelVerificacion(self):

self.panelContenidosWidget.hide()

self.panelVerificacionWidget.show()

self.panelIzquierdo.contenidosFrame.setPalette(self.paletaPanelNoActivo)

self.panelIzquierdo.verificacionFrame.setPalette(self.paletaPanelActivo)

#muestro informacion sobre el dispositivo seleccionado y los datos a grabar

self.comprobarYMostrarDatos()

def mostrarPanelGrabacion(self):

self.panelVerificacionWidget.hide()

self.panelGrabacionWidget.show()

self.panelIzquierdo.verificacionFrame.setPalette(self.paletaPanelNoActivo)

self.panelIzquierdo.grabacionFrame.setPalette(self.paletaPanelActivo)

#oculto la seccion donde muestra que ya se termino de grabar

self.panelGrabacion.terminadoWidget.hide()

#Llamo al metodo que va a llamar el timer al principio, para que no se tenga que esperar el tiempo inicial sin que se actualice

self.actualizarPresentacion()

self.timerPresentacion.start(7000)

self.actualizarBarraDeProgreso()

self.timerBarraDeProgreso.start(2000)

#Inicio el hilo de grabacion y empiezo a grabar

self.hiloGrabacion = threading.Thread(target=self.grabar)

self.hiloGrabacion.start()

#Actualizo el panel cada segundo para que se actualice la presentacion y la barra de progreso mientras que se este grabando

while self.hiloGrabacion.isAlive():

self.app.processEvents()

time.sleep(1)

self.timerPresentacion.stop()

self.timerBarraDeProgreso.stop()

#muestro el panel que indica que la grabacion termino con botones para volver al principio y oculto la barra de grabacion y su label

self.panelGrabacion.terminadoWidget.show()

self.panelGrabacion.label.hide()