jro_apps/bk_manager Commit - r78:79 · Jicamarca Repository

3ro segun diagrama...

ralonso -

r78:79

parent child

bk_manager/trunk/functions/functions.py +16 -6

             # -*- coding: utf-8 -*-
   No newline at end of file
             #class BKmanager:
             #    def __init__(self):
   No newline at end of file
             from subprocess import *
             import sys
             import os
             import subprocess
             import commands
             import shutil
+            import functions2
  No newline at end of file
   No newline at end of file
             #--------------------------------------------- Entero a cadena agregando ceros delante -------------------------------------------------
   No newline at end of file
             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
   No newline at end of file
   No newline at end of file
             #----------------------------------------- Se verifica que la ruta exista y sea un directorio -------------------------------------------------
   No newline at end of file
             def dir_exists(var_dir,  self):
                 if os.path.isdir(var_dir):
                     return True
                 else:
                     self.txtInfo.append("Incorrect path:" + str(var_dir))
                     return False
   No newline at end of file
   No newline at end of file
             #-------------------------------- Se buscan los archivos del tipo especificado y se cargan las fechas -----------------------------
   No newline at end of file
             def load_days(self):
   No newline at end of file
                 self.var_list=[]
                 self.lstStartDay.clear()
                 self.lstStopDay.clear()
   No newline at end of file
                 if self.statusDpath == False:
                     self.btnGbkp.setEnabled(False)
                     return
   No newline at end of file
                 if self.var_Dtype == '':
                    return
   No newline at end of file
                 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]
   No newline at end of file
                 #Si no se encuentra ningun archivo
                 if len(output) == 0:
                     self.txtInfo.append("File not found")
                     self.btnGbkp.setEnabled(False)
                     return
   No newline at end of file
                 #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])
   No newline at end of file
                 for i in self.var_list:
                     self.lstStartDay.addItem(i)
                     self.lstStopDay.addItem(i)
                 self.lstStopDay.setCurrentIndex(self.lstStartDay.count()-1)
   No newline at end of file
                 get_sub_list(self)
                 self.btnGbkp.setEnabled(True)
   No newline at end of file
   No newline at end of file
             #-------------------------------------------------- Obtiene el rango de las fechas seleccionadas -----------------------------------------
   No newline at end of file
             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)
   No newline at end of file
   No newline at end of file
             #----------------------------------------------------- Verifica los parametros faltantes -----------------------------------------------------------
   No newline at end of file
             def validate_parameters(self):
                 #Verifica que las ruta del proyecto sea valida
                 if self.statusRpath == False:
                     self.txtInfo.append("Incorrect proyect path")
                     return False
   No newline at end of file
                 #Verifica la etiqueta
                 if len(self.var_Elabel) == 0:
                     self.txtInfo.append("Enter label")
                     return False
   No newline at end of file
                 return True
   No newline at end of file
   No newline at end of file
             #------------------------------------------------- Crea directorios en la ruta indicada -----------------------------------------------------------
   No newline at end of file
             def make_dirs(list_dirs,  self):
                 """
   No newline at end of file
                 """
   No newline at end of file
                 for var_dir in list_dirs:
                     shutil.rmtree(self.var_Rpath+'/'+var_dir,  True)
                     var_output=commands.getstatusoutput("mkdir -p "+self.var_Rpath+'/'+var_dir)[0]
                     if var_output != 0:
                         self.txtInfo.append("Error creating directory: "+var_dir+", output_error:" + str(var_output))
                         return False
                 self.txtInfo.append('Directories created correctly')
                 return True
   No newline at end of file
   No newline at end of file
             #-------------------------------------------- Busca los archivos con los parametros de busqueda ---------------------------------------
   No newline at end of file
             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
   No newline at end of file
   No newline at end of file
             #--------------- Genera la lista de archivos .dat que contienen los archivos a grabar en cada DVD -----------------------
   No newline at end of file
             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
   No newline at end of file
                 for i in var_files_list: #Se asignan en i los archivos de la lista
   No newline at end of file
                     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
   No newline at end of file
                     #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][:-13]
                             var_file.write(var_tmp_path+'='+line+'\n')
                         var_file.close()
   No newline at end of file
                         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)
   No newline at end of file
                 #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][:-13]
                     var_file.write(var_tmp_path+'='+line+'\n')
                 var_file.close()
   No newline at end of file
                 self.txtInfo.append("configuration files created")
                 return var_n
   No newline at end of file
   No newline at end of file
             #------------------------------ Genera los archivos .print con los  cuales se creara los postscript -----------------------------------
   No newline at end of file
             def make_files_print(self):
   No newline at end of file
                 var_Rpath_ppath=self.var_Rpath+"/ppath" #Ruta de los archivos a grabar
                 var_Rpath_gpath=self.var_Rpath+"/gpath" #Ruta de los archivos postscript
                 var_labels=[]
                 for m in range (0,  self.txtPSgraphic.value() - 1):
                     var_lines = "\n" * 9
                     var_labels.append(var_lines)
   No newline at end of file
                 # Se leen todos los archivos .dat creados para crear las etiquetas en los archivos .print
                 for var_n in range(1, self.var_Discs + 1):
   No newline at end of file
                     #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
                     var_file.close()
                     list_files=[]
                     var_lines=[]
   No newline at end of file
                     for j in range(0, len(lines)):
   No newline at end of file
                         if j == 0:
                             var_first_folder = lines[j].split('=')[0]
                             var_first_file = (lines[j].split('=')[1])[:-1]
                             continue
   No newline at end of file
                         var_tmp_folder = lines[j].split('=')[0]
                         var_tmp_file = (lines[j].split('=')[1])[:-1]
   No newline at end of file
                         # Si el subfolder superior o el DOY del archivo actual y el anterior son diferentes
                         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]
                             list_files.append([var_first_folder, var_first_file, var_last_file])
   No newline at end of file
                             var_first_folder = lines[j].split('=')[0]
                             var_first_file = (lines[j].split('=')[1])[:-1]
   No newline at end of file
                     var_last_file = (lines[-1].split('=')[1])[:-1]
                     list_files.append([var_first_folder, var_first_file, var_last_file])
   No newline at end of file
                     var_lines2 = lines_print(list_files,  self.var_Elabel)
   No newline at end of file
                     for k in range(0, len(var_lines2) / 5):
                         var_lines=["\n"]
                         var_lines.append("        "+self.var_Elabel+" "+i2s(var_n)+"/"+i2s(self.var_Discs)+"\n")
                         var_lines.append("Year Doy Folder"+" "*9+"Set"+" "*11+"Time range\n")
  No newline at end of file
-                        var_lines.append("Year Doy Folder"+" "*6+"Set"+" "*9+"Time range\n")
  No newline at end of file
                         var_lines.extend(var_lines2[(5*k):(5*(k+1))])
                         var_lines.append("\n")
                         var_labels.append(var_lines)
   No newline at end of file
                 for i in range(0, (len(var_labels) // 33) +1 ):
                     var_file=var_Rpath_gpath+"/"+self.var_Elabel+"_"+i2s(i+1)
                     file_ps = open(var_file+".print","w")
                     if i == (len(var_labels) // 33):
                         var_sub_labels = var_labels[33*i:]
                     else:
                         var_sub_labels = var_labels[33*i:33*(i+1)]
   No newline at end of file
                     for label in var_sub_labels:
                         for line in label:
                             file_ps.write(line)
                     file_ps.close()
                     var_cmd="enscript "+var_file+".print -p "+var_file+".ps -f Times-Roman7 " \
                                                           +" -3R -j -B --margins=21.25:20.4:25.51:20 --media=A4"
                     var_output=commands.getstatusoutput(var_cmd)[0]
   No newline at end of file
   No newline at end of file
             def lines_print(list_files,  var_Elabel):
                 """
                 Devuelve las lineas del rango de archivos de cada etiqueta segun el formato
                 """
                 var_lines=[]
                 for i in list_files:
   No newline at end of file
                     # 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 i[0] == '/':
                         var_folder = var_Elabel
                     else:
                         var_folder = i[0].split('/')[-2]
   No newline at end of file
                     var_first_file = i[1]
                     var_last_file = i[2]
   No newline at end of file
                     var_date_first_file=commands.getstatusoutput("date -r "+var_first_file+" +'%T'")[1]
                     var_date_last_file=commands.getstatusoutput("date -r "+var_last_file+" +'%T'")[1]
   No newline at end of file
                     var_lines.append(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")
                 #Nos aseguramos que sea un mutiplo de 5
                 while (len(var_lines) % 5) != 0:
                     var_lines.append("\n")
   No newline at end of file
                 return var_lines
   No newline at end of file
             #---------------------------------------comandos para el proceso de grabacion ------------------------------------------
             def cmd_iso(self):
                 var_Rpath_ppath=self.var_Rpath+"/ppath"
                 var_Rpath_iso=self.var_Rpath+"/iso"
                 #comando para la creacion del archivo.iso
                 file_dat=var_Rpath_ppath+"/"+self.var_Elabel+"_"+i2s(self.var_disc_n)+".dat"
                 file_iso=var_Rpath_iso+"/"+i2s(self.var_disc_n)+".iso"
                 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
                 return var_cmd
   No newline at end of file
             def cmd_burn(self):
                 var_Rpath_iso=self.var_Rpath+"/iso"
                 file_iso=var_Rpath_iso+"/"+i2s(self.var_disc_n)+".iso"            
  No newline at end of file
-                file_iso=var_Rpath_iso+"/"+functions.i2s(self.var_disc_n)+".iso"            
  No newline at end of file
   No newline at end of file
                 var_index = ( ( (self.var_disc_n - 1) * self.var_Copys) + (self.var_copy_n - 1) - self.var_burned_discs ) % len(self.var_devices)
                 var_dev_tmp = self.var_devices[var_index]
   No newline at end of file
                 var_cmd = "wodim -v dev="+var_dev_tmp+" speed=16 "+ file_iso
                 return var_cmd
   No newline at end of file
+            def cmd_check(self):
              No newline at end of file
+                var_cmd = "echo 'function check'"
              No newline at end of file
+                return var_cmd
              No newline at end of file
+  No newline at end of file
             def remove_iso(self):
                 var_Rpath_iso=self.var_Rpath+"/iso"
                 file_iso=var_Rpath_iso+"/"+i2s(self.var_disc_n)+".iso"
-                file_iso=var_Rpath_iso+"/"+functions.i2s(self.var_disc_n)+".iso"
+             No newline at end of file
             #    shutil.rmtree(self.var_Rpath+'/'+var_dir,  True)
  No newline at end of file
              No newline at end of file
-                self.txtInfo.append("Deleting iso file: "+functions.i2s(self.var_disc_n)+".iso")
              No newline at end of file
-  No newline at end of file
                 if os.path.isfile(file_iso):
                     os.remove(file_iso)
   No newline at end of file
             #Si es el ultimo disco se termina el proceso
             def is_last_disc_and_copy(self):
                 if self.var_disc_n == self.var_Discs and self.var_copy_n == self.var_Copys:
                     self.function_final()
                 else:
                     next_disc(self)
   No newline at end of file
             #Define cual es el siguiente disco a grabar y que paso seguir
             def next_disc(self,  error = False):
                 if self.var_copy_n == self.var_Copys:
+                    #borrado del iso
              No newline at end of file
+                    self.txtInfo.append("Deleting iso file: "+i2s(self.var_disc_n)+".iso")
              No newline at end of file
+                    remove_iso(self)
              No newline at end of file
+  No newline at end of file
                     self.var_disc_n += 1
                     self.var_copy_n = 1
                     self.var_step = 0
   No newline at end of file
                 else:
                     self.var_copy_n += 1
                     self.var_step = 1
              No newline at end of file
+                functions2.make_burning_conf(self) # Si el proceso no ha sido detenido manualmente
              No newline at end of file
+                #crea el archivo burning.conf para el seguimiento de los discos grabados
  No newline at end of file
   No newline at end of file
                 var_index = ( ( (self.var_disc_n - 1) * self.var_Copys) + (self.var_copy_n - 1) - self.var_burned_discs ) % len(self.var_devices)
   No newline at end of file
                 self.txtInfo.append("NEXT DISC: "+str(self.var_disc_n)+" COPY: "+str(self.var_copy_n)
                                     +" INDEX: "+str(var_index)+" STEP: "+str(self.var_step))
                 self.txtInfo.append("\n")
   No newline at end of file
                 if var_index == 0 :
                     self.function_eject()
   No newline at end of file
                 elif self.var_step == 0:
                     self.function_iso()
                 elif self.var_step == 1:
                     self.function_burn()

bk_manager/trunk/functions/functions2.py +1 -1

             # -*- coding: utf-8 -*-
   No newline at end of file
   No newline at end of file
             from subprocess import *
             import sys
             import os
             import subprocess
             import commands
   No newline at end of file
             #----------------------------------------------------- Deteccion de los dispositivos de grabacion ---------------------------------------------------------------
   No newline at end of file
             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}'"
   No newline at end of file
                 var_output = commands.getstatusoutput(var_cmd)
                 if var_output[0] != 0:
                     self.txtInfo.append("No recording devices")
                 else:
                     var_devices = var_output[1].split('\n')
   No newline at end of file
                     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('')
   No newline at end of file
                     #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)
   No newline at end of file
             #----------------------------------- expulsa los dispositivos de grabacion --------------------------------------------
   No newline at end of file
             def eject_devices(self):
                 for var_dev in self.var_devices:
                     var_cmd = 'eject ' +  var_dev
                     commands.getstatusoutput(var_cmd)
   No newline at end of file
             #----------------------------------- listado de los dispositivos de grabacion seleccionados --------------------------------------------
   No newline at end of file
             def selected_devices(self):
                 self.var_devices=[]
                 if self.chkDevA.isChecked():
                     self.var_devices.append(str(self.txtDeviceA.text()))
                 if self.chkDevB.isChecked():
                     self.var_devices.append(str(self.txtDeviceB.text()))
                 if self.chkDevC.isChecked():
                     self.var_devices.append(str(self.txtDeviceC.text()))
                 if self.chkDevD.isChecked():
                     self.var_devices.append(str(self.txtDeviceD.text()))
   No newline at end of file
                 if len(self.var_devices) == 0:
                     return False
                 else:
                     return True
   No newline at end of file
   No newline at end of file
             #----------------------------------------------------- Inicializacion para pruebas---------------------------------------------------------------
   No newline at end of file
             def set_parameters_test(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(100.0)
                 self.txtDcapacity.setReadOnly(False)
   No newline at end of file
             def set_devices_test(self):
                 self.txtDeviceA.setText("/dev/scd0")
                 self.txtDeviceB.setText("/dev/scd1")
                 self.txtDeviceC.setText("/dev/scd2")
                 self.txtDeviceD.setText("/dev/scd3")
   No newline at end of file
   No newline at end of file
   No newline at end of file
             #----------------------------------------------------- crea parameters.conf ---------------------------------------------------------------
   No newline at end of file
             def make_parameters_conf(self):
                 var_file = open("parameters.conf","w")
                 var_file.write(self.var_Dpath+"\n") #0 Ruta de los datos
                 var_file.write(self.var_Rpath+"\n") #1 Ruta del proyecto
                 var_file.write(str(self.var_lstDtype)+"\n") #2 opcion Data Type
                 var_file.write(self.var_Dtype+"\n") #3 extension Data Type
                 var_file.write(self.var_Elabel+"\n") #4 etiqueta
                 var_file.write(str(self.var_Copys)+"\n") #5 Numero de copias
                 var_file.write(str(self.var_lstDcapacity)+"\n") #6 opcion Device Capacity
                 var_file.write(str(self.var_Dcapacity)+"\n") #7 tamaño Device Capacity
                 var_file.write(str(self.var_Discs)+"\n") #8 Numero de discos a grabar
             #    var_file.write(str(self.lstStartDay.currentIndex())+"\n") #9  Indice fecha inicial
             #    var_file.write(str(self.lstStopDay.currentIndex())+"\n") #10  Indice fecha final
                 var_file.close()
   No newline at end of file
             #----------------------------------------------------- carga parameters.conf ---------------------------------------------------------------
   No newline at end of file
             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])) #7
                 self.var_Discs = int(lines[8]) #8
             #    var_StartDay = int(lines[6]) #9
             #    var_StopDay = int(lines[7]) #10
             ################################
                 self.var_Copys = self.txtCopys.value() #5
             ################################
   No newline at end of file
                 var_file.close()
   No newline at end of file
   No newline at end of file
             #-------------------------- actualiza el valor de las variables con los parametros seleccionados -----------------------------
   No newline at end of file
             def set_vars(self):
                 self.var_Dpath = str(self.txtDpath.text()) #0
                 self.var_Rpath = str(self.txtRpath.text()) #1
                 self.var_lstDtype = self.lstDtype.currentIndex() #2
                 self.var_Dtype = str(self.txtDtype.text()) #3
                 self.var_Elabel = str(self.txtElabel.text()) #4
                 self.var_Copys = self.txtCopys.value() #5
                 self.var_lstDcapacity = self.lstDcapacity.currentIndex() #6
                 self.var_Dcapacity = self.txtDcapacity.value() #7
                 self.var_Discs = self.var_Discs #8
   No newline at end of file
   No newline at end of file
             #-------------------------- crea burning.conf -----------------------------
   No newline at end of file
             def make_burning_conf(self):
                 var_file = open("burning.conf","w")
                 var_n_burned_discs = ( ( (self.var_disc_n - 1) * self.var_Copys) + self.var_copy_n - 1 )
  No newline at end of file
-                var_n_burned_discs = ( ( (self.var_disc_n - 1) * self.var_Copys) + self.var_copy_n -1 )
  No newline at end of file
                 var_file.write(str(var_n_burned_discs)+"\n") #0 Numero de discos ya grabados
                 var_file.write(str(self.var_disc_n)+"\n") #1 Disco actual para grabar
                 var_file.write(str(self.var_copy_n)+"\n") #2 Numero de copia actual para grabar
                 var_file.close()
   No newline at end of file
             #----------------------------------------------------- carga burning.conf ---------------------------------------------------------------
   No newline at end of file
             def get_burning_conf(self):
                 var_file = open("burning.conf","r")
                 lines = var_file.readlines()
                 self.var_burned_discs = int(lines[0]) #0
                 self.var_disc_n = int(lines[1])
                 self.var_copy_n = int(lines[2])
                 var_file.close()
   No newline at end of file
             #---------------------------------------------- Habilitacion y deshabilitacion de items -------------------------------------------------------
   No newline at end of file
             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.actionChange_Parameters.setEnabled(var_bool)
                 self.btnGbkp.setEnabled(not(var_bool))
                 self.btnRestart.setEnabled(var_bool)
                 self.btnStartburn.setEnabled(var_bool)
   No newline at end of file
   No newline at end of file
             def enabled_items2(var_bool, self):
                 self.btnRestart.setEnabled(not(var_bool))
                 self.btnStartburn.setEnabled(not(var_bool))
                 self.btnStopburn.setEnabled(var_bool)
                 self.chkCheck.setEnabled(not(var_bool))
                 self.actionChange_Parameters.setEnabled(False)
   No newline at end of file
   No newline at end of file
   No newline at end of file
   No newline at end of file
             #---------------------------------------------- Actualiza estado en los labels -------------------------------------------------------
   No newline at end of file
             def update_message(type, message, self,  index=0):
                 if index == 0:
                     var_index = ( ( (self.var_disc_n - 1) * self.var_Copys) + (self.var_copy_n - 1) - self.var_burned_discs ) % len(self.var_devices)
                 else:
                     var_index = index
   No newline at end of file
                 var_message = message
             #    var_message = "BURNING"
             #    var_message = "COMPLETED"
             #    var_message = "ERROR"
             #    var_message = "CHECKING"
             #    var_message = "CHECKED"
   No newline at end of file
                 if type == 1:
   No newline at end of file
                     if var_index == 0:
                         self.txtBstatusA.setText(var_message)
                         self.txtBdiscA.setText(str(self.var_disc_n))
                         self.txtBcopyA.setText(str(self.var_copy_n))
   No newline at end of file
                     if var_index == 1:
                         self.txtBstatusB.setText(var_message)
                         self.txtBdiscB.setText(str(self.var_disc_n))
                         self.txtBcopyB.setText(str(self.var_copy_n))
   No newline at end of file
                     if var_index == 2:
                         self.txtBstatusC.setText(var_message)
                         self.txtBdiscC.setText(str(self.var_disc_n))
                         self.txtBcopyC.setText(str(self.var_copy_n))
   No newline at end of file
                     if var_index == 3:
                         self.txtBstatusD.setText(var_message)
                         self.txtBdiscD.setText(str(self.var_disc_n))
                         self.txtBcopyD.setText(str(self.var_copy_n))
   No newline at end of file
                 if type == 2:
   No newline at end of file
                     if var_index == 0:
                         self.txtCHstatusA.setText(var_message)
   No newline at end of file
                     if var_index == 1:
                         self.txtCHstatusB.setText(var_message)
   No newline at end of file
                     if var_index == 2:
                         self.txtCHstatusC.setText(var_message)
   No newline at end of file
                     if var_index == 3:
                         self.txtCHstatusD.setText(var_message)
   No newline at end of file
   No newline at end of file

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

             # -*- coding: utf-8 -*-
   No newline at end of file
             """
             Module implementing MainWindow.
             """
   No newline at end of file
             from PyQt4.QtGui import QMainWindow
             from PyQt4.QtCore import pyqtSignature
             from PyQt4 import QtCore
             from Ui_MainWindow import Ui_MainWindow
             from Ui_Parameters import Ui_Parameters
             from Ui_About import Ui_About
             from PyQt4 import QtGui
             from subprocess import *
             import sys
             import os
             #import subprocess
             import time
             import commands
             from functions import functions
             from functions import functions2
   No newline at end of file
             class MainWindow(QMainWindow, Ui_MainWindow):
                 """
                 Class documentation goes here.
                 """
   No newline at end of file
                 def __init__(self, parent = None):
                     QMainWindow.__init__(self, parent)
                     self.setupUi(self)
                     self.setupUi2()
   No newline at end of file
                 def setupUi2(self):
                     self.var_real_iso = True
-                    self.var_real = False
+             No newline at end of file
                     self.var_real_burn = False
-  No newline at end of file
+             No newline at end of file
+                    self.var_real_check = False
              No newline at end of file
+                    self.var_real_eject = False
  No newline at end of file
                     # Reconocimiento de los dispositivos de grabacion
             #        functions2.detect_devices(self) #busca los dispositivos de grabacion
                     ####################################
                     functions2.set_devices_test(self) ############
                     ####################################
   No newline at end of file
                     #Inicialiazacion de variables
                     self.var_Discs = 0 #Numero de discos del proyecto
                     self.var_Copys = 0 #Numero de copias
                     self.var_disc_n = 0 # disco actual
                     self.var_copy_n = 0 # copia actual
                     self.var_burned_discs = 0 #numero de discos ya grabados
   No newline at end of file
                     self.bool_first_iso = False
                     self.var_step = 0 # numero de paso en el proceso
                     self.bool_state_burning = False #si es True se puede grabar
                     self.blank_discs = False # Si es true significa que se acaban de ingresar discos en blanco
   No newline at end of file
                     self.var_list=[] # Lista de DOYs
                     self.var_sublist=[] # Sub-lista de DOYs seleccionados
                     self.var_devices=[] #Lista de dispositivos seleccionados
   No newline at end of file
                     #Revisa si existe el archivo de confirguracion y lo carga
                     if os.path.isfile("parameters.conf"):
                         functions2.get_parameters_conf(self)
                         self.bool_first_iso = True
                         self.txtInfo.append("Parameters were loaded from configuration file")
                         self.txtInfo.append("Total number of discs for recording: "+str(self.var_Discs * self.var_Copys))
   No newline at end of file
                     else:
                         functions2.set_parameters_test(self) #Establece ciertos parametros, para pruebas
   No newline at end of file
                     functions2.set_vars(self) #Carga las variables de la clase con los parametros seleccionados
   No newline at end of file
                     self.statusDpath = functions.dir_exists(self.var_Dpath,  self)
                     self.statusRpath = functions.dir_exists(self.var_Rpath,  self)
                     functions.load_days(self)
   No newline at end of file
                     if os.path.isfile("parameters.conf"):
                         functions2.enabled_items1(True, self) #Se bloquean los parametros de configuracion
   No newline at end of file
                     if os.path.isfile("burning.conf"):
                         functions2.get_burning_conf(self)
                         self.txtInfo.append("Current disc: "+str(self.var_disc_n))
                         self.txtInfo.append("Current copy: "+str(self.var_copy_n))
                         self.txtInfo.append("Burned discs: "+str(self.var_burned_discs))
                         self.btnStartburn.setText("Continue")
                         self.actionChange_Parameters.setEnabled(False)
  No newline at end of file
              No newline at end of file
-  No newline at end of file
   No newline at end of file
                     self.connect(self.actionChange_Parameters, QtCore.SIGNAL("triggered()"), self.changeParameters)
                     self.connect(self.actionAbout, QtCore.SIGNAL("triggered()"), self.about)
   No newline at end of file
                     self.process_iso = QtCore.QProcess()
                     self.connect(self.process_iso,  QtCore.SIGNAL('readyReadStandardOutput()'),  self.readOuput_iso)
                     self.connect(self.process_iso,  QtCore.SIGNAL('readyReadStandardError()'),  self.readError_iso)
                     self.connect(self.process_iso,  QtCore.SIGNAL('finished(int,QProcess::ExitStatus)'),  self.finished_iso)
   No newline at end of file
                     self.process_burn = QtCore.QProcess()
                     self.connect(self.process_burn,  QtCore.SIGNAL('readyReadStandardOutput()'),  self.readOuput_burn)
                     self.connect(self.process_burn,  QtCore.SIGNAL('readyReadStandardError()'),  self.readError_burn)
                     self.connect(self.process_burn,  QtCore.SIGNAL('finished(int,QProcess::ExitStatus)'),  self.finished_burn)
   No newline at end of file
                     self.process_check = QtCore.QProcess()
                     self.connect(self.process_check,  QtCore.SIGNAL('readyReadStandardOutput()'),  self.readOuput_check)
                     self.connect(self.process_check,  QtCore.SIGNAL('readyReadStandardError()'),  self.readError_check)
                     self.connect(self.process_check,  QtCore.SIGNAL('finished(int,QProcess::ExitStatus)'),  self.finished_check)
   No newline at end of file
   No newline at end of file
                 def changeParameters(self):
                     dlg=QtGui.QDialog()
                     dlgui=Ui_Parameters()
                     dlgui.setupUi(dlg)
                     if (dlg.exec_() == QtGui.QDialog.Accepted):
                         if dlgui.txtDisc.value() > self.var_Discs or dlgui.txtCopy.value() > dlgui.txtNcopys.value():
                             self.txtInfo.append("Wrong parameters")
                         else:
                             self.var_Copys = dlgui.txtNcopys.value()
                             self.var_disc_n = dlgui.txtDisc.value()
                             self.var_copy_n = dlgui.txtCopy.value()
                             self.txtInfo.append("Changed parameters")
                             self.var_burned_discs = ( ( (self.var_disc_n - 1) * self.var_Copys) + self.var_copy_n -1 )
                             self.bool_first_iso = True
+                            self.txtInfo.append("Current disc: "+str(self.var_disc_n))
              No newline at end of file
+                            self.txtInfo.append("Current copy: "+str(self.var_copy_n))
              No newline at end of file
+                            self.txtInfo.append("Nro Copys: "+str(self.var_Copys))
              No newline at end of file
+                            functions2.make_parameters_conf(self)
              No newline at end of file
+                            self.txtCopys.setValue(self.var_Copys) #Actualizo mananualmente el valor Copys
  No newline at end of file
   No newline at end of file
   No newline at end of file
   No newline at end of file
                 def about(self):
                     dlg_about=QtGui.QDialog()
                     dlgui_about=Ui_About()
                     dlgui_about.setupUi(dlg_about)
                     dlg_about.exec_()
   No newline at end of file
   No newline at end of file
             #==============================================================================
             #   Manejo de los eventos
             #==============================================================================
   No newline at end of file
             #----------------------------------------------------- Obtencion de la ruta de los datos  ---------------------------------------------------------------
   No newline at end of file
                 @pyqtSignature("")
                 def on_btnDpath_clicked(self):
                     """
                     Permite seleccionar graficamente el direcorio de los datos a grabar
                     """
                     self.var_Dpath= str(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)
   No newline at end of file
   No newline at end of file
                 @pyqtSignature("")
                 def on_txtDpath_editingFinished(self):
                     """
                     Carga la ruta editada y verifica que sea correcta y carga la lista de dias
                     """
                     self.var_Dpath=str(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)
   No newline at end of file
   No newline at end of file
             #----------------------------------------------------- Obtencion de las ruta del proyecto ---------------------------------------------------------------
   No newline at end of file
                 @pyqtSignature("")
                 def on_btnRpath_clicked(self):
                     """
                     Permite seleccionar graficamente el direcorio del proyecto
                     """
                     self.var_Rpath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './',  QtGui.QFileDialog.ShowDirsOnly))
                     self.txtRpath.setText(self.var_Rpath)
                     self.statusRpath = functions.dir_exists(self.var_Rpath,  self)
   No newline at end of file
   No newline at end of file
                 @pyqtSignature("")
                 def on_txtRpath_editingFinished(self):
                     """
                     Valida la ruta del proyecto
                     """
                     self.var_Rpath = str(self.txtRpath.text()) #Se carga la variable con la ruta recien editada
                     self.statusRpath = functions.dir_exists(self.var_Rpath,  self)
   No newline at end of file
   No newline at end of file
             #----------------------------------------------------- Tipo de datos ---------------------------------------------------------------
   No newline at end of file
                 @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)
   No newline at end of file
                     self.txtDtype.setText(self.var_Dtype)
                     functions.load_days(self) #llamada a funcion
   No newline at end of file
                 @pyqtSignature("")
                 def on_txtDtype_editingFinished(self):
                     self.var_Dtype=str(self.txtDtype.text())
                     functions.load_days(self) #llamada a funcion
   No newline at end of file
   No newline at end of file
             #----------------------------------------------------- Etiqueta ---------------------------------------------------------------
   No newline at end of file
                 @pyqtSignature("")
                 def on_txtElabel_editingFinished(self):
                     self.var_Elabel = str(self.txtElabel.text())
   No newline at end of file
             #----------------------------------------------------- Numero de copias ---------------------------------------------------------------
                 @pyqtSignature("")
                 def on_txtCopys_editingFinished(self):
                     self.var_Copys = self.txtCopys.value()
   No newline at end of file
             #----------------------------------------------------- Seleccion del rango de fechas ---------------------------------------------------------------
   No newline at end of file
                 @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()
   No newline at end of file
                     for i in self.var_list[index:]:
                         self.lstStopDay.addItem(i)
   No newline at end of file
                     self.lstStopDay.setCurrentIndex(self.lstStopDay.count() - var_StopDay_index)
   No newline at end of file
                     functions.get_sub_list(self)
   No newline at end of file
   No newline at end of file
                 @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()
   No newline at end of file
                     for i in self.var_list[:len(self.var_list) - var_end_index + 1]:
                         self.lstStartDay.addItem(i)
   No newline at end of file
                     self.lstStartDay.setCurrentIndex(var_StartDay_index)
   No newline at end of file
                     functions.get_sub_list(self)
   No newline at end of file
   No newline at end of file
             #----------------------------------------------------- Capacidad del dispositivo de grabacion ---------------------------------------------------------------
   No newline at end of file
                 @pyqtSignature("")
                 def on_txtDcapacity_editingFinished(self):
                     self.var_Dcapacity = self.txtDcapacity.value()
   No newline at end of file
   No newline at end of file
                 @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
   No newline at end of file
                     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)
   No newline at end of file
                     self.var_lstDcapacity = self.lstDcapacity.currentIndex()
                     self.var_Dcapacity = self.txtDcapacity.value()
   No newline at end of file
             #----------------------------------------------------- Testeo de las unidades de grabacion ---------------------------------------------------------------
   No newline at end of file
                 @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)
   No newline at end of file
                 @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)
   No newline at end of file
                 @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)
   No newline at end of file
                 @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)
   No newline at end of file
   No newline at end of file
             #==============================================================================
             #   Botones para la generacion de los archivos de configuracion
             #==============================================================================
   No newline at end of file
             #----------------------------------------------------- Generacion de la configuracion usando los parametros ---------------------------------------------------------------
   No newline at end of file
                 @pyqtSignature("")
                 def on_btnGbkp_clicked(self):
                     """
                     Generacion de archivos de configuracion usando los parametros
                     """
   No newline at end of file
                     if functions.validate_parameters(self) == False:
                         return
   No newline at end of file
                     #Crea las carpetas en la ruta del proyecto y verifica que se crearon correctamente
                     list_dirs=['gpath','iso','ppath', 'tmpdata']
                     bool_make_dirs = functions.make_dirs(list_dirs,  self)
                     if bool_make_dirs == False:
                         return
   No newline at end of file
                     var_files_list = functions.list_files(self) #Se obtiene la lista de archivos a grabar
   No newline at end of file
                     self.var_Discs = functions.make_files_dat(var_files_list,  self) #Se crean los archivos .dat
   No newline at end of file
                     functions.make_files_print(self) # Se crean los archivos .print
   No newline at end of file
                     functions2.make_parameters_conf(self) # se crea el archivo parameters.conf
   No newline at end of file
                     self.txtInfo.append("Total number of discs for recording: "+str(self.var_Discs * self.var_Copys))
   No newline at end of file
                     #Se bloquean los parametros de configuracion
                     functions2.enabled_items1(True, self)
                     self.var_disc_n = 1
                     self.var_copy_n = 1
                     self.bool_first_iso = True
                     self.var_burned_discs = 0 #numero de discos grabados
   No newline at end of file
   No newline at end of file
             #----------------------------------------------------- Permite reiniciar la configuracion ---------------------------------------------------------------
   No newline at end of file
                 @pyqtSignature("")
                 def on_btnRestart_clicked(self):
                     """
                     Permite que se puedan cambiar los parametros
                     """
                     if os.path.isfile("parameters.conf"):
                         os.remove("parameters.conf")
                     if os.path.isfile("burning.conf"):
                         os.remove("burning.conf")
   No newline at end of file
                     functions2.enabled_items1(False, self)
                     self.btnStartburn.setText("Start Burn")
   No newline at end of file
   No newline at end of file
   No newline at end of file
             #==============================================================================
             #   Acciones de los procesos
             #==============================================================================
   No newline at end of file
             #------------------------------------------------ Funciones del proceso de creacion del iso ------------------------------------------------------
   No newline at end of file
                 def readOuput_iso(self):
                     self.txtProgress.setText("stdout iso: " + QtCore.QString(self.process_iso.readAllStandardOutput()))
   No newline at end of file
                 def readError_iso(self):
                     self.txtProgress.setText("stderr iso: " + QtCore.QString(self.process_iso.readAllStandardError()))
   No newline at end of file
                 def finished_iso(self):
                     self.txtProgress.clear()
   No newline at end of file
                     if not(self.bool_state_burning):
                         return
   No newline at end of file
                     if self.process_iso.exitCode() == 0:
                         self.txtInfo.append("------Iso file: "+functions.i2s(self.var_disc_n)+" created successfully\n")
  No newline at end of file
-                        self.txtInfo.append("------Iso file: "+functions.i2s(self.var_disc_n)+" created successfully")
  No newline at end of file
                         self.var_step = 1
                         self.function_burn()
   No newline at end of file
                     else:
                         self.txtInfo.append("#####Error creating iso file "+function.i2s(self.var_disc_n)
                                             +" , code "+QtCore.QString(self.process_iso.exitCode()))
                         self.txtInfo.append("Please check the data")
                         self.txtInfo.append("FATAL ERROR")
             #----------------------------------------------------- Funciones del proceso de grabado ---------------------------------------------------------------
  No newline at end of file
             #----------------------------------------------------- Funciones del proceso de grabado ---------------------------------------------------------------
                 def readOuput_burn(self):
  No newline at end of file
                 def readOuput_burn(self):
                     self.txtProgress.setText("stdout burn: " + QtCore.QString(self.process_burn.readAllStandardOutput()))
                 def readError_burn(self):
  No newline at end of file
                 def readError_burn(self):
                     self.txtProgress.setText("stderr burn: " + QtCore.QString(self.process_burn.readAllStandardError()))
                 def finished_burn(self):
  No newline at end of file
                 def finished_burn(self):
                     self.txtProgress.clear()
                     #Si se paro el proceso manualmente se termina
  No newline at end of file
                     #Si se paro el proceso manualmente se termina
                     if not(self.bool_state_burning):
              No newline at end of file
              No newline at end of file
-                    functions2.make_burning_conf(self) # Si el proceso no ha sido detenido manualmente
              No newline at end of file
-                    #crea el archivo burning.conf para el seguimiento de los discos grabados
  No newline at end of file
                         return
                     if self.process_burn.exitCode() == 0:
  No newline at end of file
                     if self.process_burn.exitCode() == 0:
                         self.txtInfo.append("-----Complete recording, disc: "+str(self.var_disc_n)+" copy: "+str(self.var_copy_n))
                         functions2.update_message(1, "COMPLETED",  self)
                         self.var_step = 2
                         self.function_check()
                     else:
  No newline at end of file
                     else:
                         self.txtInfo.append("#######Error recording, disc: "+function.i2s(self.var_disc_n)+" copy: "
                                             +function.i2s(self.var_copy_n)+", code "+QtCore.QString(self.process_burn.exitCode()))
                         functions2.update_message(1, "ERROR",  self)
                         functions.is_last_disc_and_copy(self)
  No newline at end of file
                         functions.is_last_disc_and_copy(self)
   No newline at end of file
             #----------------------------------------------------- Funciones del proceso de verificacion ---------------------------------------------------------------
  No newline at end of file
             #----------------------------------------------------- Funciones del proceso de verificacion ---------------------------------------------------------------
                 def readOuput_check(self):
  No newline at end of file
                 def readOuput_check(self):
                     self.txtProgress.setText("stdout check: " + QtCore.QString(self.process_check.readAllStandardOutput()))
                 def readError_check(self):
  No newline at end of file
                 def readError_check(self):
                     self.txtProgress.setText("stderr check: " + QtCore.QString(self.process_check.readAllStandardError()))
                 def finished_check(self):
  No newline at end of file
                 def finished_check(self):
                     self.txtProgress.clear()
                     if not(self.bool_state_burning):
  No newline at end of file
                     if not(self.bool_state_burning):
                         return
                     if self.process_check.exitCode() == 0:
  No newline at end of file
                     if self.process_check.exitCode() == 0:
                         self.txtInfo.append("--------Complete checking, disc: "+str(self.var_disc_n)+" copy: "+str(self.var_copy_n))
                         functions2.update_message(2, "CHECKED",  self)
                     else:
  No newline at end of file
                     else:
                         self.txtInfo.append("#######Error checking, disc: "+function.i2s(self.var_disc_n)+" copy: "
                                             +function.i2s(self.var_copy_n)+", code "+QtCore.QString(self.process_check.exitCode()))
                         functions2.update_message(2, "ERROR",  self)
                     functions.is_last_disc_and_copy(self)
  No newline at end of file
                     functions.is_last_disc_and_copy(self)
   No newline at end of file
   No newline at end of file
             #==============================================================================
  No newline at end of file
             #==============================================================================
             #   Botones para el proceso de grabacion
             #==============================================================================
             #----------------------------------------------------- Iniciar proceso de grabacion ---------------------------------------------------------------  
  No newline at end of file
             #----------------------------------------------------- Iniciar proceso de grabacion ---------------------------------------------------------------
                 @pyqtSignature("")
  No newline at end of file
                 @pyqtSignature("")
                 def on_btnStartburn_clicked(self):
                     """
                     Se inicia el proceso de grabacion
                     """
                     #Verifica que exista algun dispositivo de grabacion seleccionado
                     if not(functions2.selected_devices(self)):
                         self.txtInfo.append("There is no recording device selected")
                         return
             #        #Lista los dispositivos de grabacion a usar
  No newline at end of file
             #        #Lista los dispositivos de grabacion a usar
             #        for dev in self.var_devices:
             #            self.txtInfo.append("recording device :"+dev)
                     self.bool_state_burning = True
  No newline at end of file
                     self.bool_state_burning = True
                     functions2.enabled_items2(True, self)
                     if self.bool_first_iso == True:
  No newline at end of file
                     if self.bool_first_iso == True:
                         self.txtInfo.append("BUTTON: on_btnStartburn_clicked")
                         self.var_step = 4
                         self.function_eject()
                         return
                     if self.var_step == 0:
  No newline at end of file
                     if self.var_step == 0:
                         self.function_iso()
                         return
                     if self.var_step == 1:
  No newline at end of file
                     if self.var_step == 1:
                         self.function_burn()
                         return
             #----------------------------------------------------- Funcion para el grabado ---------------------------------------------------------------  
  No newline at end of file
             #----------------------------------------------------- Funcion para el grabado ---------------------------------------------------------------
                 def function_iso(self):
  No newline at end of file
                 def function_iso(self):
                     #Creacion del archivo.iso para la grabacion
                     if self.var_step == 0:
                         self.txtInfo.append("########## Disc number: "+str(self.var_disc_n)+"##########")
                         self.txtInfo.append("------Creating iso file number: "+str(self.var_disc_n))
   No newline at end of file
-                        if self.var_real == True:
  No newline at end of file
                         if self.var_real_iso == True:
                             var_cmd = functions.cmd_iso(self)
                         else:
                             self.txtInfo.append('**function_iso')
                             var_cmd="echo 'function_iso'"
                         self.process_iso.start(var_cmd)
  No newline at end of file
                         self.process_iso.start(var_cmd)
                 def function_burn(self):
  No newline at end of file
                 def function_burn(self):
                     #Grabacion de los DVDs
   No newline at end of file
-                        self.txtInfo.append("------Recording disc: "+str(self.var_copy_n)+", copy:"+str(self.var_copy_n))
  No newline at end of file
                     if self.var_step == 1:
                         self.txtInfo.append("------Recording disc: "+str(self.var_disc_n)+", copy:"+str(self.var_copy_n))
                         functions2.update_message(1, "BURNING",  self)
  No newline at end of file
-                        if self.var_real == True:
  No newline at end of file
                             var_cmd = functions.cmd_burn(self)
  No newline at end of file
+                        if self.var_real_burn == True:
              No newline at end of file
+                            var_cmd = functions.cmd_burn(self)
              No newline at end of file
+                            #########################################
              No newline at end of file
+                            return######################################
  No newline at end of file
                             ########################################
                             self.txtInfo.append('**function_burn')
  No newline at end of file
                         else:
                             self.txtInfo.append('**function_burn')
                             var_cmd="echo 'function_burn'"
   No newline at end of file
                         self.process_burn.start(var_cmd)
                     #Verificacion de los discos
  No newline at end of file
                 def function_check(self):
                     #Verificacion de los discos
  No newline at end of file
-                        self.txtInfo.append("-----------checking disc:"+str(self.var_copy_n)+", copy:"+str(self.var_copy_n))
  No newline at end of file
                     if self.var_step == 2:
                         self.txtInfo.append("-----------checking disc:"+str(self.var_disc_n)+", copy:"+str(self.var_copy_n))
                         functions2.update_message(2, "CHECKING",  self)
  No newline at end of file
-                        if self.var_real == True:
  No newline at end of file
                             var_cmd = functions.cmd_check(self)
  No newline at end of file
                         if self.var_real_check == True:
                             var_cmd = functions.cmd_check(self)
                         else:
                             self.txtInfo.append('**function_check')
                             var_cmd="echo 'function_check'"
   No newline at end of file
                         self.process_check.start(var_cmd)
                 def function_eject(self):
  No newline at end of file
                 #OK
                 def function_eject(self):
                     self.txtInfo.append("Ejecting recording devices")
                     self.txtInfo.append("Please insert blank discs")
  No newline at end of file
-                    if self.var_real == True:
  No newline at end of file
                         functions2.eject_devices(self) # Expulsa las bandejas de los dispostivos de grabacion
  No newline at end of file
                     if self.var_real_eject == True:
                         functions2.eject_devices(self) # Expulsa las bandejas de los dispostivos de grabacion
                     else:
                         self.txtInfo.append("**functions2.eject_devices")
                     self.btnStartburn.setEnabled(True)
  No newline at end of file
                     self.btnStartburn.setText("Continue")
                     self.btnStartburn.setEnabled(True)
                         self.bool_first_iso = False
  No newline at end of file
                     if self.bool_first_iso == True:
                         self.bool_first_iso = False
                         self.var_step = 0
                         self.var_step = 0
  No newline at end of file
                     elif self.var_copy_n == 1:
                         self.var_step = 0
                         self.var_step = 1
  No newline at end of file
                     else:
                         self.var_step = 1
                     self.txtInfo.append("Recording process is complete")
  No newline at end of file
                 def function_final(self):
                     self.txtInfo.append("Recording process is complete")
   No newline at end of file
             #----------------------------------------------------- Detener proceso de grabacion ---------------------------------------------------------------  
  No newline at end of file
   No newline at end of file
             #----------------------------------------------------- Detener proceso de grabacion ---------------------------------------------------------------
                 def on_btnStopburn_clicked(self):
  No newline at end of file
                 @pyqtSignature("")
                 def on_btnStopburn_clicked(self):
                     """
                     Slot documentation goes here.
                     """
                     self.bool_state_burning = False
                         self.process_iso.terminate()  #Termina el proceso, si puede 
  No newline at end of file
                     if self.var_step == 0:
                         self.process_iso.terminate()  #Termina el proceso, si puede
             #            self.process_iso.kill() #Mata el proceso, no es la forma adecuada, solo usar si terminate() no funciona
                     elif self.var_step == 1:
                         self.process_burn.terminate()
                     elif self.var_step == 2:
                         self.process_check.terminate()
                     functions2.enabled_items2(False, self)   
  No newline at end of file
                     self.txtInfo.append("Stopped recording")
                     functions2.enabled_items2(False, self)
                     self.bool_first_iso = True
   No newline at end of file
             #==============================================================================
  No newline at end of file
             #   Proceso verificacion manual
  No newline at end of file
             #==============================================================================
             #   Proceso verificacion manual
             #==============================================================================
             #----------------------------------------------------- Proceso de verificaion manual ---------------------------------------------------------------  
  No newline at end of file
   No newline at end of file
             #----------------------------------------------------- Proceso de verificaion manual ---------------------------------------------------------------
                 @pyqtSignature("")
  No newline at end of file
                 def on_btnTDpath_clicked(self):
  No newline at end of file
                 @pyqtSignature("")
                 def on_btnTDpath_clicked(self):
                     """
                     Slot documentation goes here.
                     """
                     self.var_TDpath= str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './',  QtGui.QFileDialog.ShowDirsOnly))
                     self.txtTDpath.setText(self.var_TDpath)
                     self.statusTDpath = functions.dir_exists(self.var_TDpath,  self)
                 @pyqtSignature("")
  No newline at end of file
                 def on_btnCHstart_clicked(self):
  No newline at end of file
                 @pyqtSignature("")
                 def on_btnCHstart_clicked(self):
                     """
                     Slot documentation goes here.

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