# -*- coding: latin-1 -*- import vbfunctions import sltgl import slttx import sltgen import sltcorr import sltinfopal def ini(): global PalabraAct,PalabraSig,PalabraAnt,FiltroApo PalabraAct=slttx.PalabraAct PalabraSig=slttx.PalabraSig PalabraAnt=slttx.PalabraAnt FiltroApo=slttx.FiltroApo global VerMayuscula,SubstituirPalabra,PonMayuscula VerMayuscula=sltcorr.VerMayuscula SubstituirPalabra=sltcorr.SubstituirPalabra PonMayuscula=sltcorr.PonMayuscula global RSet,ByRef,InStr,Trim RSet=sltgen.RSet ByRef=sltgen.ByRef InStr=sltgen.InStr Trim=sltgen.Trim global AbrirBd,BdClone,CerrarBd,PalTextIni,DamePalabra,Palabra,NumEnLista,DamePalEnLista AbrirBd=sltgen.AbrirBd BdClone=sltgen.BdClone CerrarBd=sltgen.CerrarBd PalTextIni=sltgen.PalTextIni DamePalabra=sltgen.DamePalabra Palabra=sltgen.Palabra NumEnLista=sltgen.NumEnLista DamePalEnLista=sltgen.DamePalEnLista #Constantes que definen la estructura de cada elemento de colTx tx_paltext=0 tx_nordori=1 tx_carfinpal=2 tx_italica=3 tx_italicaori=4 class sltsalt(vbfunctions.Object): class infopal: def __init__(self): self.paltext = vbfunctions.String() self.paldic = vbfunctions.String() self.pre = vbfunctions.String() self.sepsil = vbfunctions.Integer() self.pal1 = vbfunctions.String() self.pal2 = vbfunctions.String() self.tipopost = vbfunctions.Integer() self.post = vbfunctions.String() self.xi = vbfunctions.Integer() self.tipoletra = vbfunctions.Integer() self.signopunt = vbfunctions.Integer() self.postsignopunt = vbfunctions.Integer() self.carfinpal = vbfunctions.String() self.italica = vbfunctions.Integer() self.italicaori = vbfunctions.Integer() self.palori = vbfunctions.String() self.nordori = vbfunctions.Long() self.ipaldu = vbfunctions.Long() colTx = [] ipa = vbfunctions.Long() class tPalDu: def __init__(self): self.Clave = vbfunctions.String() self.pos = vbfunctions.Long() self.Info = vbfunctions.String() #colPalDu={n:{'Clave':xx,'pos':n,'Info':xx},n:{}...} No usamos tPalDu colPalDu = {} def DocLista(self): # # Obtener una lista de palabras a partir de un documento # # Entrada: tx: Documento cuyas palabras hay que pasar a la lista. # Si SelLenght=0 se pasa todo; sino la parte seleccionada # # Salida: ls: Lista de palabras del documento # #Posición de partida y de final pi = 1 pf=0 cf="" self.colTx = [] pft = pi + len(sltgl.txDOC) #Primera palabra i = 0 pal,pi,pf,cf = PalabraAct(pi, pi, pf, cf) while pal <> '' and pi < pft: #Hay nueva palabra txpal=self.infopal() txpal.nordori = i txpal.palori = pal txpal.paltext = pal txpal.italica = 0 txpal.carfinpal = cf self.InfCompl(txpal) self.colTx.append(txpal) self.ipa = len(self.colTx)-1 #Siguiente palabra i = i + 1 pi = pf pal,pi,pf,cf = PalabraSig(pi, pi, pf, cf) #Dejar como palabra actual la primera de la lista self.ipa = 0 def OOoDocLista(self,cursor): # # Obtener una lista de palabras a partir de un documento OOo # # Entrada: cursor: Cursor al documento cuyas palabras hay que pasar a la lista. # Si SelLenght=0 se pasa todo; sino la parte seleccionada # # Salida: colTx: Lista de palabras del documento # self.colTx = [] i=0 ret=cursor.gotoStart(0) ret=cursor.gotoStartOfWord(0) while ret == True: cursor.gotoEndOfWord(1) pal=cursor.getString() cf="" if len(pal)>0: cf=pal[len(pal)-1] txpal=self.infopal() txpal.nordori = i txpal.palori = pal txpal.paltext = pal txpal.italica = 0 txpal.carfinpal = cf self.InfCompl(txpal) self.colTx.append(txpal) self.ipa = len(self.colTx)-1 i=i+1 ret=cursor.gotoNextWord(0) #Dejar como palabra actual la primera de la lista self.ipa = 0 def PrAuCtvShow(self): # # Proceso automático. # Presentación del Form frmCtv si no estamos en proceso # automático. En caso contrario, cambia en el texto el # texto erróneo por la propuesta de cambio (que # corresponde a la primera alternativa, si hay varias) y # tambien guarda la información complementaria necesaria # para que posteriormente se pueda presentar al operador # el cambio que ha realizado y las alternativas que # habia. # #ATENCIóN: Crear otra función para llamarla desde revisión de la forma #que en Salt3 se llama "modo no automático" (presentar frmCtv al operador) #Modo automático #Preparar información complementaria Info="" #paldu=self.tPalDu() paldu={} palalt = Trim(sltgl.tx_pal) n = len(sltgl.ls_alt) if palalt == '' and n > 0: #Si no hay palalt, obtenerla de la lista palalt = DamePalEnLista(sltgl.ls_alt[0]) Info=self.PrAuInfoGuardar(Info, sltgl.praunumalts, Trim(str(n))) Info=self.PrAuInfoGuardar(Info, sltgl.prautxtdu, Trim(sltgl.tx_palerr)) Info=self.PrAuInfoGuardar(Info, sltgl.prautxtpro, palalt) i=0 while i<= n - 1: pal = Trim(sltgl.ls_alt[i]) Info=self.PrAuInfoGuardar(Info, sltgl.praualt + Trim(str(i+1)), pal) i=i+1 Info=self.PrAuInfoGuardar(Info, sltgl.praudescrierror, Trim(sltgl.lb_mens)) Info=self.PrAuInfoGuardar(Info, sltgl.praunpretro, Trim(str(sltgl.npretro))) #Guardar información sobre la palabra dudosa paldu["Clave"] = palalt paldu["pos"] = self.ipa paldu["Info"] = Info paldu["dtr"]=sltgl.dtractual #self.colPalDu.append(paldu) self.colPalDu[self.ipa]=paldu i = self.ipa #Simular actuación de frmCtv.cmbSubs _select429 = sltgl.ctvmodocorrtrad if (_select429 == sltgl.CTV_ESCORR): #Substituir palabra en el texto if sltgl.enrevisio: t=ByRef() s="" self.PrAuInfoLeer(paldu["Info"], sltgl.praudescrierror, t.a((s,))) s,=t.r() if s<>"Castellanisme": SubstituirPalabra(palalt) #self.colPalDu[i]["Clave"] = Trim(sltgl.tx_palerr) self.colPalDu[i]["Clave"]=Trim(sltgl.tx_palerr) i = DamePalabra(1) elif (_select429 == sltgl.CTV_ESTRAD) or (_select429 == sltgl.CTV_ESTRAD2): #Guardar palabra sltgl.palsel = palalt sltgl.ctverr = sltgl.NO #Borrar en Form sltgl.tx_pal = '' sltgl.tx_palerr = '' sltgl.lb_mens = '' sltgl.ls_alt=[] def PrAuIni(self): # # Inicializar el proceso automático # self.colPalDu = {} def PrAuInfoGuardar(self, Info, Cod, txt): # # Guardar datos en el string de información adicional. # El string contiene elementos de la forma: # $Código=Información$ # # Entrada: Info: vbfunctions.String de información adicional # Cod: Código del elemento a guardar # Txt: Texto informativo correspondiente a Cod # Retorno: Info, con el nuevo elemento añadido return Info + '_' + Cod + '=' + txt + '_' + '\n' def PrAuListaPalDu(self): # # Guardar en el documento actual la información # asociada a cada palabra dudosa, para poder presentar # posteriormente las opciones al operador # t=ByRef() sltgl.ls_paldu=[] s="" for n in self.colPalDu: paldu=self.colPalDu[n] if paldu["Clave"] <> '': #Mostrar información de la palabra dudosa txt = paldu["Clave"] + ';' + str(paldu["pos"]) + ';' + paldu["Info"] if self.PrAuInfoLeer(paldu["Info"], sltgl.praunumalts, t.a((s,))): s,=t.r() if s == '0': txt = txt + ';' + 'DESCONOCIDA' else: txt = txt + ';' + 'DUDOSA' sltgl.ls_paldu.append(txt) #print txt def PrAuInfoLeer(self, Info, Cod, t): txt,=t.r() _ret = None # # Leer un elemento de la información adicional que se # guarda junto a cada texto dudoso, en el proceso # automático # # Entrada: Info: vbfunctions.String de información adicional # Cod: Código a buscar # # Salida: Txt: Texto informativo correspondiente a # Cod, si existe ese elemento en Info # (en caso contrario "") # # Retorno: True: Encontrado elemento Cod en Info # False: No encontrado elemento Cod # _ret = False txt = '' pi = InStr(Info, '_' + Cod + '=') if pi > 0: pi = pi + len(Cod) + 2 pf = InStr(Info, '_',pi) if pf > 0: txt = vbfunctions.Mid(Info, pi, pf - pi) else: txt = vbfunctions.Mid(Info, pi) _ret = True t.a((txt,)) return _ret def InfCompl(self, paltx): # # Obtener más información sobre palabra actual # La palabra se pasa en paltx, pero aun no se ha añadido a la colección # por lo que el índice de la palabra anterior es ipa o Count # # rval=RSet() #Set rVal = RMetaFlex.Clone() #Ver si es palabra especial HayApo = sltgl.NO HayGui = sltgl.NO HayXi = sltgl.NO lonpal = len(paltx.paltext) if lonpal > 0: for j in vbfunctions.vbForRange(1, lonpal): _select430 = vbfunctions.Mid(paltx.paltext, j, 1) if (_select430 == '\''): if lonpal > 2: HayApo = sltgl.SI elif (_select430 == '-'): HayGui = sltgl.SI elif ('0' <= _select430 <= '9') or (_select430 == '@') or (_select430 == '#') or (_select430 == '$') or (_select430 == '%') or (_select430 == '&') or (_select430 == '/'): HayXi = sltgl.SI pal = vbfunctions.LCase(paltx.paltext) #Apóstrofe par = '' parpost = '' if HayApo == sltgl.SI: p = InStr(pal, '\'') while p > 0: #Puede haber apóstrofe if p == 2: #Si hay apóstrofe lo guardamos en minúsculas par = vbfunctions.LCase(vbfunctions.Left(pal, p - 1)) pal = vbfunctions.Mid(pal, p + 1) else: #Es apóstrofe posterior parpost = vbfunctions.LCase(vbfunctions.Mid(pal, p + 1)) pal = vbfunctions.Left(pal, p - 1) p = InStr(pal, '\'') #Separación silábica parte1 = '' parte2 = '' haysepsil = sltgl.NO if HayGui == sltgl.SI: p = InStr(pal, '-') if p > 0: #Puede ser ,palabra (para-sol), verbo+pronombre o sep. silábica if p > 1: parte1 = vbfunctions.Left(pal, p - 1) parte2 = vbfunctions.Mid(pal, p + 1) if parpost <> '': #Es -aaa'bb parte2 = parte2 + '\'' + parpost parpost = '' #rVal.Index = "IdxVeu" #rVal.Seek "=", parte1 + "-" + parte2 rval.Open(sltgl.bd_metaflex_Veu) rval.Seek((parte1 + '-' + parte2,)) #sql = 'select * from metaflex where Veu = %s' #+ parte1 + '-' + parte2 + '"' #rval.OpenR(sql, (parte1 + '-' + parte2,)) if not rval.noesta: #Existe en el diccionario con - pal = parte1 + '-' + parte2 else: #rVal.Seek "=", parte1 + parte2 rval.Seek((parte1 + parte2,)) #sql = 'select * from metaflex where Veu = %s' #+ parte1 + parte2 + '"' #rval.OpenR(sql, (parte1 + parte2,)) if rval.noesta: #Es verbo-pronombre pal = parte1 else: #Hay separación silábica haysepsil = sltgl.SI pal = parte1 + parte2 #Guardar palabra "como está en los diccionarios" paltx.paldic = pal #Es la palabra actual: guardar información complementaria paltx.pre = par.strip() paltx.post = parpost.strip() paltx.sepsil = haysepsil paltx.pal1 = parte1 paltx.pal2 = parte2 #Mayúsculas / minúsculas paltx.tipoletra = VerMayuscula(paltx.paltext) #Ver si hay cifras dentro de la palabra paltx.xi = HayXi #Caso especial 1 y 11 if paltx.paltext == '1' or paltx.paltext == '11': paltx.xi = sltgl.NO #Ver si es signo de puntuación _select431 = paltx.paltext #if (_select431 == '.') or (_select431 == ',') or (_select431 == ':') or (_select431 == ';') or (_select431 == '*') or (_select431 == unichr(191)) or (_select431 == '?') or (_select431 == unichr(161)) or (_select431 == '!') or (_select431 == '%') or (_select431 == '(') or (_select431 == ')') or (_select431 == '"') or (_select431 == '/') or (_select431 == unichr(145)) or (_select431 == unichr(146)) or (_select431 == unichr(147)) or (_select431 == unichr(148)) or (_select431 == unichr(132)) or (_select431 == unichr(171)) or (_select431 == unichr(187)) or (_select431 == unichr(188)) or (_select431 == '-') or (_select431 == unichr(10)) or (_select431 == unichr(12)) or (_select431 == unichr(9)) or (_select431 == unichr(11)) or (_select431 == '[') or (_select431 == ']') or (_select431 == '<') or (_select431 == '>') or (_select431 == unichr(160)) or (_select431 == unichr(150)) or (_select431 == unichr(151)) or (_select431 == unichr(215)) or (_select431 == unichr(247)) or (_select431 == '\''): #if (_select431 == '.') or (_select431 == ',') or (_select431 == ':') or (_select431 == ';') or (_select431 == '*') or (_select431 == chr(191)) or (_select431 == '?') or (_select431 == chr(161)) or (_select431 == '!') or (_select431 == '%') or (_select431 == '(') or (_select431 == ')') or (_select431 == '"') or (_select431 == '/') or (_select431 == chr(145)) or (_select431 == chr(146)) or (_select431 == unichr(147)) or (_select431 == chr(148)) or (_select431 == chr(132)) or (_select431 == chr(171)) or (_select431 == chr(187)) or (_select431 == chr(188)) or (_select431 == '-') or (_select431 == chr(10)) or (_select431 == chr(12)) or (_select431 == chr(9)) or (_select431 == chr(11)) or (_select431 == '[') or (_select431 == ']') or (_select431 == '<') or (_select431 == '>') or (_select431 == chr(160)) or (_select431 == chr(150)) or (_select431 == chr(151)) or (_select431 == chr(215)) or (_select431 == chr(247)) or (_select431 == '\''): if (_select431 == '.') or (_select431 == ',') or (_select431 == ':') or (_select431 == ';') or (_select431 == '*') or (_select431 == '¿')or (_select431 == '?')or (_select431 == '?') or (_select431 == '¡') or (_select431 == '!') or (_select431 == '%') or (_select431 == '(') or (_select431 == ')') or (_select431 == '"') or (_select431 == '/') or (_select431 == chr(145)) or (_select431 == '-') or (_select431 == chr(10)) or (_select431 == chr(12)) or (_select431 == chr(9)) or (_select431 == chr(11)) or (_select431 == '[') or (_select431 == ']') or (_select431 == '<') or (_select431 == '>') or (_select431 == '\''): #Es signo de puntuación paltx.signopunt = sltgl.SI else: paltx.signopunt = sltgl.NO #Ver si sigue a signo de puntuación if len(sltgl.lspals.colTx) > 0: i = len(sltgl.lspals.colTx)-1 if self.colTx[i].paltext == '.' or self.colTx[i].paltext == ',' or self.colTx[i].paltext == ':' or self.colTx[i].paltext == ';': paltx.postsignopunt = sltgl.SI else: paltx.postsignopunt = sltgl.NO else: paltx.postsignopunt = sltgl.NO def Modif(self, i, nue): # # Modifica el contenido de un ítem de la colección colTx # Para ello lo elimina y lo vuelve a crear en la posición correspondiente # # Entrada: i: índice del ítem a modificar # nue: Nuevo contenido # #self.colTx.Remove(i) #if self.colTx.Count == 0 or i > self.colTx.Count: #self.colTx.Add(nue) #else: #self.colTx.Add(nue, i) self.colTx[i]=nue def InsertarPost(self, pal): # # Insertar un elemento en la colección colTx a continuación del elemento actual. # El elemento actual sigue siendo el mismo # Hereda el nordori de la palabra actual # # Entrada: pal: Palabra a insertar # txpal=sltinfopal.infopal() txpal.nordori = self.colTx[self.ipa].nordori txpal.palori = '' txpal.paltext = pal txpal.italica = sltgl.NO self.InfCompl(txpal) if self.ipa < len(self.colTx): #insertar post actual = insertar antes del siguiente i=self.ipa+1 self.colTx.insert(i,txpal) else: #añadir self.colTx.append(txpal) def InsertarAnt(self, pal): # # Insertar un elemento en la colección colTx antes del elemento actual. # El elemento actual sigue siendo el mismo ipa (el insertado) # Hereda toda la información original de la palabra actual # # Entrada: pal: Palabra a insertar # txpal=sltinfopal.infopal() txpal.nordori = self.colTx[self.ipa].nordori txpal.palori = self.colTx[self.ipa].palori txpal.paltext = pal txpal.italica = self.colTx[self.ipa].italica self.InfCompl(txpal) self.colTx.insert(self.ipa,txpal) def Modif_paltext(self, i, ptext): # # Modifica el contenido de paltext de un ítem de la lista colTx # # Entrada: i: índice del ítem a modificar # ptext: Nuevo contenido # self.colTx[i].paltext=ptext self.InfCompl(self.colTx[i]) def ListaDoc(self): # # Modificar el documento a partir de la lista de palabras # # #Posición de partida y de final pf=0 pi = 1 cf="" pft = pi + len(sltgl.txDOC) #Primera palabra pal,pi,pf,cf = PalabraAct(pi, pi, pf, cf) i = 0 j = 0 while pal <> '' and pi < pft: #Hay nueva palabra if self.colTx[j].nordori > i: #Eliminar palabra en el documento if pi > 1: if vbfunctions.Mid(sltgl.txDOC, pi - 1, 1) == ' ': #Eliminar el espacio anterior pi = pi - 1 #vbfunctions.Mid(txDOC, pi, pf - pi + 1) = "" sltgl.txDOC = vbfunctions.Left(sltgl.txDOC, pi - 1) + vbfunctions.Mid(sltgl.txDOC, pf + 1) pf = pi elif self.colTx[j].nordori == i: #Sustituir / insertar palabras pal = self.colTx[j].paltext while j < len(self.colTx)-1: if self.colTx[j + 1].nordori == i: j = j + 1 pal = pal + ' ' + self.colTx[j].paltext else: break #txDOC.SelStart = pi - 1 #txDOC.SelLength = pf - pi + 1 #If colTx(j).italica <> colTx(j).italicaori Then # txDOC.FontItalic = colTx(j).italica #End If #txDOC.SelText = pal #vbfunctions.Mid(txDOC, pi, pf - pi + 1) = pal sltgl.txDOC = vbfunctions.Left(sltgl.txDOC, pi - 1) + pal + vbfunctions.Mid(sltgl.txDOC, pf + 1) j = j + 1 pf = pi + len(pal) - 1 #Siguiente palabra pi = pf pal,pi,pf,cf = PalabraSig(pi, pi, pf, cf) i = i + 1 def OooListaDoc(self,cursor): # # Copiar una lista de palabras a un documento OOo # # Entrada: cursor: Cursor al documento cuyas palabras hay que pasar a la lista. # Si SelLenght=0 se pasa todo; sino la parte seleccionada # # i = 0 j = 0 ret=cursor.gotoStartOfWord(0) while ret == True: cursor.gotoEndOfWord(1) #Hay nueva palabra if self.colTx[j].nordori > i: #Eliminar palabra en el documento cursor.vbfunctions.String="" elif self.colTx[j].nordori == i: #Sustituir / insertar palabras pal = self.colTx[j].paltext while j < len(self.colTx)-1: if self.colTx[j + 1].nordori == i: j = j + 1 pal = pal + ' ' + self.colTx[j].paltext else: break cursor.vbfunctions.String=pal j = j + 1 #Siguiente palabra ret=cursor.gotoNextWord(0) i = i + 1 def PrAuListaDoc(self): # # Guardar en el documento actual la información # asociada a cada palabra dudosa, para poder presentar # posteriormente las opciones al operador # sltgl.ls_paldu.append('--------------------') for pal in self.colTx: txt = pal.paltext + ' ' + str(pal.nordori) + ' ' + pal.palori sltgl.ls_paldu.append(txt) #print txt def QuitaApopstrofes(self): # # Quitar todos los apóstrofes de la lista colTx substituyéndolos por la # palabra correspondiente # ipaini = self.ipa i = 0 while i <= len(self.colTx)-1: pal = '' if vbfunctions.LCase(vbfunctions.Left(self.colTx[i].paltext, 2)) == "d'" or vbfunctions.LCase(vbfunctions.Left(self.colTx[i].paltext, 2)) == "d"+chr(146): #Es d' tl = self.colTx[i].tipoletra if tl == sltgl.TL_TODOMAYUS and VerMayuscula(vbfunctions.Left(self.colTx[i].paltext, 3)) <> sltgl.TL_TODOMAYUS: tl = sltgl.TL_PRIMERAMAYUS pal = PonMayuscula('de', tl) elif vbfunctions.LCase(vbfunctions.Left(self.colTx[i].paltext, 2)) == "l'" or vbfunctions.LCase(vbfunctions.Left(self.colTx[i].paltext, 2)) == "l"+chr(146): #Es l' tl = self.colTx[i].tipoletra if tl == sltgl.TL_TODOMAYUS and VerMayuscula(vbfunctions.Left(self.colTx[i].paltext, 3)) <> sltgl.TL_TODOMAYUS: tl = sltgl.TL_PRIMERAMAYUS pal = PonMayuscula('el', tl) if pal <> '': #Modificar palabra actual pal2 = vbfunctions.Mid(self.colTx[i].paltext, 3) self.Modif_paltext(i, pal2) #Insertar palabra antes de la actual self.ipa = i self.InsertarAnt(pal) #Saltar palabra insertada i = i + 1 #Siguiente elemento i = i + 1 self.ipa = ipaini def Modif_italica(self, i, ital): # # Modifica el contenido de italica de un ítem de la colección colTx # # Entrada: i: índice del ítem a modificar # ptext: Nuevo contenido # self.colTx[i].italica=ital def Picklar2(self,com): #Obtener información adicional a partir de las variables globales en caso de comandos tipo trad #Entrada: com: Comando #Retorno: (colTx,colPalDu) a partir de información en memoria if com=='trad' or com=='tradi' or com=='corr' or com=='rev' or com=='revi' or com=='void': #Afinar palabras dudosas for m in sltgl.lspals.colPalDu.keys(): i=m if i>len(sltgl.lspals.colTx)-1: i=len(sltgl.lspals.colTx)-1 #if sltgl.lspals.colPalDu[m]['Clave']!=sltgl.lspals.colTx[i].paldic: if sltgl.lspals.colPalDu[m]['Clave']!=sltgl.lspals.colTx[i].paltext: #Hay que afinar n=sltgl.lspals.colPalDu[m]['Clave'].count(' ')+1 k=-1 for j in range(-2,2): if i+j>=0 and i+j+n-1-1 and k!=m: #Se ha encontrado una palabra que coincide sltgl.lspals.colPalDu[k]=sltgl.lspals.colPalDu[m] sltgl.lspals.colPalDu[k]['pos']=k del sltgl.lspals.colPalDu[m] elif k==-1: #No se ha encontrado una palabra que coincida del sltgl.lspals.colPalDu[m] #Componer lista de palabras lsTx=[] for paltx in sltgl.lspals.colTx: tx=(paltx.paltext,paltx.nordori,paltx.carfinpal,paltx.italica,paltx.italicaori) lsTx.append(tx) return (lsTx,sltgl.lspals.colPalDu) elif com=='txtrad' or com=='txtradi' or com=='txcorr': for m in sltgl.lspals.colPalDu.keys(): newkey=sltgl.lspals.colPalDu[m]['Clave']+"_("+str(m)+")" sltgl.lspals.colPalDu[newkey]=sltgl.lspals.colPalDu[m] del sltgl.lspals.colPalDu[m] #Componer lista de palabras lsTx=[] for paltx in sltgl.lspals.colTx: tx=(paltx.paltext,paltx.nordori,paltx.carfinpal,paltx.italica,paltx.italicaori) lsTx.append(tx) txt=self.ListaaTxt(lsTx) return (txt,sltgl.lspals.colPalDu) def Unpicklar2(self,com,masdatos): #Unpiclar la información recibida #Entrada: com: Comando recibido # masdatos: (colTx,colPalDu) es el resto de la información que # hay que guardar en variables globales (en el caso de comandos tipo trad) sltgl.lspals.ipa=0 if com=='trad' or com=='tradi' or com=='corr' or com=='rev' or com=='revi': lsTx,sltgl.lspals.colPalDu=masdatos sltgl.lspals.colTx=[] for tx in lsTx: paltx=self.infopal() paltx.paltext=tx[tx_paltext] paltx.palori=tx[tx_paltext] paltx.nordori=tx[tx_nordori] paltx.carfinpal=tx[tx_carfinpal] paltx.italica=tx[tx_italica] paltx.italicaori=tx[tx_italicaori] sltgl.lspals.InfCompl(paltx) sltgl.lspals.colTx.append(paltx) elif com=='txtrad' or com=='txtradi' or com=='txcorr': txt,sltgl.lspals.colPalDu=masdatos sltgl.lspals.colTx=[] lsTx=self.TxtaLista(txt) for tx in lsTx: paltx=self.infopal() paltx.paltext=tx[tx_paltext] paltx.palori=tx[tx_paltext] paltx.nordori=tx[tx_nordori] paltx.carfinpal=tx[tx_carfinpal] paltx.italica=tx[tx_italica] paltx.italicaori=tx[tx_italicaori] sltgl.lspals.InfCompl(paltx) sltgl.lspals.colTx.append(paltx) def TxtaLista(self,txt): #Obtener lista de palabras a partir de un texto #Entrada: Texto a pasar a lista #Retorno: Lista de palabras del texto colTx=[] lspals=txt.split() i=0 for pal in lspals: if ",;:.?!".find(pal[-1])>-1: p1=pal[0:-1] s=pal[-1] p2=s elif "¿¡".find(pal[0])>-1: p1=pal[0] s=pal[0] p2=pal[1:] else: p1=pal s=" " p2="" txpal=(p1,i,s,0,0) colTx.append(txpal) i=i+1 if p2!="": txpal=(p2,i," ",0,0) colTx.append(txpal) i=i+1 return colTx def ListaaTxt(self,colTx): #Convertir lista de palabras a texto #Entrada: colTx: Lista de palabras #Retorno: texto correspondiente a colTx txt="" for e in colTx: if txt!="" and e[0]!="." and e[0]!="," and e[0]!=";" and e[0]!=":" and e[0]!="?" and e[0]!="!": txt=txt+" " txt=txt+e[0] return txt # end of class sltsalt # VB2PY (UntranslatedCode) Attribute VB_Name = "sltsalt" # VB2PY (UntranslatedCode) Attribute VB_GlobalNameSpace = True # VB2PY (UntranslatedCode) Attribute VB_Creatable = True # VB2PY (UntranslatedCode) Attribute VB_PredeclaredId = False # VB2PY (UntranslatedCode) Attribute VB_Exposed = True # VB2PY (UntranslatedCode) Option Explicit # -------------------------------------------------------- # Párrafo a traducir (colección de palabras) # -------------------------------------------------------- # -------------------------------------------------------- # Definición del elemento que corresponde a una palabra # o frase dudosa, guardado en memoria hasta que se # termine de traducir o corregir el texto # --------------------------------------------------------