jro_apps/bk_manager Commit - r56:57 · Jicamarca Repository

redefiniendo parte grabacion

ralonso -

r56:57

parent child

bk_manager/trunk/functions/functions.py +7 -15

             # -*- coding: utf-8 -*-
             #class BKmanager:
             #    def __init__(self):
             from subprocess import *
             import sys
             import os
             import subprocess
             import commands
             #Entero a cadena agregando ceros delante
             def i2s(var_n, var_length=4):
                 var_n2=str(var_n)
                 while len(var_n2) < var_length:
                     var_n2 = "0"+var_n2
                 return var_n2
             #Crea directorios en la ruta indicada
             def make_dirs(list_dirs,  self):
                 var_cmd="mkdir -p "+str(self.var_Rpath)
                 for var_dir in list_dirs:
                     var_output=commands.getstatusoutput(var_cmd+'/'+var_dir)[0]
                     if var_output != 0:
                         self.txtInfo.append("Error al crear el directorio "+var_dir+", output_error:" + str(var_output))
                         return False
                 self.txtInfo.append('Carpetas creadas correctamente')
                 return True
             #Se verifica que la ruta exista y sea un directorio
             def dir_exists(var_dir,  self):
                 if os.path.isdir(var_dir):
                     self.txtInfo.append("Ruta valida, sin error:" + str(var_dir))
                     return True
                 else:
                     self.txtInfo.append("Ruta no valida, output_error:" + str(var_dir))
                     return False
             #Se buscan los archivos del tipo especificado
             def load_days(self):
                 self.var_list=[]
                 self.lstStartDay.clear()
                 self.lstStopDay.clear()
                 if self.statusDpath == False:
                     self.btnGbkp.setEnabled(False)
                     return
                 if self.var_Dtype == '':
                    return
                 var_cmd="find " + str(self.var_Dpath) + " -name *."+ str(self.var_Dtype) +" | awk -F/ '{print substr($NF,2,7)}' | sort| uniq"
                 output=commands.getstatusoutput(var_cmd)[1]
                 #Si no se encuentra ningun archivo
                 if len(output) == 0:
                     self.txtInfo.append("No se encontraron archivos")
                     self.btnGbkp.setEnabled(False)
                     return
                 #Se cargan las listas para seleccionar StartDay y StopDay (QComboBox)
                 for i in range(0, (len(output)+1)/8):
                     self.var_list.append(output[8*i:8*(i+1)-1])
                 for i in self.var_list:
                     self.lstStartDay.addItem(i)
                     self.lstStopDay.addItem(i)
                 self.lstStopDay.setCurrentIndex(self.lstStartDay.count()-1)
                 get_sub_list(self)
                 self.btnGbkp.setEnabled(True)
             #Verifica que los parametros
             def validate_parameters(self):
                 #Verifica que las rutas sean validas
                 if self.statusRpath == False:
                     self.txtInfo.append("Ruta de proyecto no valida")
                     return False
                 #Verifica la etiqueta
                 if len(self.var_Elabel) == 0:
                     self.txtInfo.append("Debe ingresar el nombre de la etiqueta")
                     return False
                 return True
             #Obtiene el rango de las fechas seleccionadas
             def get_sub_list(self):
                 self.var_sublist=[]
                 for i in self.var_list[self.lstStartDay.currentIndex():self.lstStartDay.currentIndex() + self.lstStopDay.currentIndex()+1]:
                     self.var_sublist.append(i)
                 if len(self.var_sublist) == 0:
                     self.txtInfo.append("No existen archivos encontrados")
             #Busca los archivos con los parametros de busqueda
             def list_files(self):
                 var_files_list=[]
                 for var_doy in self.var_sublist:
                     var_cmd="find " + str(self.var_Dpath) + " -name ?"+var_doy+"???."+ str(self.var_Dtype) + " |sort"
                     var_output=commands.getstatusoutput(var_cmd)[1]
                     for var_file in var_output.split():
                         var_files_list.append(var_file) #Almacena  cada archivo en la lista
                 return var_files_list
             #Genera la lista de archivos .dat que contienen los archivos a grabar en cada DVD
             def make_files_dat(var_files_list,  self):
                 var_Rpath_ppath=self.var_Rpath+"/ppath" #Ruta de los archivos a grabar
                 var_n=1 #Numero del DVD actual
                 var_tmp=0 #Se usa para acumular el tamaño de los archivos de la lista
                 var_files_list_2=[] #Se usa para almacenar la lista de archivos agrbar en cada DVD
                 for i in var_files_list: #Se asignan en i los archivos de la lista
                     self.txtInfo.append(i)
                     var_size_i=os.path.getsize(i)/1024+1 #tamaño en KB del archivo de la lista, se suma 1 KB para evitar problemas al momento de sumar
                     var_tmp += var_size_i #Se acumulan el tamaño de los archivos de la lista
                     #Si el tamaño acumulado es mayor que el de el DVD
                     if var_tmp > (self.var_Dcapacity * 1024):
                         var_tmp -= var_size_i #se quita el tamaño sumado para mostrar el tamaño real
                         #se crea un archivo con numeral en el sufijo y extension .dat
                         var_file = open(var_Rpath_ppath+"/"+self.var_Elabel+"_"+i2s(var_n)+".dat","w")
                         #Se añade la lista de archivos a grabar en el DVD al archivo .dat
                         for line in var_files_list_2:
-                            var_tmp_path=(line.split(self.var_Dpath)[1]).split('/')
+                            var_tmp_path=line.split(self.var_Dpath)[1][:-13]
-                            var_tmp_path2="/"
+                            var_file.write(var_tmp_path+'='+line+'\n')
-                            for l in range(0, len(var_tmp_path)-1):
-                                var_tmp_path2=var_tmp_path2+str(var_tmp_path[l])+"/"
-                            var_file.write(var_tmp_path2+'=')
-                            var_file.write(line+'\n')
                         var_file.close()
                         var_tmp = var_size_i #Se asigna a la variable el tamaño del archivo actual
                         var_files_list_2=[] #Se reinicia la lista
                         var_n += 1
                     var_files_list_2.append(i)
                 #se crea un archivo con numeral en el sufijo y extension .dat
                 var_file = open(var_Rpath_ppath+"/"+self.var_Elabel+"_"+i2s(var_n)+".dat","w")
                 #Se añade la lista de archivos a grabar en el DVD al archivo .dat
                 for line in var_files_list_2:
-                    var_tmp_path=(line.split(self.var_Dpath)[1]).split('/')
+                    var_tmp_path=line.split(self.var_Dpath)[1][:-13]
-                    var_tmp_path2="/"
+                    var_file.write(var_tmp_path+'='+line+'\n')
-                    for l in range(0, len(var_tmp_path)-1):
-                        var_tmp_path2=var_tmp_path2+str(var_tmp_path[l])+"/"
-                    var_file.write(var_tmp_path2+'=')
-                    var_file.write(line+'\n')
                 var_file.close()
                 return var_n
             #Genera los archivos .print con los  cuales se creara los postscript
             def make_files_print(self):
                 var_Rpath_ppath=self.var_Rpath+"/ppath" #Ruta de los archivos a grabar
                 # Se leen todos los archivos .dat creados para crear las etiquetas en los archivos .print
                 for var_n in range(1, self.var_n_discs + 1):
                     #se abren los archivos .dat en modo lectura
                     var_file = open(var_Rpath_ppath+"/"+self.var_Elabel+"_"+i2s(var_n)+".dat","r")
                     lines=var_file.readlines() # Se lee las lineas en el archivo y se almacenan en la lista
                     # Se crea el archivo .print
                     var_file_print = open(var_Rpath_ppath+"/"+self.var_Elabel+"_"+i2s(var_n)+".print","w")
                     var_file_print.write(self.var_Elabel+" "+i2s(var_n)+"/"+i2s(self.var_n_discs)+"\n")
                     var_file_print.write("Year Doy Folder Set Time range\n")
                     var_first_folder = lines[0].split('=')[0]
                     var_first_file = (lines[0].split('=')[1])[:-1]
                     var_date_first_file=commands.getstatusoutput("date -r "+var_first_file+" +'%T'")[1]
                     for j in range(1, len(lines)-1):
                         var_tmp_folder = lines[j].split('=')[0]
                         var_tmp_file = (lines[j].split('=')[1])[:-1]
                         # Si el subfolder superior o la fecha del archivo cambia se genera una nueva linea
                         if (var_tmp_folder != var_first_folder) or (var_tmp_file[0:-5] != var_first_file[0:-5]):
                             var_last_file = (lines[j-1].split('=')[1])[:-1]
                             var_date_last_file=commands.getstatusoutput("date -r "+var_last_file+" +'%T'")[1]
                             # Si el archivo se grabara directamente en la / del DVD y no en un /directorio/
                             # se usa la etiqueta para indicar la parte de la etiqueta donde va el subdirectorio
                             if var_first_folder == '/':
                                 var_folder = self.var_Elabel
                             else:
-                                var_folder = var_first_folder.split('/')[1]
+                                var_folder = var_first_folder.split('/')[-2]
                             var_file_print.write(var_first_file[-12:-8]+" "+var_first_file[-8:-5]+" "+var_folder +" "+var_first_file[-5:-2]+" "
                                     +var_last_file[-5:-2]+" "+var_date_first_file+" "+var_date_last_file+"\n")
                             var_first_folder = lines[j].split('=')[0]
                             var_first_file = (lines[j].split('=')[1])[:-1]
                             var_date_first_file=commands.getstatusoutput("date -r "+var_first_file+" +'%T'")[1]
                     var_last_file = (lines[-1].split('=')[1])[:-1]
                     var_date_last_file=commands.getstatusoutput("date -r "+var_last_file+" +'%T'")[1]
                     if var_first_folder == '/':
                         var_folder = self.txtElabel.text()
                     else:
-                        var_folder = var_first_folder.split('/')[1]
+                        var_folder = var_first_folder.split('/')[-2]
                     var_file_print.write(var_first_file[-12:-8]+" "+var_first_file[-8:-5]+" "+var_folder +" "+var_first_file[-5:-2]+" "
                             +var_last_file[-5:-2]+" "+var_date_first_file+" "+var_date_last_file+"\n")
                     var_file.close()
                     var_file_print.close()

bk_manager/trunk/functions/functions2.py +38 -34

             # -*- coding: utf-8 -*-
             from subprocess import *
             import sys
             import os
             import subprocess
             import commands
-            def set_parameters(self):
-                """
-                Se usa para inicializar ciertos parametros para pruebas
-                """
-                self.txtDpath.setText('/home/ricardoar/optional/STORAGE/EW_DRIFTS')
-                self.txtRpath.setText('/home/ricardoar/optional/prueba1_jro_backup_manager')
-                self.txtElabel.setText('EW_DRIFTS_pruebas')
-                self.lstDcapacity.setCurrentIndex(4)
-                self.txtDcapacity.setValue(250.0)
-                self.txtDcapacity.setReadOnly(False)
             def detect_devices(self):
                 """
                 Deteccion de los dispositvos de grabacion
                 """
                 #var_cmd="wodim --devices | grep /dev/ | awk -F\' '{print $2}'" #Funciona en consola pero no en python ¿?
                 var_cmd="wodim --devices | grep /dev/ | awk '{print $2}' | awk -F= '{print $2}'"
                 var_output = commands.getstatusoutput(var_cmd)
                 if var_output[0] != 0:
                     self.txtInfo.append("No se pudo encontrar los dispositivos de grabacion, output_error:" + str(var_output))
                 else:
                     self.txtInfo.append("dispositivos encontrados")
                     var_devices = var_output[1].split('\n')
                     var_tmp=[]
                     for i in range(0, 4):
                         if i < len(var_devices):
                             var_len = len(var_devices[i])
                             var_tmp.append(var_devices[i][1:var_len - 1])
                         else:
                             var_tmp.append('')
                     #Se escriben los dispostivos correspodientes, si existen
                     self.txtDeviceA.setText(str(var_tmp[0]))
                     self.txtDeviceB.setText(str(var_tmp[1]))
                     self.txtDeviceC.setText(str(var_tmp[2]))
                     self.txtDeviceD.setText(str(var_tmp[3]))
                     #Se desactivan los que no existen
                     if len(var_tmp[0]) == 0 :
                         self.chkDevA.setChecked(False)
                         self.chkDevA.setEnabled(False)
                     if len(var_tmp[1]) == 0 :
                         self.chkDevB.setChecked(False)
                         self.chkDevB.setEnabled(False)
                     if len(var_tmp[2]) == 0 :
                         self.chkDevC.setChecked(False)
                         self.chkDevC.setEnabled(False)
                     if len(var_tmp[3]) == 0 :
                         self.chkDevD.setChecked(False)
                         self.chkDevD.setEnabled(False)
-            def enabled_items1(var_bool, self):
+            def set_parameters_test(self):
-                self.tabParameters.setEnabled(not(var_bool))
+                """
-                self.lstDcapacity.setEnabled(not(var_bool))
+                Se usa para inicializar ciertos parametros para pruebas
-                self.txtDcapacity.setEnabled(not(var_bool))
+                """
-                self.btnGbkp.setEnabled(not(var_bool))
+                self.txtDpath.setText('/home/ricardoar/optional/STORAGE/EW_DRIFTS')
-                self.btnRestart.setEnabled(var_bool)
+                self.txtRpath.setText('/home/ricardoar/optional/prueba1_jro_backup_manager')
-                self.btnStartburn.setEnabled(var_bool)
+                self.txtElabel.setText('EW_DRIFTS_pruebas')
+                self.lstDcapacity.setCurrentIndex(4)
+                self.txtDcapacity.setValue(250.0)
+                self.txtDcapacity.setReadOnly(False)
             def make_parameters_conf(self):
                 var_file = open("parameters.conf","w")
                 var_file.write(self.var_Dpath+"\n") #0
                 var_file.write(self.var_Rpath+"\n") #1
                 var_file.write(str(self.var_lstDtype)+"\n") #2
                 var_file.write(self.var_Dtype+"\n") #3
                 var_file.write(self.var_Elabel+"\n") #4
                 var_file.write(str(self.var_Copys)+"\n") #5
                 var_file.write(str(self.var_lstDcapacity)+"\n") #6
                 var_file.write(str(self.var_Dcapacity)+"\n") #7
+                var_file.write(str(self.var_n_discs)) #8
                 var_file.close()
             def get_parameters_conf(self):
                 var_file = open("parameters.conf","r")
                 lines = var_file.readlines()
                 self.txtDpath.setText(lines[0][:-1]) #0
                 self.txtRpath.setText(lines[1][:-1]) #1
                 self.lstDtype.setCurrentIndex(int(lines[2])) #2
                 self.txtDtype.setText(lines[3][:-1]) #3
                 self.txtElabel.setText(lines[4][:-1]) #4
                 self.txtCopys.setValue(int(lines[5][:-1])) #5
                 self.lstDcapacity.setCurrentIndex(int(lines[6])) #6
-                self.txtDcapacity.setValue(float(lines[7]))
+                self.txtDcapacity.setValue(float(lines[7])) #7
+                self.var_n_discs = int(lines[8]) # 8
                 var_file.close()
             def set_vars(self):
-                self.var_Dpath = self.txtDpath.text()
+                self.var_Dpath = self.txtDpath.text() #0
-                self.var_Rpath = self.txtRpath.text()
+                self.var_Rpath = self.txtRpath.text() #1
-                self.var_lstDtype = self.lstDtype.currentIndex()
+                self.var_lstDtype = self.lstDtype.currentIndex() #2
-                self.var_Dtype = self.txtDtype.text()
+                self.var_Dtype = self.txtDtype.text() #3
-                self.var_Elabel = self.txtElabel.text()
+                self.var_Elabel = self.txtElabel.text() #4
-                self.var_Copys = self.txtCopys.value()
+                self.var_Copys = self.txtCopys.value() #5
-                self.var_lstDcapacity = self.lstDcapacity.currentIndex()
+                self.var_lstDcapacity = self.lstDcapacity.currentIndex() #6
-                self.var_Dcapacity = self.txtDcapacity.value()
+                self.var_Dcapacity = self.txtDcapacity.value() #7
+            def enabled_items1(var_bool, self):
+                self.tabParameters.setEnabled(not(var_bool))
+                self.lstDcapacity.setEnabled(not(var_bool))
+                self.txtDcapacity.setEnabled(not(var_bool))
+                self.btnGbkp.setEnabled(not(var_bool))
+                self.btnRestart.setEnabled(var_bool)
+                self.btnStartburn.setEnabled(var_bool)
+            def enabled_items2(var_bool, self):
+                self.btnRestart.setEnabled(not(var_bool))
+                self.btnStartburn.setEnabled(not(var_bool))
+                self.btnStopburn.setEnabled(var_bool)

bk_manager/trunk/ui/MainWindow.py +21 -31

             # -*- coding: utf-8 -*-
             """
             Module implementing MainWindow.
             """
             from PyQt4.QtGui import QMainWindow
             from PyQt4.QtCore import pyqtSignature
             from PyQt4 import QtCore
             from Ui_MainWindow import Ui_MainWindow
             from PyQt4 import QtGui
             from subprocess import *
             import sys
             import os
-            import subprocess
+            #import subprocess
             import commands
             from functions import functions
             from functions import functions2
             class MainWindow(QMainWindow, Ui_MainWindow):
                 """
                 Class documentation goes here.
                 """
                 def __init__(self, parent = None):
                     QMainWindow.__init__(self, parent)
                     self.setupUi(self)
                     self.setupUi2()
                     #sys.stdout = self #redirige salida estandar
                 def setupUi2(self):
                     functions2.detect_devices(self) #busca los dispositivos de grabacion
+                    self.var_n_discs=0
+                    self.var_list=[]
+                    self.var_sublist=[]
                     #Revisa si existe el archivo de confirguracion
                     if os.path.isfile("parameters.conf"):
                         self.txtInfo.append("Archivo de configuracion encontrado")
                         functions2.get_parameters_conf(self)
+                        self.txtInfo.append("El proyecto creara "+str(self.var_n_discs)+" DVDs")
                     else:
                         self.txtInfo.append("Elija los parametros de configuracion")
-                        functions2.set_parameters(self) #Establece ciertos parametros, para pruebas
+                        functions2.set_parameters_test(self) #Establece ciertos parametros, para pruebas
                     functions2.set_vars(self) #Carga las variables de la clase con los parametros seleccionados
                     self.statusDpath = functions.dir_exists(self.var_Dpath,  self)
                     self.statusRpath = functions.dir_exists(self.var_Rpath,  self)
-                    self.var_n_discs=0
-                    self.var_list=[]
-                    self.var_sublist=[]
                     functions.load_days(self)
                     self.var_process = QtCore.QProcess()
                     self.connect(self.var_process,  QtCore.SIGNAL('readyReadStandardOutput()'),  self.readOuput)
                     self.connect(self.var_process,  QtCore.SIGNAL('readyReadStandardError()'),  self.readError)
                     self.connect(self.var_process,  QtCore.SIGNAL('finished(int,QProcess::ExitStatus)'),  self.finished)
+                def write(self, txt):
+                    self.txtInfo.append(str(txt))
+            #----------------------------------------------------- Funciones del proceso ---------------------------------------------------------------
                 def readOuput(self):
                     self.txtSburn.insertPlainText("stdout: " + QtCore.QString(self.var_process.readAllStandardOutput()))
                 def readError(self):
                     self.txtSburn.insertPlainText("stderr: " + QtCore.QString(self.var_process.readAllStandardError()))
                 def finished(self):
-                    self.txtInfo.append("proceso terminado finished()")
+                    self.txtInfo.append("proceso terminado finished() "+QtCore.QString(self.var_process.exitCode()))
-                    print self.var_process.exitCode()
-                def write(self, txt):
-                    self.txtInfo.append(str(txt))
             #----------------------------------------------------- Obtencion de las ruta de los datos  ---------------------------------------------------------------
                 @pyqtSignature("")
                 def on_btnDpath_clicked(self):
                     """
                     Permite seleccionar graficamente el direcorio de los datos a grabar
                     """
                     self.var_Dpath= QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './',  QtGui.QFileDialog.ShowDirsOnly)
                     self.txtDpath.setText(self.var_Dpath)
                     self.statusDpath = functions.dir_exists(self.var_Dpath,  self)
                     functions.load_days(self)
                 @pyqtSignature("")
                 def on_txtDpath_editingFinished(self):
                     """
                     Carga la ruta editada y verifica que sea correcta y carga la lista de dias
                     """
                     self.var_Dpath=self.txtDpath.text() #Se carga la variable con la ruta recien editada
                     self.statusDpath = functions.dir_exists(self.var_Dpath,  self)
                     functions.load_days(self)
             #----------------------------------------------------- Obtencion de las ruta del proyecto ---------------------------------------------------------------
                 @pyqtSignature("")
                 def on_btnRpath_clicked(self):
                     """
                     Permite seleccionar graficamente el direcorio del proyecto
                     """
                     self.var_Rpath = QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './',  QtGui.QFileDialog.ShowDirsOnly)
                     self.txtRpath.setText(self.var_Rpath)
                     self.statusRpath = functions.dir_exists(self.var_Rpath,  self)
                 @pyqtSignature("")
                 def on_txtRpath_editingFinished(self):
                     """
                     Valida la ruta del proyecto
                     """
                     self.var_Rpath=self.txtRpath.text() #Se carga la variable con la ruta recien editada
                     self.statusRpath = functions.dir_exists(self.var_Rpath,  self)
             #----------------------------------------------------- Tipo de datos ---------------------------------------------------------------
                 @pyqtSignature("int")
                 def on_lstDtype_activated(self, index):
                     """
                     Permite elegir entre los tipos de archivos
                     """
                     self.txtDtype.setReadOnly(True)
                     if index == 0:
                         self.var_Dtype ='r'
                     elif index == 1:
                         self.var_Dtype ='pdata'
                     elif index == 2:
                         self.var_Dtype ='sswma'
                     else :
                         self.var_Dtype =''
                         self.txtDtype.setReadOnly(False)
                     self.txtDtype.setText(self.var_Dtype)
                     functions.load_days(self) #llamada a funcion
                 @pyqtSignature("")
                 def on_txtDtype_editingFinished(self):
                     self.var_Dtype=self.txtDtype.text()
                     functions.load_days(self) #llamada a funcion
             #----------------------------------------------------- Etiqueta ---------------------------------------------------------------
                 @pyqtSignature("")
                 def on_txtElabel_editingFinished(self):
                     self.var_Elabel = self.txtElabel.text()
             #----------------------------------------------------- Numero de copias ---------------------------------------------------------------
                 @pyqtSignature("")
                 def on_txtCopys_editingFinished(self):
                     self.var_Copys = self.txtCopys.value()
             #----------------------------------------------------- Seleccion del rango de fechas ---------------------------------------------------------------
                 @pyqtSignature("int") #CLOSED
                 def on_lstStartDay_activated(self, index):
                     """
                     Cambia la lista de opciones en lstStopDay
                     """
                     var_StopDay_index=self.lstStopDay.count() - self.lstStopDay.currentIndex()
                     self.lstStopDay.clear()
                     for i in self.var_list[index:]:
                         self.lstStopDay.addItem(i)
                     self.lstStopDay.setCurrentIndex(self.lstStopDay.count() - var_StopDay_index)
                     functions.get_sub_list(self)
                 @pyqtSignature("int") #CLOSED
                 def on_lstStopDay_activated(self, index):
                     """
                     Cambia la lista de opciones en lstStartDay
                     """
                     var_StartDay_index=self.lstStartDay.currentIndex()
                     var_end_index = self.lstStopDay.count() - index
                     self.lstStartDay.clear()
                     for i in self.var_list[:len(self.var_list) - var_end_index + 1]:
                         self.lstStartDay.addItem(i)
                     self.lstStartDay.setCurrentIndex(var_StartDay_index)
                     functions.get_sub_list(self)
             #----------------------------------------------------- Capacidad del dispositivo de grabacion ---------------------------------------------------------------
                 @pyqtSignature("")
                 def on_txtDcapacity_editingFinished(self):
                     self.var_Dcapacity = self.txtDcapacity.value()
                 @pyqtSignature("int") #CLOSED
                 def on_lstDcapacity_activated(self, index):
                     """
                     Permite elegir el tamaño del disco
                     """
                     if index == 0:
                         var_size=25.0
                     elif index == 1:
                         var_size=8.5
                     elif index == 2:
                         var_size=4.7
                     elif index == 3:
                         var_size=0.7
                     if index != 4:
                         self.txtDcapacity.setValue(var_size*10**9/1024**2)
                         self.txtDcapacity.setReadOnly(True)
                     else:
                         self.txtDcapacity.setValue(100.0)
                         self.txtDcapacity.setReadOnly(False)
                     self.var_Dcapacity = self.txtDcapacity.value()
             #==============================================================================
             #   Botones para la generacion de los archivos de configuracion y el proceso de grabacion
             #==============================================================================
             #----------------------------------------------------- Generacion de la configuracion usando los parametros ---------------------------------------------------------------
                 @pyqtSignature("")
                 def on_btnGbkp_clicked(self):
                     """
                     Generacion de archivos de configuracion usando los parametros
                     """
                     if functions.validate_parameters(self) == False:
                         return
                     #Crea las carpetas en la ruta del proyecto y verifica que se crearon correctamente
                     list_dirs=['gpath','iso','ppath']
                     bool_make_dirs = functions.make_dirs(list_dirs,  self)
                     if bool_make_dirs == False:
                         return
                     var_files_list = functions.list_files(self) #Se obtiene la lista de archivos a grabar
                     self.var_n_discs = functions.make_files_dat(var_files_list,  self) #Se crean los archivos .dat
                     functions.make_files_print(self) # Se crean los archivos .print
                     functions2.make_parameters_conf(self) # se crea el archivo parameters.conf
                     #Se bloquean los parametros de configuracion
                     functions2.enabled_items1(True, self)
             #----------------------------------------------------- Permite reiniciar la configuracion ---------------------------------------------------------------
                 @pyqtSignature("")
                 def on_btnRestart_clicked(self):
                     """
                     Permite que se puedan cambiar los parametros
                     """
                     functions2.enabled_items1(False, self)
                     os.remove("parameters.conf")
             #----------------------------------------------------- Iniciar proceso de grabacion ---------------------------------------------------------------
                 @pyqtSignature("")
                 def on_btnStartburn_clicked(self):
                     """
                     Se inicia el proceso de grabacion
                     """
-                    self.btnRestart.setEnabled(False)
+                    functions2.enabled_items2(True, self)
-                    self.btnStartburn.setEnabled(False)
-                    self.btnStopburn.setEnabled(True)
                     sys.stdout = self
                     #sys.stderr = self
                     print "stdout_!!!"
                     #Inicializando variables
                     var_Rpath_ppath=self.var_Rpath+"/ppath"
                     var_Rpath_iso=self.var_Rpath+"/iso"
                     var_n=1
                     file_iso=var_Rpath_iso+"/"+functions.i2s(var_n)+".iso"
                     file_dat=var_Rpath_ppath+"/"+self.var_Elabel+"_"+functions.i2s(var_n)+".dat"
                     var_cmd = 'genisoimage -hide-joliet-trans-tbl -joliet-long -r '
                     var_cmd += ' -A '+self.var_Elabel+' -V '+self.var_Elabel
                     var_cmd += ' -graft-points -path-list '+ file_dat+' -o '+file_iso
-            #        self.process.start(var_cmd)
                     self.var_process.start(var_cmd)
-            #        self.var_process.waitForFinished()
                     self.txtInfo.append("ejecutandose")
             #        # Se leen todos los archivos .dat creados para crear las etiquetas en los archivos .ps
             #        for var_n in range(1, self.var_n_discs+1):
             #            self.txtInfo.append(str(var_n))
             #            file_iso=var_Rpath_iso+"/"+functions.i2s(var_n)+".iso"
             #            file_dat=var_Rpath_ppath+"/"+self.var_Elabel+"_"+functions.i2s(var_n)+".dat"
             #
             #            var_cmd = 'genisoimage -hide-joliet-trans-tbl -joliet-long -r '
             #            var_cmd += ' -A '+self.var_Elabel+' -V '+self.var_Elabel
             #            var_cmd += ' -graft-points -path-list '+ file_dat+' -o '+file_iso
             #            self.txtInfo.append(var_cmd)
             #
-            #            var_output=commands.getstatusoutput(str(var_cmd))[0]
-            #            self.txtInfo.append(str(var_output))
-                    #os.system(str(var_cmd))
-                    #p = subprocess.Popen(str('ls /'), shell=True,  stdout=self)
-                    #os.waitpid(p.pid, 0)
-                    ####self.txtInfo.append(str(p.pid))
             #----------------------------------------------------- Detener proceso de grabacion ---------------------------------------------------------------
                 @pyqtSignature("")
                 def on_btnStopburn_clicked(self):
                     """
                     Slot documentation goes here.
                     """
-                    self.var_process.terminate()
+                    self.var_process.terminate() #Termina el proceso, si puede
-                    self.btnRestart.setEnabled(True)
+                    functions2.enabled_items2(False, self)
-                    self.btnStartburn.setEnabled(True)
-                    self.btnStopburn.setEnabled(False)
             #----------------------------------------------------- Testeo de las unidades de grabacion ---------------------------------------------------------------
                 @pyqtSignature("")
                 def on_btnTdevA_clicked(self):
                     var_dev = str(self.txtDeviceA.text())
                     var_cmd = 'eject ' +  var_dev + '; eject -t ' +  var_dev
                     commands.getstatusoutput(var_cmd)
                 @pyqtSignature("")
                 def on_btnTdevB_clicked(self):
                     var_dev = str(self.txtDeviceB.text())
                     var_cmd = 'eject ' +  var_dev + '; eject -t ' +  var_dev
                     commands.getstatusoutput(var_cmd)
                 @pyqtSignature("")
                 def on_btnTdevC_clicked(self):
                     var_dev = str(self.txtDeviceC.text())
                     var_cmd = 'eject ' +  var_dev + '; eject -t ' +  var_dev
                     commands.getstatusoutput(var_cmd)
                 @pyqtSignature("")
                 def on_btnTdevD_clicked(self):
                     var_dev = str(self.txtDeviceD.text())
                     var_cmd = 'eject ' +  var_dev + '; eject -t ' +  var_dev
                     commands.getstatusoutput(var_cmd)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages