def accept(self):
#/ nome do metodo (logger)
#/ ----------------------------------------------------------------------------------------
l_szMetodo = "dlgEditPAR::accept"
#** ---------------------------------------------------------------------------------------
#* m.poirot logger
#*/
#l_log = logging.getLogger ( l_szMetodo )
#l_log.setLevel ( w_logLvl )
#l_log.debug ( ">> " )
#** ---------------------------------------------------------------------------------------
#* obtem os dados do sítio PAR
#*/
l_szKey = self.qleKey.text().toUpper()
l_szDescr = self.qleDescr.text().toUpper()
#** ---------------------------------------------------------------------------------------
#* obtem os valores de performance do sítio PAR
#*/
l_iCab = int(self.qsbCab.value())
l_fHAnt0 = float(self.qsbHAnt0.value())
l_fHAnt1 = float(self.qsbHAnt1.value())
l_fDstAntEixo = float(self.qsbDstAntEixo.value())
l_fDstAntPT0 = float(self.qsbDstAntPT0.value())
l_fDstAntPT1 = float(self.qsbDstAntPT1.value())
l_fAngRampa = float(self.qsbAngRampa.value())
l_iRetardo = int(self.qsbRetardo.value())
l_iDecl = int(self.qsbDecl.value())
#** ---------------------------------------------------------------------------------------
#* PAR inexistente ?
#*/
if (None == self._oPAR):
#** -----------------------------------------------------------------------------------
#* cria um novo sítio PAR
#*/
self._oPAR = clsPAR.clsPAR([
l_szKey, l_szDescr, l_iCab, l_fHAnt0, l_fHAnt1, l_fDstAntEixo,
l_fDstAntPT0, l_fDstAntPT1, l_fAngRampa, l_iRetardo, l_iDecl
])
#assert ( self._oPAR )
#** -----------------------------------------------------------------------------------
#* cria uma nova entrada na tabela de sítios PAR com o PAR criado
#*/
self._oSitPAR.add(self._oPAR, l_szKey)
#** ---------------------------------------------------------------------------------------
#* se existe, atualiza a informação
#*/
else:
#** -----------------------------------------------------------------------------------
#* atualiza os dados do sítio PAR
#*/
self._oSitPAR.updateTabela(self._oPAR, [
l_szKey, l_szDescr, l_iCab, l_fHAnt0, l_fHAnt1, l_fDstAntEixo,
l_fDstAntPT0, l_fDstAntPT1, l_fAngRampa, l_iRetardo, l_iDecl
])
#** ---------------------------------------------------------------------------------------
#* faz o "accept"
#*/
QtGui.QDialog.accept(self)
def populateFromData(self, f_lstData):
#/ globals
#/ ----------------------------------------------------------------------------------------
#global locDefs.xMAX_PAR
#/ nome do método (logger)
#/ ----------------------------------------------------------------------------------------
#l_szMetodo = "clsTabelaPAR::populateFromData"
#** ---------------------------------------------------------------------------------------
#* m.poirot logger
#*/
#l_log = logging.getLogger ( l_szMetodo )
#l_log.setLevel ( w_logLvl )
#l_log.debug ( ">> " )
#** ---------------------------------------------------------------------------------------
#* zera índices
#*/
l_iD = 0
#** ---------------------------------------------------------------------------------------
#* calcula o número de PARs na tabela
#*/
locDefs.xMAX_PAR = (len(f_lstData) // 11)
##l_log.info ( "locDefs.xMAX_PAR: " + str ( locDefs.xMAX_PAR ))
#** ---------------------------------------------------------------------------------------
#* cria a tabela de PARs
#*/
self._tabItens = [None for _ in xrange(locDefs.xMAX_PAR)]
#assert ( self._tabItens )
##l_log.info ( "self._tabItens: " + str ( self._tabItens ))
#** ---------------------------------------------------------------------------------------
#* carrega os dados da tabela de PARs
#*/
for _ in xrange(locDefs.xMAX_PAR):
##l_log.info ( "l_btPAR: " + str ( l_btPAR ))
#** -----------------------------------------------------------------------------------
#* chave do PAR
#*/
l_szKey = str(f_lstData[l_iD]).upper()
l_iD += 1
##l_log.info ( "_szKey: " + str ( l_szKey ))
#** -----------------------------------------------------------------------------------
#* descrição do PAR
#*/
l_szDescr = str(f_lstData[l_iD]).upper().replace('_', ' ')
l_iD += 1
##l_log.info ( "_szDescr: " + str ( l_szDescr ))
#** -----------------------------------------------------------------------------------
#* carrega as pistas
#*/
l_iCab0 = int(f_lstData[l_iD])
l_iD += 1
##l_log.info ( "_iCab0: " + str ( l_iCab0 ))
#** -----------------------------------------------------------------------------------
#* altura da antena relativo ao ponto toque principal
#*/
l_fHAnt0 = float(f_lstData[l_iD])
l_iD += 1
##l_log.info ( "_fHAnt0: " + str ( l_fHAnt0 ))
#** -----------------------------------------------------------------------------------
#* altura da antena relativo ao ponto toque secundário
#*/
l_fHAnt1 = float(f_lstData[l_iD])
l_iD += 1
##l_log.info ( "_fHAnt1: " + str ( l_fHAnt1 ))
#** -----------------------------------------------------------------------------------
#* afastamento da antena ao eixo da pista
#*/
l_fDstAntEixo = float(f_lstData[l_iD])
l_iD += 1
##l_log.info ( "_fDstAntEixo: " + str ( l_fDstAntEixo ))
#** -----------------------------------------------------------------------------------
#* distância da antena ao ponto toque principal
#*/
l_fDstAntPT0 = float(f_lstData[l_iD])
l_iD += 1
##l_log.info ( "_fDstAntPT0: " + str ( l_fDstAntPT0 ))
#** -----------------------------------------------------------------------------------
#* distância da antena ao ponto toque secundário
#*/
l_fDstAntPT1 = float(f_lstData[l_iD])
l_iD += 1
##l_log.info ( "_fDstAntPT1: " + str ( l_fDstAntPT1 ))
#** -----------------------------------------------------------------------------------
#* angulo da rampa de aproximacao
#*/
l_fAngRampa = float(f_lstData[l_iD])
l_iD += 1
##l_log.info ( "_fAngRampa: " + str ( l_fAngRampa ))
#** -----------------------------------------------------------------------------------
#* carrega os retardos
#*/
l_iRetardo = int(f_lstData[l_iD])
l_iD += 1
##l_log.info ( "_iRetardo: " + str ( l_iRetardo ))
#** -----------------------------------------------------------------------------------
#* declinação magnética do PAR
#*/
l_iDecl = int(f_lstData[l_iD])
l_iD += 1
##l_log.info ( "_iDecl: " + str ( l_iDecl ))
#** -----------------------------------------------------------------------------------
#* cria a PAR
#*/
l_PAR = clsPAR.clsPAR([
l_szKey, l_szDescr, l_iCab0, l_fHAnt0, l_fHAnt1, l_fDstAntEixo,
l_fDstAntPT0, l_fDstAntPT1, l_fAngRampa, l_iRetardo, l_iDecl
])
#assert ( l_PAR )
#** -----------------------------------------------------------------------------------
#* coloca o PAR na tabela de PARs
#*/
self.add(l_PAR, l_szKey)
#** ---------------------------------------------------------------------------------------
#* após a carga, reseta o flag dirty
#*/
self._bDirty = False
def loadConfigExe(self, f_szCfg):
#/ nome do método (logger)
#/ ----------------------------------------------------------------------------------------
#l_szMetodo = "modelPiloto::loadConfigExe"
#** ---------------------------------------------------------------------------------------
#* m.poirot logger
#*/
#l_log = logging.getLogger ( l_szMetodo )
#l_log.setLevel ( w_logLvl )
#l_log.debug ( ">> " )
#** ---------------------------------------------------------------------------------------
#* verifica condições de execução
#*/
#assert ( f_szCfg )
#l_log.info ( u"Configuração de exercício a carregar: " + f_szCfg )
#** ---------------------------------------------------------------------------------------
#* abre o arquivo de configuração
#*/
l_fdCfg = open(f_szCfg, "r")
#assert ( l_fdCfg )
#** ---------------------------------------------------------------------------------------
#* cria a área de dados
#*/
l_data = []
#** ---------------------------------------------------------------------------------------
#* percorre todas as linhas do arquivo de configuração
#*/
for l_line in l_fdCfg.readlines():
#** -----------------------------------------------------------------------------------
#* checa se é uma linha de comentário ou vazia
#*/
if ((not l_line.startswith("#"))
and (not l_line.startswith("\n"))):
#** -------------------------------------------------------------------------------
#* checa end-of-line
#*/
if (l_line.endswith("\n") or l_line.endswith("\x1a")):
#** ---------------------------------------------------------------------------
#* aceita o valor sem o end-of-line
#*/
l_data.extend(l_line[:-1].split())
#** -------------------------------------------------------------------------------
#*/
else:
#** ---------------------------------------------------------------------------
#* aceita o valor
#*/
l_data.extend(l_line.split())
#** ---------------------------------------------------------------------------------------
#* fecha o arquivo
#*/
l_fdCfg.close()
#** ---------------------------------------------------------------------------------------
#* carrega a parte do exercício
#*/
self._oExe = clsExe.clsExe(l_data[0:10])
#assert ( self._oExe )
#** ---------------------------------------------------------------------------------------
#* carrega a parte do PAR
#*/
l_oPAR = clsPAR.clsPAR(l_data[10:21])
#assert ( l_oPAR )
#** ---------------------------------------------------------------------------------------
#* salva o PAR no exercício
#*/
self._oExe.setPAR(l_oPAR)
#** ---------------------------------------------------------------------------------------
#* carrega a parte da aeronave
#*/
l_oAnv = clsAnv.clsAnv(l_data[21:28])
#assert ( l_oAnv )
#** ---------------------------------------------------------------------------------------
#* salva a aeronave no exercício
#*/
self._oExe.setAnv(l_oAnv)
#** ---------------------------------------------------------------------------------------
#* carrega a parte de comunicação
#*/
self._iCanal = int(l_data[28])
def loadQDataStream(self):
#/ nome do método (logger)
#/ ----------------------------------------------------------------------------------------
#l_szMetodo = "clsTabelaPAR::loadQDataStream"
#/ file descriptor
#/ ----------------------------------------------------------------------------------------
l_fdIn = None
#/ mensagem de erro
#/ ----------------------------------------------------------------------------------------
l_szErro = None
#** ---------------------------------------------------------------------------------------
#* m.poirot logger
#*/
#l_log = logging.getLogger ( l_szMetodo )
#l_log.setLevel ( w_logLvl )
#l_log.debug ( ">> " )
#** ---------------------------------------------------------------------------------------
#* tenta carregar o arquivo...
#*/
try:
#** -----------------------------------------------------------------------------------
#* abre o arquivo
#*/
l_fdIn = QtCore.QFile(self._szFName)
#assert ( l_fdIn )
#** -----------------------------------------------------------------------------------
#* erro na abertura ?
#*/
if (not l_fdIn.open(QtCore.QIODevice.ReadOnly)):
#** -------------------------------------------------------------------------------
#* gera exception
#*/
raise IOError, unicode(l_fdIn.errorString())
#** -----------------------------------------------------------------------------------
#* acessa o arquivo como uma stream de dados
#*/
l_stream = QtCore.QDataStream(l_fdIn)
#assert ( l_stream )
#** -----------------------------------------------------------------------------------
#* le o magic number
#*/
l_iMagic = l_stream.readInt32()
#** -----------------------------------------------------------------------------------
#* tipo de arquivo valido ?
#*/
if (clsTabelaModel.c_xxMAGIC_NUMBER != l_iMagic):
#** -------------------------------------------------------------------------------
#* gera exception
#*/
raise IOError, u"tipo de arquivo não reconhecido !"
#** -----------------------------------------------------------------------------------
#* le a versao do arquivo
#*/
l_iVersion = l_stream.readInt32()
#** -----------------------------------------------------------------------------------
#* versao muito antiga ?
#*/
if (l_iVersion < clsTabelaModel.c_xxOLD_FILE_VERSION):
#** -------------------------------------------------------------------------------
#* gera exception
#*/
raise IOError, u"formato do arquivo é antigo e não legível !"
#** -----------------------------------------------------------------------------------
#* versao nova ?
#*/
elif (l_iVersion > clsTabelaModel.c_xxFILE_VERSION):
#** -------------------------------------------------------------------------------
#* gera exception
#*/
raise IOError, u"formato do arquivo é novo e não legível !"
#** -----------------------------------------------------------------------------------
#*/
l_stream.setVersion(QtCore.QDataStream.Qt_4_2)
#** -----------------------------------------------------------------------------------
#*/
self.clear(False)
#** -----------------------------------------------------------------------------------
#* enquanto nao termina de ler a stream...
#*/
while (not l_stream.atEnd()):
#** -------------------------------------------------------------------------------
#* cria a área para chave do PAR
#*/
l_szKey = QtCore.QString()
#** -------------------------------------------------------------------------------
#* lê a chave do PAR
#*/
l_stream >> l_szKey
#** -------------------------------------------------------------------------------
#* cria a área para descrição do PAR
#*/
l_szDescr = QtCore.QString()
#** -------------------------------------------------------------------------------
#* lê a descrição do PAR
#*/
l_stream >> l_szDescr
l_szDescr = l_szDescr.replace('_', ' ')
#** -------------------------------------------------------------------------------
#* lê a cabeceira principal
#*/
l_iCab0 = l_stream.readInt()
#** -------------------------------------------------------------------------------
#* lê a altura da antena relativo ao ponto toque principal
#*/
l_fHAnt0 = l_stream.readFloat()
#** -------------------------------------------------------------------------------
#* lê a altura da antena relativo ao ponto toque secundário
#*/
l_fHAnt1 = l_stream.readFloat()
#** -------------------------------------------------------------------------------
#* lê o afastamento da antena ao eixo da pista
#*/
l_fDstAntEixo = l_stream.readFloat()
#** -------------------------------------------------------------------------------
#* lê a distância da antena ao ponto toque principal
#*/
l_fDstAntPT0 = l_stream.readFloat()
#** -------------------------------------------------------------------------------
#* lê a distância da antena ao ponto toque secundário
#*/
l_fDstAntPT1 = l_stream.readFloat()
#** -------------------------------------------------------------------------------
#* lê o ângulo da rampa de aproximação
#*/
l_fAngRampa = l_stream.readFloat()
#** -------------------------------------------------------------------------------
#* lê o retardo
#*/
l_iRetardo = l_stream.readInt()
#** -------------------------------------------------------------------------------
#* lê a declinação magnética
#*/
l_iDecl = l_stream.readInt()
#** -------------------------------------------------------------------------------
#* cria o PAR e coloca na tabela de PARs
#*/
self.add(
clsPAR.clsPAR([
l_szKey, l_szDescr, l_iCab0, l_fHAnt0, l_fHAnt1,
l_fDstAntEixo, l_fDstAntPT0, l_fDstAntPT1, l_fAngRampa,
l_iRetardo, l_iDecl
]), l_szKey)
#** ---------------------------------------------------------------------------------------
#*/
except (IOError, OSError), e:
#** -----------------------------------------------------------------------------------
#* cria a mensagem de erro
#*/
l_szErro = "Erro na carga: {0}".format(e)
def iniciaBaseDados(self, f_lstData):
#/ nome do método (logger)
#/ ----------------------------------------------------------------------------------------
#l_szMetodo = "modelControle::iniciaBaseDados"
#** ---------------------------------------------------------------------------------------
#* m.poirot logger
#*/
#l_log = logging.getLogger ( l_szMetodo )
#l_log.setLevel ( w_logLvl )
#l_log.debug ( ">> " )
#** ---------------------------------------------------------------------------------------
#* verifica parâmetros de entrada
#*/
#assert ( f_lstData )
#** ---------------------------------------------------------------------------------------
#* cria o exercício
#*/
self._oExe = clsExe.clsExe()
#assert ( self._oExe )
#l_log.info ( "f_lstData: " + str ( f_lstData ))
#** ---------------------------------------------------------------------------------------
#* salva a chave do exercício
#*/
self._oExe.setKey(f_lstData[0])
#l_log.info ( "Exe.setKey: " + str ( f_lstData [ 0 ] ))
#** ---------------------------------------------------------------------------------------
#* salva a cabeceira atual em uso (0=principal/1=secundária)
#*/
self._oExe.setCabAtu(int(f_lstData[1]))
#l_log.info ( "Exe.setCabAtu: " + str ( f_lstData [ 1 ] ))
#** ---------------------------------------------------------------------------------------
#* salva os parâmetros de vento
#*/
self._oExe.setVento((float(f_lstData[2]), float(f_lstData[3])))
#l_log.info ( "Exe.setVento_Vel: " + str ( f_lstData [ 2 ] ))
#l_log.info ( "Exe.setVento_Dir: " + str ( f_lstData [ 3 ] ))
#** ---------------------------------------------------------------------------------------
#* cria o PAR
#*/
l_oPAR = clsPAR.clsPAR(f_lstData[4:])
#assert ( l_oPAR )
#** ---------------------------------------------------------------------------------------
#* salva o PAR no exercício
#*/
self._oExe.setPAR(l_oPAR)
#** ---------------------------------------------------------------------------------------
#* m.poirot logger
#*/
#l_log.debug ( "<< " )
#** ---------------------------------------------------------------------------------------
#*/
return (True)