def iniciaBaseDados(self, f_szExe):
#/ nome do metodo (logger)
#/ ----------------------------------------------------------------------------------------
l_szMetodo = "modelConsole::iniciaBaseDados"
#** ---------------------------------------------------------------------------------------
#* m.poirot logger
#*/
l_log = logging.getLogger(l_szMetodo)
l_log.setLevel(logging.INFO)
l_log.debug(">> ")
#** ---------------------------------------------------------------------------------------
#* verifica parametros de entrada
#*/
assert ((f_szExe) and ("" != f_szExe))
#** ---------------------------------------------------------------------------------------
#* carrega o arquivo de exercício
#*/
self._oExe = clsExe.clsExe(f_szExe)
assert (self._oExe)
#** ---------------------------------------------------------------------------------------
#* obtem o indicativo do aeródromo
#*/
l_szInd = self._oExe.getIndicativo().upper()
l_log.info("Indicativo: " + l_szInd)
#** ---------------------------------------------------------------------------------------
#* monta o nome do arquivo de aeródromo
#*/
l_szAer = data.filepath(os.path.join(locDefs.xDIR_AER, l_szInd))
l_log.info(u"Arquivo de aeródromo: " + l_szAer)
#** ---------------------------------------------------------------------------------------
#* carrega o arquivo de aeródromo
#*/
self._oAer = clsAer.clsAer(l_szAer)
assert (self._oAer)
#** ---------------------------------------------------------------------------------------
#* m.poirot logger
#*/
l_log.debug("<< ")
#** ---------------------------------------------------------------------------------------
#*/
return (True)
def nextPage(self):
#/ nome do metodo (logger)
#/ ----------------------------------------------------------------------------------------
l_szMetodo = "wpgStart::nextPage"
#** ---------------------------------------------------------------------------------------
#* m.poirot logger
#*/
#l_log = logging.getLogger ( l_szMetodo )
#l_log.setLevel ( w_logLvl )
#l_log.debug ( ">> " )
#** ---------------------------------------------------------------------------------------
#* selecionou abrir exercício ?
#*/
if (self._rbtOpen.isChecked()):
#** -----------------------------------------------------------------------------------
#* próxima página, escolher o exercício na tabela
#*/
l_pgNext = self._oWizard._pagTabExe
#** ---------------------------------------------------------------------------------------
#* senão, selecionou criar exercício
#*/
else:
#** -----------------------------------------------------------------------------------
#* cria um exercício
#*/
locData.g_oExe = clsExe.clsExe()
#assert ( locData.g_oExe )
#** -----------------------------------------------------------------------------------
#* próxima página, escolher o sítio PAR
#*/
l_pgNext = self._oWizard._pagTabPAR
#** ---------------------------------------------------------------------------------------
#* m.poirot logger
#*/
#l_log.debug ( "<< " )
#** ---------------------------------------------------------------------------------------
#*/
return (l_pgNext)
def selectPAR(self):
#/ nome do método (logger)
#/ ----------------------------------------------------------------------------------------
#l_szMetodo = "wndTabelaPAR::selectPAR"
#** ---------------------------------------------------------------------------------------
#* m.poirot logger
#*/
#l_log = logging.getLogger ( l_szMetodo )
#l_log.setLevel ( w_logLvl )
#l_log.debug ( ">> " )
#** ---------------------------------------------------------------------------------------
#* verifica condições de execução
#*/
##assert ( locData.g_oExe )
#** ---------------------------------------------------------------------------------------
#* obtém o sítio PAR selecionado
#*/
l_oPAR = self.getCurrentLine()
if (l_oPAR is not None):
#** ---------------------------------------------------------------------------------------
#* o exercício não existe ?
#*/
if (None == locData.g_oExe):
#** -----------------------------------------------------------------------------------
#* cria um exercício
#*/
locData.g_oExe = clsExe.clsExe()
#assert ( locData.g_oExe )
#** -----------------------------------------------------------------------------------
#* salva o sítio PAR selecionada
#*/
locData.g_oExe._oPAR = l_oPAR
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 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)
def accept(self):
#/ nome do método (logger)
#/ ----------------------------------------------------------------------------------------
#l_szMetodo = "dlgEditExe::accept"
#** ---------------------------------------------------------------------------------------
#* m.poirot logger
#*/
#l_log = logging.getLogger ( l_szMetodo )
#l_log.setLevel ( w_logLvl )
#l_log.debug ( ">> " )
#** ---------------------------------------------------------------------------------------
#* verifica condições de execução
#*/
#assert ( None != self._oTabExe )
#** ---------------------------------------------------------------------------------------
#* obtém os dados do exercício
#*/
l_szKey = self.qleKey.text().toUpper()
l_szDescr = self.qleDescr.text().toUpper()
l_szPAR = self.cbxPAR.currentText().toUpper()
l_szAnv = self.cbxAnv.currentText().toUpper()
#** ---------------------------------------------------------------------------------------
#* obtém os valores do exercício
#*/
#l_iCab = int ( self.cbxCab.value ())
l_iCab = 12
#** ---------------------------------------------------------------------------------------
#* obtém os valores do exercício
#*/
l_fVentoVel = float(self.qsbVentoVel.value())
l_fVentoDir = float(self.qsbVentoDir.value())
l_fGateDist = float(self.qsbGateDist.value())
l_fGateAfst = float(self.qsbGateAfst.value())
l_fGateAlt = float(self.qsbGateAlt.value())
#** ---------------------------------------------------------------------------------------
#* exercício inexistente ?
#*/
if (None == self._oExe):
#** -----------------------------------------------------------------------------------
#* cria uma nova exercício
#*/
self._oExe = clsExe.clsExe([
l_szKey, l_szDescr, l_szPAR, l_iCab, l_fVentoVel, l_fVentoDir,
l_szAnv, l_fGateDist, l_fGateAfst, l_fGateAlt
])
#assert ( self._oExe )
#** -----------------------------------------------------------------------------------
#* cria uma nova entrada na tabela de exercícios com o exercício criado
#*/
self._oTabExe.add(self._oExe, l_szKey)
#** ---------------------------------------------------------------------------------------
#* se existe, atualiza a informação
#*/
else:
#** -----------------------------------------------------------------------------------
#* atualiza os dados do exercício
#*/
self._oTabExe.updateTabela(self._oExe, [
l_szKey, l_szDescr, l_szPAR, l_iCab, l_fVentoVel, l_fVentoDir,
l_szAnv, l_fGateDist, l_fGateAfst, l_fGateAlt
])
#** ---------------------------------------------------------------------------------------
#* faz o "accept"
#*/
QtGui.QDialog.accept(self)
def iniciaBaseDados(self, f_szExe):
#/ nome do método (logger)
#/ ----------------------------------------------------------------------------------------
#l_szMetodo = "modelPiloto::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_szExe) and ("" != f_szExe))
#** ---------------------------------------------------------------------------------------
#* carrega o arquivo de exercício
#*/
self._oExe = clsExe.clsExe(f_szExe)
assert (self._oExe)
#** ---------------------------------------------------------------------------------------
#* obtem o indicativo do aeródromo
#*/
l_szInd = self._oExe.getIndicativo().upper()
#l_log.info ( "Indicativo: " + l_szInd )
#** ---------------------------------------------------------------------------------------
#* monta o nome do arquivo de aeródromo
#*/
l_szAer = data.filepath(os.path.join(locDefs.xDIR_AER, l_szInd))
#l_log.info ( "Arquivo de aeródromo: " + l_szAer )
#** ---------------------------------------------------------------------------------------
#* carrega o arquivo de aeródromo
#*/
self._oAer = clsAer.clsAer(l_szAer)
assert (self._oAer)
#** ---------------------------------------------------------------------------------------
#* calcula a direção das aeronaves, apartir dos valores de proa (lidos
#* no arquivo de exercício) e da diferenca de declinação (lido no
#* arquivo de aeródromo).
#*/
#pilCalc.calculaDireçãoAeronaves ()
#** ---------------------------------------------------------------------------------------
#* carrega o arquivo de desenhos de aeronaves
#*/
#anvCls.loadDesenhosAeronaves ( data.filepath ( os.path.join ( locDefs.xARQ_TAB, locDefs.xARQ_DES )))
#** ---------------------------------------------------------------------------------------
#* monta o nome do arquivo de performance
#*/
l_szPrf = data.filepath(
os.path.join(glbDefs.xDIR_TAB, locDefs.xARQ_PRF))
#l_log.info ( "Arquivo de performance: " + l_szPrf )
#** ---------------------------------------------------------------------------------------
#* carrega a tabela de performance
#*/
self._oPrf = clsPrf.clsPrf(l_szPrf)
assert (self._oPrf)
#** ---------------------------------------------------------------------------------------
#* m.poirot logger
#*/
#l_log.debug ( "<< " )
#** ---------------------------------------------------------------------------------------
#*/
return (True)
def populateFromData(self, f_Data):
#/ globals
#/ ----------------------------------------------------------------------------------------
#global locDefs.xMAX_Exercicios
#/ nome do método (logger)
#/ ----------------------------------------------------------------------------------------
#l_szMetodo = "clsTabelaExe::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 exercícios na tabela
#*/
locDefs.xMAX_Exercicios = (len(f_Data) // 10)
#l_log.info ( "locDefs.xMAX_Exercicios: " + str ( locDefs.xMAX_Exercicios ))
#** ---------------------------------------------------------------------------------------
#* cria a tabela de exercícios
#*/
self._tabItens = [None for _ in xrange(locDefs.xMAX_Exercicios)]
#assert ( self._tabItens )
#l_log.info ( "self._tabItens: " + str ( self._tabItens ))
#** ---------------------------------------------------------------------------------------
#* carrega os dados da tabela de exercícios
#*/
for _ in xrange(locDefs.xMAX_Exercicios):
#l_log.info ( "l_btExe: " + str ( l_btExe ))
#** -----------------------------------------------------------------------------------
#* chave do exercício
#*/
l_szKey = f_Data[l_iD].upper()
l_iD += 1
#l_log.info ( "_szKey: " + l_szKey )
#** -----------------------------------------------------------------------------------
#* descrição
#*/
l_szDescr = f_Data[l_iD].upper().replace('_', ' ')
l_iD += 1
#l_log.info ( "_szDescr: " + str ( l_szDescr ))
#** -----------------------------------------------------------------------------------
#* sítio PAR
#*/
l_szPAR = f_Data[l_iD].upper()
l_iD += 1
#l_log.info ( "_szPAR: " + str ( l_szPAR ))
#** -----------------------------------------------------------------------------------
#* cabeceira atual em uso
#*/
l_iCab = int(f_Data[l_iD])
l_iD += 1
#l_log.info ( "_iCab: " + str ( l_iCab ))
#** -----------------------------------------------------------------------------------
#* velocidade do vento
#*/
l_fVentoVel = float(f_Data[l_iD])
l_iD += 1
#l_log.info ( "_fVentoVel: " + str ( l_fVentoVel ))
#** -----------------------------------------------------------------------------------
#* direção do vento
#*/
l_fVentoDir = float(f_Data[l_iD])
l_iD += 1
#l_log.info ( "_fVentoDir: " + str ( l_fVentoDir ))
#** -----------------------------------------------------------------------------------
#* aeronave
#*/
l_szAnv = f_Data[l_iD].upper()
l_iD += 1
#l_log.info ( "_szAnv: " + str ( l_szAnv ))
#** -----------------------------------------------------------------------------------
#* distância da aeronave
#*/
l_fGateDist = float(f_Data[l_iD])
l_iD += 1
#l_log.info ( "_fGateDist: " + str ( l_fGateDist ))
#** -----------------------------------------------------------------------------------
#* afastamento do eixo da pista
#*/
l_fGateAfst = float(f_Data[l_iD])
l_iD += 1
#l_log.info ( "_fGateAfst: " + str ( l_fGateAfst ))
#** -----------------------------------------------------------------------------------
#* altura da aeronave
#*/
l_fGateAlt = float(f_Data[l_iD])
l_iD += 1
#l_log.info ( "_fGateAlt: " + str ( l_fGateAlt ))
#** -----------------------------------------------------------------------------------
#* cria o exercício
#*/
l_oExe = clsExe.clsExe([
l_szKey, l_szDescr, l_szPAR, l_iCab, l_fVentoVel, l_fVentoDir,
l_szAnv, l_fGateDist, l_fGateAfst, l_fGateAlt
])
#assert ( l_oExe )
#** -----------------------------------------------------------------------------------
#* coloca o exercício na tabela
#*/
self.add(l_oExe, l_szKey)
#** ---------------------------------------------------------------------------------------
#* após a carga, reseta o flag dirty
#*/
self._bDirty = False
def loadQDataStream(self):
#/ nome do método (logger)
#/ ----------------------------------------------------------------------------------------
#l_szMetodo = "clsTabelaExe::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 )
#** -----------------------------------------------------------------------------------
#* lê o magic number
#*/
l_iMagic = l_stream.readInt32()
#** -----------------------------------------------------------------------------------
#* tipo de arquivo válido ?
#*/
if (clsTabelaModel.c_xxMAGIC_NUMBER != l_iMagic):
#** -------------------------------------------------------------------------------
#* gera exception
#*/
raise IOError, u"tipo de arquivo não reconhecido !"
#** -----------------------------------------------------------------------------------
#* lê a versão do arquivo
#*/
l_iVersion = l_stream.readInt32()
#** -----------------------------------------------------------------------------------
#* versão muito antiga ?
#*/
if (l_iVersion < clsTabelaModel.c_xxOLD_FILE_VERSION):
#** -------------------------------------------------------------------------------
#* gera exception
#*/
raise IOError, u"formato do arquivo é antigo e não legível !"
#** -----------------------------------------------------------------------------------
#* versão 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_6)
#** -----------------------------------------------------------------------------------
#*/
self.clear(False)
#** -----------------------------------------------------------------------------------
#* enquanto não termina de ler a stream...
#*/
while (not l_stream.atEnd()):
#** -------------------------------------------------------------------------------
#* cria a área para chave do exercício
#*/
l_szKey = QtCore.QString()
#** -------------------------------------------------------------------------------
#* lê a chave do exercício
#*/
l_stream >> l_szKey
#** -------------------------------------------------------------------------------
#* cria a área para descrição do exercício
#*/
l_szDescr = QtCore.QString()
#** -------------------------------------------------------------------------------
#* lê a descrição do exercício
#*/
l_stream >> l_szDescr
l_szDescr = l_szDescr.replace('_', ' ')
#** -------------------------------------------------------------------------------
#* cria a área para chave do sítio PAR
#*/
l_szPAR = QtCore.QString()
#** -------------------------------------------------------------------------------
#* lê a chave do sítio PAR
#*/
l_stream >> l_szPAR
#** -------------------------------------------------------------------------------
#* lê a cabeceira atual em uso
#*/
l_iCab = l_stream.readInt()
#** -------------------------------------------------------------------------------
#* lê a velocidade do vento
#*/
l_fVentoVel = l_stream.readFloat()
#** -------------------------------------------------------------------------------
#* lê a direção do vento
#*/
l_fVentoDir = l_stream.readFloat()
#** -------------------------------------------------------------------------------
#* cria a área para chave da aeronave
#*/
l_szAnv = QtCore.QString()
#** -------------------------------------------------------------------------------
#* lê a chave da aeronave
#*/
l_stream >> l_szAnv
#** -------------------------------------------------------------------------------
#* lê a distância da aeronave
#*/
l_fGateDist = l_stream.readFloat()
#** -------------------------------------------------------------------------------
#* lê o afastamento do eixo da pista
#*/
l_fGateAfst = l_stream.readFloat()
#** -------------------------------------------------------------------------------
#* lê a altura da aeronave
#*/
l_fGateAlt = l_stream.readFloat()
#** -------------------------------------------------------------------------------
#* cria o exercício e coloca na tabela
#*/
self.add(
clsExe.clsExe([
l_szKey, l_szDescr, l_szPAR, l_iCab, l_fVentoVel,
l_fVentoDir, l_szAnv, l_fGateDist, l_fGateAfst,
l_fGateAlt
]), l_szKey)
#** ---------------------------------------------------------------------------------------
#*/
except (IOError, OSError), e:
#** -----------------------------------------------------------------------------------
#* cria a mensagem de erro
#*/
l_szErro = "Erro na carga: {0}".format(e)
