|
|
# -*- coding: utf-8 -*-
|
|
|
"""
|
|
|
Module implementing MainWindow.
|
|
|
#+ ######################INTERFAZ DE USUARIO V1.1##################
|
|
|
"""
|
|
|
from PyQt4.QtGui import QMainWindow
|
|
|
from PyQt4.QtCore import pyqtSignature
|
|
|
from PyQt4.QtCore import pyqtSignal
|
|
|
|
|
|
from PyQt4 import QtCore
|
|
|
from PyQt4 import QtGui
|
|
|
|
|
|
from timeconversions import Doy2Date
|
|
|
|
|
|
from modelProperties import person_class
|
|
|
from modelProperties import TreeItem
|
|
|
|
|
|
|
|
|
from viewer.ui_window import Ui_window
|
|
|
from viewer.ui_mainwindow import Ui_MainWindow
|
|
|
from viewer.ui_workspace import Ui_Workspace
|
|
|
from viewer.ui_initwindow import Ui_InitWindow
|
|
|
|
|
|
from controller1 import Project,ReadBranch,ProcBranch,UP,UPSUB,UP2SUB,Operation,Parameter
|
|
|
|
|
|
import os
|
|
|
|
|
|
HORIZONTAL_HEADERS = ("ITEM :"," DATOS : " )
|
|
|
|
|
|
HORIZONTAL = ("RAMA :",)
|
|
|
|
|
|
class MainWindow(QMainWindow, Ui_MainWindow):
|
|
|
"""
|
|
|
Class documentation goes here.
|
|
|
#*##################VENTANA CUERPO DEL PROGRAMA####################
|
|
|
"""
|
|
|
closed=pyqtSignal()
|
|
|
def __init__(self, parent = None):
|
|
|
"""
|
|
|
Constructor
|
|
|
1-CARGA DE ARCHIVOS DE CONFIGURACION SI EXISTIERA.SI EXISTE EL ARCHIVO PROYECT.xml
|
|
|
2- ESTABLECE CIERTOS PARAMETROS PARA PRUEBAS
|
|
|
3- CARGA LAS VARIABLES DE LA CLASE CON LOS PARAMETROS SELECCIONADOS
|
|
|
4-VALIDACION DE LA RUTA DE LOS DATOS Y DEL PROYECTO
|
|
|
5-CARGA LOS DOYS ENCONTRADOS PARA SELECCIONAR EL RANGO
|
|
|
6-CARGA UN PROYECTO
|
|
|
"""
|
|
|
|
|
|
print "Inicio de Programa"
|
|
|
QMainWindow.__init__(self, parent)
|
|
|
|
|
|
self.setupUi(self)
|
|
|
|
|
|
QtGui.QToolTip.setFont(QtGui.QFont('SansSerif', 10))
|
|
|
self.addoBtn.setToolTip('Add_Unit_Process')
|
|
|
self.addbBtn.setToolTip('Add_Branch')
|
|
|
self.addpBtn.setToolTip('Add_New_Project')
|
|
|
self.ventanaproject=0
|
|
|
|
|
|
self.var=0
|
|
|
self.variableList=[] # Lista de DOYs
|
|
|
self.iniciodisplay=0
|
|
|
self.year=0
|
|
|
self.OpMode=0
|
|
|
self.starTem=0
|
|
|
self.endTem=0
|
|
|
#*###################1########################
|
|
|
if os.path.isfile("Proyect.xml"):
|
|
|
self.getParam()
|
|
|
self.textedit.append("Parameters were loaded from configuration file")
|
|
|
#*###################2########################
|
|
|
else:
|
|
|
self.setParam()
|
|
|
#*###################3#########################
|
|
|
self.setVariables()
|
|
|
#*###################4#########################
|
|
|
self.statusDpath = self.existDir(self.dataPath)
|
|
|
#self.statusRpath = self.dir_exists(self.var_Rpath, self)
|
|
|
#*###################5 ########################
|
|
|
self.loadYears()
|
|
|
self.loadDays()
|
|
|
#================================
|
|
|
|
|
|
self.model = QtGui.QStandardItemModel()
|
|
|
self.treeView.setModel(self.model)
|
|
|
self.treeView.clicked.connect(self.treefunction1)
|
|
|
#==========Project==========#
|
|
|
self.projectObjList= []
|
|
|
self.ProjectObj=0
|
|
|
self.Pro=0
|
|
|
self.proObjList=[]
|
|
|
self.valuep=1
|
|
|
self.namep=0
|
|
|
self.idp=0
|
|
|
self.refresh=0
|
|
|
self.countBperPObjList= []
|
|
|
#===========Branch==========#
|
|
|
self.branchObjList=[]
|
|
|
self.BranchObj=0
|
|
|
self.braObjList=[]
|
|
|
self.Bra=0
|
|
|
self.idb=0
|
|
|
self.nameb=0
|
|
|
self.countVperBObjList= []
|
|
|
#===========Voltage==========#
|
|
|
self.voltageObjList=[]
|
|
|
self.VoltageObj=0
|
|
|
self.Vol=0
|
|
|
self.volObjList=[]
|
|
|
self.idv=0
|
|
|
self.namev=0
|
|
|
#===========Spectra==========#
|
|
|
self.spectraObjList=[]
|
|
|
self.SpectraObj=0
|
|
|
self.Spec=0
|
|
|
self.specObjList=[]
|
|
|
self.ids=0
|
|
|
self.names=0
|
|
|
#===========Correlation==========#
|
|
|
self.correlationObjList=[]
|
|
|
self.CorrelationObj=0
|
|
|
self.Cor=0
|
|
|
self.corObjList=[]
|
|
|
self.idc=0
|
|
|
self.namec=0
|
|
|
self.datatype=0
|
|
|
|
|
|
#=================
|
|
|
#self.window=Window()
|
|
|
self.Workspace=Workspace()
|
|
|
#self.DataType=0
|
|
|
|
|
|
|
|
|
#*###################
|
|
|
|
|
|
def treefunction1(self, index):
|
|
|
a= index.model().itemFromIndex(index).text()
|
|
|
print a
|
|
|
b=a[8:10]
|
|
|
self.valuep=b
|
|
|
c=a[0:7]
|
|
|
self.namep=c
|
|
|
|
|
|
# def ventanaconfigura(self):
|
|
|
# '''
|
|
|
# METODO QUE SE ENCARGA DE LLAMAR A LA CLASE
|
|
|
# VENTANA CONFIGURACION DE PROYECTO
|
|
|
# '''
|
|
|
# self.Luna =Workspace(self)
|
|
|
# self.Luna.closed.connect(self.show)
|
|
|
# self.Luna.show()
|
|
|
# self.hide()
|
|
|
|
|
|
# def closeEvent(self, event):
|
|
|
# self.closed.emit()
|
|
|
# event.accept()
|
|
|
|
|
|
#+######################BARRA DE MENU###################
|
|
|
|
|
|
# *####################MENU FILE #########################
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_actionabrirObj_triggered(self):
|
|
|
"""
|
|
|
Ubicado en la Barra de Menu, OPCION FILE, CARGA UN ARCHIVO DE CONFIGURACION ANTERIOR
|
|
|
"""
|
|
|
# TODO: not implemented yet
|
|
|
#raise NotImplementedError
|
|
|
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_actioncrearObj_triggered(self):
|
|
|
"""
|
|
|
CREACION DE UN NUEVO EXPERIMENTO
|
|
|
"""
|
|
|
self.on_addpBtn_clicked()
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_actionguardarObj_triggered(self):
|
|
|
"""
|
|
|
GUARDAR EL ARCHIVO DE CONFIGURACION XML
|
|
|
"""
|
|
|
# TODO: not implemented yet
|
|
|
#raise NotImplementedError
|
|
|
self.SaveConfig()
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_actionCerrarObj_triggered(self):
|
|
|
"""
|
|
|
CERRAR LA APLICACION GUI
|
|
|
"""
|
|
|
self.close()
|
|
|
|
|
|
#*######################### MENU RUN ##################
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_actionStartObj_triggered(self):
|
|
|
"""
|
|
|
EMPEZAR EL PROCESAMIENTO.
|
|
|
"""
|
|
|
# TODO: not implemented yet
|
|
|
#raise NotImplementedErr
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_actionPausaObj_triggered(self):
|
|
|
"""
|
|
|
PAUSAR LAS OPERACIONES
|
|
|
"""
|
|
|
# TODO: not implemented yet
|
|
|
# raise NotImplemente
|
|
|
|
|
|
#*###################MENU OPTIONS######################
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_actionconfigLogfileObj_triggered(self):
|
|
|
"""
|
|
|
Slot Documentation goes here
|
|
|
"""
|
|
|
self.Luna = Workspace(self)
|
|
|
#print self.Luna.dirCmbBox.currentText()
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_actionconfigserverObj_triggered(self):
|
|
|
"""
|
|
|
CONFIGURACION DE SERVIDOR.
|
|
|
"""
|
|
|
# TODO: not implemented yet
|
|
|
#raise NotImplementedError
|
|
|
|
|
|
#*################# MENU HELPS##########################
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_actionAboutObj_triggered(self):
|
|
|
"""
|
|
|
Slot documentation goes here.
|
|
|
"""
|
|
|
# TODO: not implemented yet
|
|
|
#raise NotImplementedError
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_actionPrfObj_triggered(self):
|
|
|
"""
|
|
|
Slot documentation goes here.
|
|
|
"""
|
|
|
# TODO: not implemented yet
|
|
|
#raise NotImplementedError
|
|
|
|
|
|
#+##################################################
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_actionOpenObj_triggered(self):
|
|
|
"""
|
|
|
Slot documentation goes here.
|
|
|
"""
|
|
|
# TODO: not implemented yet
|
|
|
#raise No
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_actioncreateObj_triggered(self):
|
|
|
"""
|
|
|
Slot documentation goes here.
|
|
|
"""
|
|
|
self.on_addpBtn_clicked()
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_actionstopObj_triggered(self):
|
|
|
"""
|
|
|
CARGA UN ARCHIVO DE CONFIGURACION ANTERIOR
|
|
|
"""
|
|
|
# TODO: not implemented yet
|
|
|
#raise NotImplementedError
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_actionPlayObj_triggered(self):
|
|
|
"""
|
|
|
EMPEZAR EL PROCESAMIENTO.
|
|
|
"""
|
|
|
# TODO: not implemented yet
|
|
|
#raise NotImplementedError
|
|
|
|
|
|
#*################VENTANA EXPLORADOR DE PROYECTOS######################
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_addpBtn_clicked(self):
|
|
|
"""
|
|
|
AADIR UN NUEVO PROYECTO
|
|
|
"""
|
|
|
self.windowshow()
|
|
|
self.idp += 1
|
|
|
self.Pro=Project()
|
|
|
self.proObjList.append(self.Pro)
|
|
|
self.parentItem=self.model.invisibleRootItem()
|
|
|
self.ProjectObj = QtGui.QStandardItem(QtCore.QString("Project %0").arg(self.idp))
|
|
|
self.parentItem.appendRow(self.ProjectObj)
|
|
|
self.projectObjList.append(self.ProjectObj)
|
|
|
self.parentItem=self.ProjectObj
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_addbBtn_clicked(self):
|
|
|
"""
|
|
|
AÑADIR UNA RAMA DE PROCESAMIENTO
|
|
|
"""
|
|
|
#print self.valuep
|
|
|
#print self.namep
|
|
|
#print self.valueb
|
|
|
|
|
|
#if self.namep ==str("Project"):
|
|
|
self.idb += 1
|
|
|
self.Bra=self.proObjList[int(self.valuep)-1].addProcBranch(id=self.idb,name='Branch')
|
|
|
self.braObjList.append(self.Bra)
|
|
|
self.parentItem=self.projectObjList[int(self.valuep)-1]
|
|
|
#=
|
|
|
self.countBperPObjList.append(self.valuep)
|
|
|
# LisBperP=self.countBperPObjList
|
|
|
|
|
|
self.BranchObj= QtGui.QStandardItem(QtCore.QString("Branch %1 ").arg(self.idb))
|
|
|
self.parentItem.appendRow(self.BranchObj)
|
|
|
self.branchObjList.append(self.BranchObj)
|
|
|
self.parentItem=self.BranchObj
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_addoBtn_clicked(self):
|
|
|
"""
|
|
|
AÑADIR UN TIPO DE PROCESAMIENTO.
|
|
|
"""
|
|
|
if self.namep ==str("Project"):
|
|
|
self.totalTree()
|
|
|
#=====================
|
|
|
if self.namep ==str("Voltage"):
|
|
|
self.ids += 1
|
|
|
self.Spec=self.volObjList[int(self.valuep)-1].addUPSUB(id=self.ids, name='Spectra', type='Pri')
|
|
|
self.specObjList.append(self.Spec)
|
|
|
self.parentItem=self.voltageObjList[int(self.valuep)-1]
|
|
|
self.SpectraObj= QtGui.QStandardItem(QtCore.QString("Spectra %2").arg(self.ids))
|
|
|
self.parentItem.appendRow(self.SpectraObj)
|
|
|
self.spectraObjList.append(self.SpectraObj)
|
|
|
self.parentItem=self.SpectraObj
|
|
|
|
|
|
if self.namep ==str("Spectra"):
|
|
|
self.idc += 1
|
|
|
self.Cor=self.specObjList[int(self.valuep)-1].addUP2SUB(id=self.idc, name='Correlation', type='Pri')
|
|
|
self.corObjList.append(self.Cor)
|
|
|
self.parentItem=self.spectraObjList[int(self.valuep)-1]
|
|
|
self.CorrelationObj= QtGui.QStandardItem(QtCore.QString("Correlation %3").arg(self.idc))
|
|
|
self.parentItem.appendRow(self.CorrelationObj)
|
|
|
self.correlationObjList.append(self.CorrelationObj)
|
|
|
self.parentItem=self.CorrelationObj
|
|
|
|
|
|
if self.namep == str("Branch "):
|
|
|
if self.DataType== str("r"):
|
|
|
self.idv += 1
|
|
|
if len(self.valuep)==0:
|
|
|
print "construir rama"
|
|
|
else:
|
|
|
self.Vol=self.braObjList[int(self.valuep)-1].addUP(id=self.idv, name='Voltage', type='Pri')
|
|
|
self.volObjList.append(self.Vol)
|
|
|
self.parentItem=self.branchObjList[int(self.valuep)-1]
|
|
|
self.VoltageObj= QtGui.QStandardItem(QtCore.QString("Voltage %2").arg(self.idv))
|
|
|
self.parentItem.appendRow(self.VoltageObj)
|
|
|
self.voltageObjList.append(self.VoltageObj)
|
|
|
self.parentItem=self.VoltageObj
|
|
|
|
|
|
if self.DataType== str("pdata"):
|
|
|
self.ids += 1
|
|
|
if len(self.valuep)==0:
|
|
|
print "construir rama"
|
|
|
else:
|
|
|
self.Spec=self.braObjList[int(self.valuep)-1].addUPSUB(id=self.ids, name='Spectra', type='Pri')
|
|
|
self.specObjList.append(self.Spec)
|
|
|
self.parentItem=self.branchObjList[int(self.valuep)-1]
|
|
|
self.SpectraObj= QtGui.QStandardItem(QtCore.QString("Spectra %2").arg(self.ids))
|
|
|
self.parentItem.appendRow(self.SpectraObj)
|
|
|
self.spectraObjList.append(self.SpectraObj)
|
|
|
self.parentItem=self.SpectraObj
|
|
|
|
|
|
def totalTree(self):
|
|
|
b= self.proObjList[int(self.valuep)-1]
|
|
|
b.procBranchObjList # Objetos de tipo Branch
|
|
|
print "Project"+str(self.valuep) +"Branch",
|
|
|
for i in range(0 , len(b.procBranchObjList)):
|
|
|
print b.procBranchObjList[i].id, #objetos de tipo branch 1,2,3 o 4,5 o 6
|
|
|
print ""
|
|
|
for i in range(0 , len(b.procBranchObjList)):
|
|
|
print "Branch"+ str(b.procBranchObjList[i].id)
|
|
|
|
|
|
for i in range(0 , len(b.procBranchObjList)):
|
|
|
print b.procBranchObjList[i].id
|
|
|
c= self.braObjList[(b.procBranchObjList[i].id)-1]
|
|
|
c.upsubObjList
|
|
|
for i in range(0,len(c.upsubObjList)):
|
|
|
print "Spectra"+str(c.upsubObjList[i].id),
|
|
|
#*********************VENTANA CONFIGURACION DE PROYECTOS************************************
|
|
|
|
|
|
#***********************PESTAÑA DE PROYECTOS************************
|
|
|
|
|
|
#*************************MODO BASICO O AVANZADO*****************
|
|
|
|
|
|
@pyqtSignature("QString")
|
|
|
def on_operationModeCmbBox_activated(self, p0):
|
|
|
"""
|
|
|
Slot documentation goes here.
|
|
|
"""
|
|
|
pass
|
|
|
|
|
|
#***********************TIPOS DE DATOS A GRABAR******************************
|
|
|
|
|
|
@pyqtSignature("int")
|
|
|
def on_dataFormatCmbBox_activated(self,index):
|
|
|
"""
|
|
|
SE EJECUTA CUANDO SE ELIGE UN ITEM DE LA LISTA
|
|
|
ADEMAS SE CARGA LA LISTA DE DIAS SEGUN EL TIPO DE ARCHIVO SELECCIONADO
|
|
|
"""
|
|
|
self.dataFormatTxt.setReadOnly(True)
|
|
|
if index == 0:
|
|
|
self.DataType ='r'
|
|
|
elif index == 1:
|
|
|
self.DataType ='pdata'
|
|
|
else :
|
|
|
self.DataType =''
|
|
|
self.dataFormatTxt.setReadOnly(False)
|
|
|
self.dataFormatTxt.setText(self.DataType)
|
|
|
# self.loadDays(self)
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_dataPathBrowse_clicked(self):
|
|
|
"""
|
|
|
OBTENCION DE LA RUTA DE DATOS
|
|
|
"""
|
|
|
self.dataPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
|
|
|
self.dataPathTxt.setText(self.dataPath)
|
|
|
self.statusDpath=self.existDir(self.dataPath)
|
|
|
self.loadYears()
|
|
|
self.loadDays()
|
|
|
|
|
|
@pyqtSignature("int")
|
|
|
def on_starDateCmbBox_activated(self, index):
|
|
|
"""
|
|
|
SELECCION DEL RANGO DE FECHAS -STAR DATE
|
|
|
"""
|
|
|
var_StopDay_index=self.endDateCmbBox.count() - self.endDateCmbBox.currentIndex()
|
|
|
self.endDateCmbBox.clear()
|
|
|
for i in self.variableList[index:]:
|
|
|
self.endDateCmbBox.addItem(i)
|
|
|
self.endDateCmbBox.setCurrentIndex(self.endDateCmbBox.count() - var_StopDay_index)
|
|
|
self.getsubList()
|
|
|
|
|
|
@pyqtSignature("int")
|
|
|
def on_endDateCmbBox_activated(self, index):
|
|
|
"""
|
|
|
SELECCION DEL RANGO DE FECHAS-END DATE
|
|
|
"""
|
|
|
var_StartDay_index=self.starDateCmbBox.currentIndex()
|
|
|
var_end_index = self.endDateCmbBox.count() - index
|
|
|
self.starDateCmbBox.clear()
|
|
|
for i in self.variableList[:len(self.variableList) - var_end_index + 1]:
|
|
|
self.starDateCmbBox.addItem(i)
|
|
|
self.starDateCmbBox.setCurrentIndex(var_StartDay_index)
|
|
|
self.getsubList() #Se carga var_sublist[] con el rango de las fechas seleccionadas
|
|
|
|
|
|
@pyqtSignature("QString")
|
|
|
def on_readModeCmBox_activated(self, p0):
|
|
|
"""
|
|
|
Slot documentation goes here.
|
|
|
"""
|
|
|
print self.readModeCmBox.currentText()
|
|
|
|
|
|
@pyqtSignature("int")
|
|
|
def on_initialTimeSlider_valueChanged(self, initvalue):
|
|
|
"""
|
|
|
SELECCION DE LA HORA DEL EXPERIMENTO -INITIAL TIME
|
|
|
"""
|
|
|
self.iniciodisplay=initvalue
|
|
|
self.initialtimeLcd.display(initvalue)
|
|
|
self.starTem=initvalue
|
|
|
|
|
|
@pyqtSignature("int")
|
|
|
def on_finalTimeSlider_valueChanged(self, finalvalue):
|
|
|
"""
|
|
|
SELECCION DE LA HORA DEL EXPERIMENTO -FINAL TIME
|
|
|
"""
|
|
|
finalvalue = self.iniciodisplay + finalvalue
|
|
|
if finalvalue >24:
|
|
|
finalvalue = 24
|
|
|
self.finaltimeLcd.display(finalvalue)
|
|
|
self.endTem=finalvalue
|
|
|
|
|
|
@pyqtSignature("QString")
|
|
|
def on_yearCmbBox_activated(self, year):
|
|
|
"""
|
|
|
SELECCION DEL AÑO
|
|
|
"""
|
|
|
self.year = year
|
|
|
#print self.year
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_dataCancelBtn_clicked(self):
|
|
|
"""
|
|
|
SAVE- BUTTON CANCEL
|
|
|
"""
|
|
|
# TODO: not implemented yet
|
|
|
#raise NotImplementedError
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_dataOkBtn_clicked(self):
|
|
|
"""
|
|
|
SAVE-BUTTON OK
|
|
|
"""
|
|
|
#print self.ventanaproject.almacena()
|
|
|
print "alex"
|
|
|
print self.Workspace.dirCmbBox.currentText()
|
|
|
self.model_2=treeModel()
|
|
|
#lines = unicode(self.textEdit_2.toPlainText()).split('\n')
|
|
|
#print lines
|
|
|
if self.ventanaproject.almacena()==None:
|
|
|
name=str(self.namep)
|
|
|
name=str(self.ventanaproject.almacena())
|
|
|
|
|
|
self.model_2.setParams(name=name,
|
|
|
directorio=str(self.dataPathTxt.text()),
|
|
|
workspace=str(self.Workspace.dirCmbBox.currentText()),
|
|
|
opmode=str(self.operationModeCmbBox.currentText()),
|
|
|
remode=str(self.readModeCmBox.currentText()),
|
|
|
dataformat=str(self.dataFormatTxt.text()),
|
|
|
date=str(self.starDateCmbBox.currentText())+"-"+str(self.endDateCmbBox.currentText()),
|
|
|
initTime=str( self.starTem),
|
|
|
endTime=str(self.endTem),
|
|
|
timezone="Local" )
|
|
|
# Summary=str(self.textEdit_2.textCursor()))
|
|
|
self.model_2.arbol()
|
|
|
self.treeView_2.setModel(self.model_2)
|
|
|
self.treeView_2.expandAll()
|
|
|
|
|
|
#*############METODOS PARA EL PATH-YEAR-DAYS###########################
|
|
|
|
|
|
def existDir(self, var_dir):
|
|
|
"""
|
|
|
METODO PARA VERIFICAR SI LA RUTA EXISTE-VAR_DIR
|
|
|
VARIABLE DIRECCION
|
|
|
"""
|
|
|
if os.path.isdir(var_dir):
|
|
|
return True
|
|
|
else:
|
|
|
self.textEdit.append("Incorrect path:" + str(var_dir))
|
|
|
return False
|
|
|
|
|
|
def loadYears(self):
|
|
|
"""
|
|
|
METODO PARA SELECCIONAR EL AÑO
|
|
|
"""
|
|
|
self.variableList=[]
|
|
|
self.yearCmbBox.clear()
|
|
|
if self.statusDpath == False:
|
|
|
self.dataOkBtn.setEnabled(False)
|
|
|
return
|
|
|
if self.DataType == '':
|
|
|
return
|
|
|
|
|
|
Dirlist = os.listdir(self.dataPath)
|
|
|
|
|
|
for y in range(0, len(Dirlist)):
|
|
|
fyear= Dirlist[y]
|
|
|
fyear = fyear[1:5]
|
|
|
Dirlist[y]=fyear
|
|
|
|
|
|
Dirlist=list(set(Dirlist))
|
|
|
Dirlist.sort()
|
|
|
|
|
|
if len(Dirlist) == 0:
|
|
|
self.textEdit.append("File not found")
|
|
|
self.dataOkBtn.setEnabled(False)
|
|
|
return
|
|
|
#Se cargan las listas para seleccionar StartDay y StopDay (QComboBox)
|
|
|
for i in range(0, (len(Dirlist))):
|
|
|
self.variableList.append(Dirlist[i])
|
|
|
for i in self.variableList:
|
|
|
self.yearCmbBox.addItem(i)
|
|
|
|
|
|
def loadDays(self):
|
|
|
"""
|
|
|
METODO PARA CARGAR LOS DIAS
|
|
|
"""
|
|
|
self.variableList=[]
|
|
|
self.starDateCmbBox.clear()
|
|
|
self.endDateCmbBox.clear()
|
|
|
|
|
|
Dirlist = os.listdir(self.dataPath)
|
|
|
Dirlist.sort()
|
|
|
|
|
|
for a in range(0, len(Dirlist)):
|
|
|
fname= Dirlist[a]
|
|
|
Doy=fname[5:8]
|
|
|
fname = fname[1:5]
|
|
|
print fname
|
|
|
fecha=Doy2Date(int(fname),int(Doy))
|
|
|
fechaList=fecha.change2date()
|
|
|
#print fechaList[0]
|
|
|
Dirlist[a]=fname+"-"+str(fechaList[0])+"-"+str(fechaList[1])
|
|
|
#+"-"+ fechaList[0]+"-"+fechaList[1]
|
|
|
|
|
|
#---------------AQUI TIENE QUE SER MODIFICADO--------#
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#Se cargan las listas para seleccionar StartDay y StopDay (QComboBox)
|
|
|
for i in range(0, (len(Dirlist))):
|
|
|
self.variableList.append(Dirlist[i])
|
|
|
|
|
|
for i in self.variableList:
|
|
|
self.starDateCmbBox.addItem(i)
|
|
|
self.endDateCmbBox.addItem(i)
|
|
|
self.endDateCmbBox.setCurrentIndex(self.starDateCmbBox.count()-1)
|
|
|
|
|
|
self.getsubList()
|
|
|
self.dataOkBtn.setEnabled(True)
|
|
|
|
|
|
def getsubList(self):
|
|
|
"""
|
|
|
OBTIENE EL RANDO DE LAS FECHAS SELECCIONADAS
|
|
|
"""
|
|
|
self.subList=[]
|
|
|
for i in self.variableList[self.starDateCmbBox.currentIndex():self.starDateCmbBox.currentIndex() + self.endDateCmbBox.currentIndex()+1]:
|
|
|
self.subList.append(i)
|
|
|
|
|
|
#*################ METODO PARA GUARDAR ARCHIVO DE CONFIGURACION #################
|
|
|
# def SaveConfig(self):
|
|
|
#
|
|
|
# desc = "Este es un test"
|
|
|
# filename=str(self.workspace.dirCmbBox.currentText())+"\\"+"Config"+str(self.valuep)+".xml"
|
|
|
# projectObj=self.proObjList[int(self.valuep)-1]
|
|
|
# projectObj.setParms(id =int(self.valuep),name=str(self.namep),description=desc)
|
|
|
# print self.valuep
|
|
|
# print self.namep
|
|
|
#
|
|
|
# readBranchObj = projectObj.addReadBranch(id=str(self.valuep),
|
|
|
# dpath=str(self.dataPathTxt.text()),
|
|
|
# dataformat=str(self.dataFormatTxt.text()),
|
|
|
# opMode=str(self.operationModeCmbBox.currentText()),
|
|
|
# readMode=str(self.readModeCmBox.currentText()),
|
|
|
# startDate=str(self.starDateCmbBox.currentText()),
|
|
|
# endDate=str(self.endDateCmbBox.currentText()),
|
|
|
# startTime=str(self.starTem),
|
|
|
# endTime=str(self.endTem))
|
|
|
#
|
|
|
#
|
|
|
# branchNumber= len(projectObj.procBranchObjList) #Numero de Ramas
|
|
|
# #=======================readBranchObj==============
|
|
|
# for i in range(0,branchNumber):
|
|
|
# projectObj.procBranchObjList[i]
|
|
|
# idb=projectObj.procBranchObjList[i].id
|
|
|
# # opObjTotal={}
|
|
|
#
|
|
|
# for j in range(0,branchNumber):
|
|
|
# idb=projectObj.procBranchObjList[j].id
|
|
|
# branch=self.braObjList[(idb)-1]
|
|
|
# branch.upObjList
|
|
|
# volNumber=len(branch.upObjList)
|
|
|
# for i in range(0,volNumber):
|
|
|
# unitProcess=branch.upObjList[i]
|
|
|
# idv=branch.upObjList[i].id
|
|
|
#
|
|
|
# opObj11 = unitProcess.addOperation(id=1,name='removeDC', priority=1)
|
|
|
# opObj11.addParameter(name='type', value='1')
|
|
|
# opObj2 = unitProcess.addOperation(id=2,name='removeInterference', priority=1)
|
|
|
# opObj3 = unitProcess.addOperation(id=3,name='removeSatelites', priority=1)
|
|
|
# opObj4 = unitProcess.addOperation(id=4,name='coherent Integration', priority=1)
|
|
|
#
|
|
|
# projectObj.writeXml(filename)
|
|
|
#
|
|
|
#*############METODOS PARA INICIALIZAR-CONFIGURAR-CARGAR ARCHIVO-CARGAR VARIABLES########################
|
|
|
|
|
|
def setParam(self):
|
|
|
"""
|
|
|
INICIALIZACION DE PARAMETROS PARA PRUEBAS
|
|
|
"""
|
|
|
#self.dataProyectTxt.setText('Test')
|
|
|
self.dataFormatTxt.setText('r')
|
|
|
self.dataPathTxt.setText('C:\\Users\\alex\\Documents\\ROJ\\ew_drifts')
|
|
|
self.dataWaitTxt.setText('0')
|
|
|
|
|
|
def make_parameters_conf(self):
|
|
|
"""
|
|
|
ARCHIVO DE CONFIGURACION cCRA parameters.conf
|
|
|
"""
|
|
|
pass
|
|
|
|
|
|
def getParam(self):
|
|
|
"""
|
|
|
CARGA Proyect.xml
|
|
|
"""
|
|
|
print "Archivo XML AUN No adjuntado"
|
|
|
|
|
|
def setVariables(self):
|
|
|
"""
|
|
|
ACTUALIZACION DEL VALOR DE LAS VARIABLES CON LOS PARAMETROS SELECCIONADOS
|
|
|
"""
|
|
|
self.dataPath = str(self.dataPathTxt.text()) #0
|
|
|
self.DataType= str(self.dataFormatTxt.text()) #3
|
|
|
|
|
|
def windowshow(self):
|
|
|
self.ventanaproject= Window(self)
|
|
|
self.ventanaproject.closed.connect(self.show)
|
|
|
self.ventanaproject.show()
|
|
|
# self.window()
|
|
|
# self.window.closed.connect(self.show)
|
|
|
# self.window.show()
|
|
|
#self.hide()
|
|
|
|
|
|
def closeEvent(self, event):
|
|
|
self.closed.emit()
|
|
|
event.accept()
|
|
|
|
|
|
|
|
|
class treeModel(QtCore.QAbstractItemModel):
|
|
|
'''
|
|
|
a model to display a few names, ordered by encabezado
|
|
|
'''
|
|
|
name=None
|
|
|
directorio=None
|
|
|
workspace=None
|
|
|
opmode=None
|
|
|
remode=None
|
|
|
dataformat=None
|
|
|
date=None
|
|
|
initTime=None
|
|
|
endTime=None
|
|
|
timezone=None
|
|
|
#Summary=None
|
|
|
|
|
|
def __init__(self ,parent=None):
|
|
|
super(treeModel, self).__init__(parent)
|
|
|
self.people = []
|
|
|
|
|
|
def arbol(self):
|
|
|
for caracteristica,principal, descripcion in (("Properties","Name",self.name),
|
|
|
("Properties","Data Path",self.directorio),
|
|
|
("Properties","Workspace",self.workspace),
|
|
|
("Properties","Operation Mode ",self.opmode),
|
|
|
("Parameters", "Read Mode ",self.remode),
|
|
|
("Parameters", "DataFormat ",self.dataformat),
|
|
|
("Parameters", "Date ",self.date),
|
|
|
("Parameters", "Init Time ",self.initTime),
|
|
|
("Parameters", "Final Time ",self.endTime),
|
|
|
("Parameters", " Time zone ",self.timezone),
|
|
|
("Parameters", "Profiles ","1"),
|
|
|
# ("Description", "Summary ", self.Summary),
|
|
|
):
|
|
|
person = person_class(caracteristica, principal, descripcion)
|
|
|
self.people.append(person)
|
|
|
|
|
|
self.rootItem = TreeItem(None, "ALL", None)
|
|
|
self.parents = {0 : self.rootItem}
|
|
|
self.setupModelData()
|
|
|
|
|
|
#def veamos(self):
|
|
|
# self.update= MainWindow(self)
|
|
|
# self.update.dataProyectTxt.text()
|
|
|
# return self.update.dataProyectTxt.text()
|
|
|
def setParams(self,name,directorio,workspace,opmode,remode,dataformat,date,initTime,endTime,timezone):
|
|
|
self.name=name
|
|
|
self.workspace=workspace
|
|
|
self.directorio= directorio
|
|
|
self.opmode=opmode
|
|
|
self.remode=remode
|
|
|
self.dataformat=dataformat
|
|
|
self.date=date
|
|
|
self.initTime=initTime
|
|
|
self.endTime=endTime
|
|
|
self.timezone=timezone
|
|
|
#self.Summary=Summary
|
|
|
|
|
|
|
|
|
def columnCount(self, parent=None):
|
|
|
if parent and parent.isValid():
|
|
|
return parent.internalPointer().columnCount()
|
|
|
else:
|
|
|
return len(HORIZONTAL_HEADERS)
|
|
|
|
|
|
def data(self, index, role):
|
|
|
if not index.isValid():
|
|
|
return QtCore.QVariant()
|
|
|
|
|
|
item = index.internalPointer()
|
|
|
if role == QtCore.Qt.DisplayRole:
|
|
|
return item.data(index.column())
|
|
|
if role == QtCore.Qt.UserRole:
|
|
|
if item:
|
|
|
return item.person
|
|
|
|
|
|
return QtCore.QVariant()
|
|
|
|
|
|
def headerData(self, column, orientation, role):
|
|
|
if (orientation == QtCore.Qt.Horizontal and
|
|
|
role == QtCore.Qt.DisplayRole):
|
|
|
try:
|
|
|
return QtCore.QVariant(HORIZONTAL_HEADERS[column])
|
|
|
except IndexError:
|
|
|
pass
|
|
|
|
|
|
return QtCore.QVariant()
|
|
|
|
|
|
def index(self, row, column, parent):
|
|
|
if not self.hasIndex(row, column, parent):
|
|
|
return QtCore.QModelIndex()
|
|
|
|
|
|
if not parent.isValid():
|
|
|
parentItem = self.rootItem
|
|
|
else:
|
|
|
parentItem = parent.internalPointer()
|
|
|
|
|
|
childItem = parentItem.child(row)
|
|
|
if childItem:
|
|
|
return self.createIndex(row, column, childItem)
|
|
|
else:
|
|
|
return QtCore.QModelIndex()
|
|
|
|
|
|
def parent(self, index):
|
|
|
if not index.isValid():
|
|
|
return QtCore.QModelIndex()
|
|
|
|
|
|
childItem = index.internalPointer()
|
|
|
if not childItem:
|
|
|
return QtCore.QModelIndex()
|
|
|
|
|
|
parentItem = childItem.parent()
|
|
|
|
|
|
if parentItem == self.rootItem:
|
|
|
return QtCore.QModelIndex()
|
|
|
|
|
|
return self.createIndex(parentItem.row(), 0, parentItem)
|
|
|
|
|
|
def rowCount(self, parent=QtCore.QModelIndex()):
|
|
|
if parent.column() > 0:
|
|
|
return 0
|
|
|
if not parent.isValid():
|
|
|
p_Item = self.rootItem
|
|
|
else:
|
|
|
p_Item = parent.internalPointer()
|
|
|
return p_Item.childCount()
|
|
|
|
|
|
def setupModelData(self):
|
|
|
for person in self.people:
|
|
|
if person.descripcion:
|
|
|
encabezado = person.caracteristica
|
|
|
|
|
|
|
|
|
if not self.parents.has_key(encabezado):
|
|
|
newparent = TreeItem(None, encabezado, self.rootItem)
|
|
|
self.rootItem.appendChild(newparent)
|
|
|
|
|
|
self.parents[encabezado] = newparent
|
|
|
|
|
|
parentItem = self.parents[encabezado]
|
|
|
newItem = TreeItem(person, "", parentItem)
|
|
|
parentItem.appendChild(newItem)
|
|
|
|
|
|
def searchModel(self, person):
|
|
|
'''
|
|
|
get the modelIndex for a given appointment
|
|
|
'''
|
|
|
def searchNode(node):
|
|
|
'''
|
|
|
a function called recursively, looking at all nodes beneath node
|
|
|
'''
|
|
|
for child in node.childItems:
|
|
|
if person == child.person:
|
|
|
index = self.createIndex(child.row(), 0, child)
|
|
|
return index
|
|
|
|
|
|
if child.childCount() > 0:
|
|
|
result = searchNode(child)
|
|
|
if result:
|
|
|
return result
|
|
|
|
|
|
retarg = searchNode(self.parents[0])
|
|
|
#print retarg
|
|
|
return retarg
|
|
|
|
|
|
def find_GivenName(self, principal):
|
|
|
app = None
|
|
|
for person in self.people:
|
|
|
if person.principal == principal:
|
|
|
app = person
|
|
|
break
|
|
|
if app != None:
|
|
|
index = self.searchModel(app)
|
|
|
return (True, index)
|
|
|
return (False, None)
|
|
|
|
|
|
|
|
|
|
|
|
class Workspace(QMainWindow, Ui_Workspace):
|
|
|
"""
|
|
|
Class documentation goes here.
|
|
|
"""
|
|
|
closed=pyqtSignal()
|
|
|
def __init__(self, parent = None):
|
|
|
"""
|
|
|
Constructor
|
|
|
"""
|
|
|
QMainWindow.__init__(self, parent)
|
|
|
self.setupUi(self)
|
|
|
#*####### DIRECTORIO DE TRABAJO #########*#
|
|
|
self.dirCmbBox.setItemText(0, QtGui.QApplication.translate("MainWindow", "C:\WorkSpaceGui", None, QtGui.QApplication.UnicodeUTF8))
|
|
|
self.dir=str("C:\WorkSpaceGui")
|
|
|
self.dirCmbBox.addItem(self.dir)
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_dirBrowsebtn_clicked(self):
|
|
|
"""
|
|
|
Slot documentation goes here.
|
|
|
"""
|
|
|
self.dirBrowse = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
|
|
|
self.dirCmbBox.addItem(self.dirBrowse)
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_dirButton_clicked(self):
|
|
|
"""
|
|
|
Slot documentation goes here.
|
|
|
"""
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_dirOkbtn_clicked(self):
|
|
|
"""
|
|
|
VISTA DE INTERFAZ GRÃFICA
|
|
|
"""
|
|
|
self.showmemainwindow()
|
|
|
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_dirCancelbtn_clicked(self):
|
|
|
"""
|
|
|
Cerrar
|
|
|
"""
|
|
|
self.close()
|
|
|
|
|
|
def showmemainwindow(self):
|
|
|
self.Dialog= MainWindow(self)
|
|
|
self.Dialog.closed.connect(self.show)
|
|
|
self.Dialog.show()
|
|
|
self.hide()
|
|
|
|
|
|
def closeEvent(self, event):
|
|
|
self.closed.emit()
|
|
|
event.accept()
|
|
|
|
|
|
|
|
|
class InitWindow(QMainWindow, Ui_InitWindow):
|
|
|
"""
|
|
|
Class documentation goes here.
|
|
|
"""
|
|
|
def __init__(self, parent = None):
|
|
|
"""
|
|
|
Constructor
|
|
|
"""
|
|
|
QMainWindow.__init__(self, parent)
|
|
|
self.setupUi(self)
|
|
|
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_pushButton_2_clicked(self):
|
|
|
"""
|
|
|
Close First Window
|
|
|
"""
|
|
|
self.close()
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_pushButton_clicked(self):
|
|
|
"""
|
|
|
Show Workspace Window
|
|
|
"""
|
|
|
self.showmeconfig()
|
|
|
|
|
|
def showmeconfig(self):
|
|
|
'''
|
|
|
Method to call Workspace
|
|
|
'''
|
|
|
|
|
|
self.config=Workspace(self)
|
|
|
self.config.closed.connect(self.show)
|
|
|
self.config.show()
|
|
|
self.hide()
|
|
|
|
|
|
|
|
|
class Window(QMainWindow, Ui_window):
|
|
|
"""
|
|
|
Class documentation goes here.
|
|
|
"""
|
|
|
closed=pyqtSignal()
|
|
|
def __init__(self, parent = None):
|
|
|
"""
|
|
|
Constructor
|
|
|
"""
|
|
|
QMainWindow.__init__(self, parent)
|
|
|
self.setupUi(self)
|
|
|
self.name=0
|
|
|
self.nameproject=None
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_cancelButton_clicked(self):
|
|
|
"""
|
|
|
Slot documentation goes here.
|
|
|
"""
|
|
|
# TODO: not implemented yet
|
|
|
#raise NotImplementedError
|
|
|
self.hide()
|
|
|
|
|
|
@pyqtSignature("")
|
|
|
def on_okButton_clicked(self):
|
|
|
"""
|
|
|
Slot documentation goes here.
|
|
|
"""
|
|
|
# TODO: not implemented yet
|
|
|
#raise NotImplementedError
|
|
|
self.almacena()
|
|
|
print self.nameproject
|
|
|
self.close()
|
|
|
|
|
|
|
|
|
def almacena(self):
|
|
|
#print str(self.proyectNameLine.text())
|
|
|
self.nameproject=str(self.proyectNameLine.text())
|
|
|
return self.nameproject
|
|
|
|
|
|
def closeEvent(self, event):
|
|
|
self.closed.emit()
|
|
|
event.accept()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
