source: salt-server/trunk/fuentes/sltsalt.py @ 473

Last change on this file since 473 was 473, checked in by daduve, 3 years ago

Adding files

  • Property svn:executable set to *
File size: 26.7 KB
Line 
1# -*- coding: latin-1 -*-
2import vbfunctions
3import sltgl
4import slttx
5import sltgen
6import sltcorr
7import sltinfopal
8
9def ini():
10  global PalabraAct,PalabraSig,PalabraAnt,FiltroApo
11  PalabraAct=slttx.PalabraAct
12  PalabraSig=slttx.PalabraSig
13  PalabraAnt=slttx.PalabraAnt
14  FiltroApo=slttx.FiltroApo
15  global VerMayuscula,SubstituirPalabra,PonMayuscula
16  VerMayuscula=sltcorr.VerMayuscula
17  SubstituirPalabra=sltcorr.SubstituirPalabra
18  PonMayuscula=sltcorr.PonMayuscula
19  global RSet,ByRef,InStr,Trim
20  RSet=sltgen.RSet
21  ByRef=sltgen.ByRef
22  InStr=sltgen.InStr
23  Trim=sltgen.Trim
24  global AbrirBd,BdClone,CerrarBd,PalTextIni,DamePalabra,Palabra,NumEnLista,DamePalEnLista
25  AbrirBd=sltgen.AbrirBd
26  BdClone=sltgen.BdClone
27  CerrarBd=sltgen.CerrarBd
28  PalTextIni=sltgen.PalTextIni
29  DamePalabra=sltgen.DamePalabra
30  Palabra=sltgen.Palabra
31  NumEnLista=sltgen.NumEnLista
32  DamePalEnLista=sltgen.DamePalEnLista
33
34#Constantes que definen la estructura de cada elemento de colTx
35tx_paltext=0
36tx_nordori=1
37tx_carfinpal=2
38tx_italica=3
39tx_italicaori=4
40
41class sltsalt(vbfunctions.Object):
42 
43  class infopal:
44    def __init__(self):
45      self.paltext = vbfunctions.String()
46      self.paldic = vbfunctions.String()
47      self.pre = vbfunctions.String()
48      self.sepsil = vbfunctions.Integer()
49      self.pal1 = vbfunctions.String()
50      self.pal2 = vbfunctions.String()
51      self.tipopost = vbfunctions.Integer()
52      self.post = vbfunctions.String()
53      self.xi = vbfunctions.Integer()
54      self.tipoletra = vbfunctions.Integer()
55      self.signopunt = vbfunctions.Integer()
56      self.postsignopunt = vbfunctions.Integer()
57      self.carfinpal = vbfunctions.String()
58      self.italica = vbfunctions.Integer()
59      self.italicaori = vbfunctions.Integer()
60      self.palori = vbfunctions.String()
61      self.nordori = vbfunctions.Long()
62      self.ipaldu = vbfunctions.Long()
63
64  colTx = []
65  ipa = vbfunctions.Long()
66  class tPalDu:
67    def __init__(self):
68      self.Clave = vbfunctions.String()
69      self.pos = vbfunctions.Long()
70      self.Info = vbfunctions.String()
71
72  #colPalDu={n:{'Clave':xx,'pos':n,'Info':xx},n:{}...} No usamos tPalDu
73  colPalDu = {}
74
75  def DocLista(self):
76    #
77    #   Obtener una lista de palabras a partir de un documento
78    #
79    #   Entrada: tx: Documento cuyas palabras hay que pasar a la lista.
80    #               Si SelLenght=0 se pasa todo; sino la parte seleccionada
81    #
82    #   Salida:  ls: Lista de palabras del documento
83    #
84    #Posición de partida y de final
85    pi = 1
86    pf=0
87    cf=""
88    self.colTx = []
89    pft = pi + len(sltgl.txDOC)
90    #Primera palabra
91    i = 0
92    pal,pi,pf,cf = PalabraAct(pi, pi, pf, cf)
93    while pal <> '' and pi < pft:
94      #Hay nueva palabra
95      txpal=self.infopal()
96      txpal.nordori = i
97      txpal.palori = pal
98      txpal.paltext = pal
99      txpal.italica = 0
100      txpal.carfinpal = cf
101      self.InfCompl(txpal)
102      self.colTx.append(txpal)
103      self.ipa = len(self.colTx)-1
104      #Siguiente palabra
105      i = i + 1
106      pi = pf
107      pal,pi,pf,cf = PalabraSig(pi, pi, pf, cf)
108    #Dejar como palabra actual la primera de la lista
109    self.ipa = 0
110
111  def OOoDocLista(self,cursor):
112    #
113    #   Obtener una lista de palabras a partir de un documento OOo
114    #
115    #   Entrada: cursor: Cursor al documento cuyas palabras hay que pasar a la lista.
116    #               Si SelLenght=0 se pasa todo; sino la parte seleccionada
117    #
118    #   Salida:  colTx: Lista de palabras del documento
119    #
120    self.colTx = []
121    i=0
122    ret=cursor.gotoStart(0)
123    ret=cursor.gotoStartOfWord(0)
124    while ret == True:
125      cursor.gotoEndOfWord(1)
126      pal=cursor.getString()
127      cf=""
128      if len(pal)>0:
129        cf=pal[len(pal)-1]
130      txpal=self.infopal()
131      txpal.nordori = i
132      txpal.palori = pal
133      txpal.paltext = pal
134      txpal.italica = 0
135      txpal.carfinpal = cf
136      self.InfCompl(txpal)
137      self.colTx.append(txpal)
138      self.ipa = len(self.colTx)-1
139      i=i+1
140      ret=cursor.gotoNextWord(0)
141       
142    #Dejar como palabra actual la primera de la lista
143    self.ipa = 0
144   
145  def PrAuCtvShow(self):
146    #
147    #   Proceso automático.
148    #   Presentación del Form frmCtv si no estamos en proceso
149    #   automático. En caso contrario, cambia en el texto el
150    #   texto erróneo por la propuesta de cambio (que
151    #   corresponde a la primera alternativa, si hay varias) y
152    #   tambien guarda la información complementaria necesaria
153    #   para que posteriormente se pueda presentar al operador
154    #   el cambio que ha realizado y las alternativas que
155    #   habia.
156    #
157    #ATENCIóN: Crear otra función para llamarla desde revisión de la forma
158    #que en Salt3 se llama "modo no automático" (presentar frmCtv al operador)
159    #Modo automático
160    #Preparar información complementaria
161    Info=""
162    #paldu=self.tPalDu()
163    paldu={}
164    palalt = Trim(sltgl.tx_pal)
165    n = len(sltgl.ls_alt)
166    if palalt == '' and n > 0:
167      #Si no hay palalt, obtenerla de la lista
168      palalt = DamePalEnLista(sltgl.ls_alt[0])
169    Info=self.PrAuInfoGuardar(Info, sltgl.praunumalts, Trim(str(n)))
170    Info=self.PrAuInfoGuardar(Info, sltgl.prautxtdu, Trim(sltgl.tx_palerr))
171    Info=self.PrAuInfoGuardar(Info, sltgl.prautxtpro, palalt)
172    i=0
173    while i<= n - 1:
174      pal = Trim(sltgl.ls_alt[i])
175      Info=self.PrAuInfoGuardar(Info, sltgl.praualt + Trim(str(i+1)), pal)
176      i=i+1
177    Info=self.PrAuInfoGuardar(Info, sltgl.praudescrierror, Trim(sltgl.lb_mens))
178    Info=self.PrAuInfoGuardar(Info, sltgl.praunpretro, Trim(str(sltgl.npretro)))
179    #Guardar información sobre la palabra dudosa
180    paldu["Clave"] = palalt
181    paldu["pos"] = self.ipa
182    paldu["Info"] = Info
183    paldu["dtr"]=sltgl.dtractual
184    #self.colPalDu.append(paldu)
185    self.colPalDu[self.ipa]=paldu
186    i = self.ipa
187    #Simular actuación de frmCtv.cmbSubs
188    _select429 = sltgl.ctvmodocorrtrad
189    if (_select429 == sltgl.CTV_ESCORR):
190      #Substituir palabra en el texto
191      if sltgl.enrevisio:
192        t=ByRef()
193        s=""
194        self.PrAuInfoLeer(paldu["Info"], sltgl.praudescrierror, t.a((s,)))
195        s,=t.r()
196        if s<>"Castellanisme":
197          SubstituirPalabra(palalt)
198      #self.colPalDu[i]["Clave"] = Trim(sltgl.tx_palerr)
199      self.colPalDu[i]["Clave"]=Trim(sltgl.tx_palerr)
200      i = DamePalabra(1)
201    elif (_select429 == sltgl.CTV_ESTRAD) or (_select429 == sltgl.CTV_ESTRAD2):
202      #Guardar palabra
203      sltgl.palsel = palalt
204    sltgl.ctverr = sltgl.NO
205    #Borrar en Form
206    sltgl.tx_pal = ''
207    sltgl.tx_palerr = ''
208    sltgl.lb_mens = ''
209    sltgl.ls_alt=[]
210
211  def PrAuIni(self):
212    #
213    #   Inicializar el proceso automático
214    #
215    self.colPalDu = {}
216
217  def PrAuInfoGuardar(self, Info, Cod, txt):
218    #
219    #   Guardar datos en el string de información adicional.
220    #   El string contiene elementos de la forma:
221    #       $Código=Información$
222    #
223    #   Entrada:    Info: vbfunctions.String de información adicional
224    #               Cod: Código del elemento a guardar
225    #               Txt: Texto informativo correspondiente a Cod
226    #   Retorno:    Info, con el nuevo elemento añadido
227    return Info + '_' + Cod + '=' + txt + '_' + '\n'
228
229  def PrAuListaPalDu(self):
230    #
231    #   Guardar en el documento actual la información
232    #   asociada a cada palabra dudosa, para poder presentar
233    #   posteriormente las opciones al operador
234    #
235    t=ByRef()
236    sltgl.ls_paldu=[]
237    s=""
238    for n in self.colPalDu:
239      paldu=self.colPalDu[n]
240      if paldu["Clave"] <> '':
241        #Mostrar información de la palabra dudosa
242        txt = paldu["Clave"] + ';' + str(paldu["pos"]) + ';' + paldu["Info"]
243        if self.PrAuInfoLeer(paldu["Info"], sltgl.praunumalts, t.a((s,))):
244          s,=t.r()
245          if s == '0':
246            txt = txt + ';' + 'DESCONOCIDA'
247          else:
248            txt = txt + ';' + 'DUDOSA'
249        sltgl.ls_paldu.append(txt)
250        #print txt
251
252  def PrAuInfoLeer(self, Info, Cod, t):
253    txt,=t.r()
254    _ret = None
255    #
256    #   Leer un elemento de la información adicional que se
257    #   guarda junto a cada texto dudoso, en el proceso
258    #   automático
259    #
260    #   Entrada:    Info: vbfunctions.String de información adicional
261    #               Cod: Código a buscar
262    #
263    #   Salida:     Txt: Texto informativo correspondiente a
264    #                       Cod, si existe ese elemento en Info
265    #                       (en caso contrario "")
266    #
267    #   Retorno:    True: Encontrado elemento Cod en Info
268    #               False: No encontrado elemento Cod
269    #
270    _ret = False
271    txt = ''
272    pi = InStr(Info, '_' + Cod + '=')
273    if pi > 0:
274      pi = pi + len(Cod) + 2
275      pf = InStr(Info, '_',pi)
276      if pf > 0:
277        txt = vbfunctions.Mid(Info, pi, pf - pi)
278      else:
279        txt = vbfunctions.Mid(Info, pi)
280      _ret = True
281    t.a((txt,))
282    return _ret
283
284  def InfCompl(self, paltx):
285    #
286    #   Obtener más información sobre palabra actual
287    #   La palabra se pasa en paltx, pero aun no se ha añadido a la colección
288    #   por lo que el índice de la palabra anterior es ipa o Count
289    #
290    #
291    rval=RSet()
292    #Set rVal = RMetaFlex.Clone()
293    #Ver si es palabra especial
294    HayApo = sltgl.NO
295    HayGui = sltgl.NO
296    HayXi = sltgl.NO
297    lonpal = len(paltx.paltext)
298    if lonpal > 0:
299      for j in vbfunctions.vbForRange(1, lonpal):
300        _select430 = vbfunctions.Mid(paltx.paltext, j, 1)
301        if (_select430 == '\''):
302          if lonpal > 2:
303            HayApo = sltgl.SI
304        elif (_select430 == '-'):
305          HayGui = sltgl.SI
306        elif ('0' <= _select430 <= '9') or (_select430 == '@') or (_select430 == '#') or (_select430 == '$') or (_select430 == '%') or (_select430 == '&') or (_select430 == '/'):
307          HayXi = sltgl.SI
308    pal = vbfunctions.LCase(paltx.paltext)
309    #Apóstrofe
310    par = ''
311    parpost = ''
312    if HayApo == sltgl.SI:
313      p = InStr(pal, '\'')
314      while p > 0:
315        #Puede haber apóstrofe
316        if p == 2:
317          #Si hay apóstrofe lo guardamos en minúsculas
318          par = vbfunctions.LCase(vbfunctions.Left(pal, p - 1))
319          pal = vbfunctions.Mid(pal, p + 1)
320        else:
321          #Es apóstrofe posterior
322          parpost = vbfunctions.LCase(vbfunctions.Mid(pal, p + 1))
323          pal = vbfunctions.Left(pal, p - 1)
324        p = InStr(pal, '\'')
325    #Separación silábica
326    parte1 = ''
327    parte2 = ''
328    haysepsil = sltgl.NO
329    if HayGui == sltgl.SI:
330      p = InStr(pal, '-')
331      if p > 0:
332        #Puede ser ,palabra (para-sol), verbo+pronombre o sep. silábica
333        if p > 1:
334          parte1 = vbfunctions.Left(pal, p - 1)
335        parte2 = vbfunctions.Mid(pal, p + 1)
336        if parpost <> '':
337          #Es -aaa'bb
338          parte2 = parte2 + '\'' + parpost
339          parpost = ''
340        #rVal.Index = "IdxVeu"
341        #rVal.Seek "=", parte1 + "-" + parte2
342        rval.Open(sltgl.bd_metaflex_Veu)
343        rval.Seek((parte1 + '-' + parte2,))
344        #sql = 'select * from metaflex where Veu = %s' #+ parte1 + '-' + parte2 + '"'
345        #rval.OpenR(sql, (parte1 + '-' + parte2,))
346        if not rval.noesta:
347          #Existe en el diccionario con -
348          pal = parte1 + '-' + parte2
349        else:
350          #rVal.Seek "=", parte1 + parte2
351          rval.Seek((parte1 + parte2,))
352          #sql = 'select * from metaflex where Veu = %s' #+ parte1 + parte2 + '"'
353          #rval.OpenR(sql, (parte1 + parte2,))
354          if rval.noesta:
355            #Es verbo-pronombre
356            pal = parte1
357          else:
358            #Hay separación silábica
359            haysepsil = sltgl.SI
360            pal = parte1 + parte2
361    #Guardar palabra "como está en los diccionarios"
362    paltx.paldic = pal
363    #Es la palabra actual: guardar información complementaria
364    paltx.pre = par.strip()
365    paltx.post = parpost.strip()
366    paltx.sepsil = haysepsil
367    paltx.pal1 = parte1
368    paltx.pal2 = parte2
369    #Mayúsculas / minúsculas
370    paltx.tipoletra = VerMayuscula(paltx.paltext)
371    #Ver si hay cifras dentro de la palabra
372    paltx.xi = HayXi
373    #Caso especial 1 y 11
374    if paltx.paltext == '1' or paltx.paltext == '11':
375      paltx.xi = sltgl.NO
376    #Ver si es signo de puntuación
377    _select431 = paltx.paltext
378    #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 == '\''):
379    #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 == '\''):
380    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 == '\''):
381      #Es signo de puntuación
382      paltx.signopunt = sltgl.SI
383    else:
384      paltx.signopunt = sltgl.NO
385    #Ver si sigue a signo de puntuación
386    if len(sltgl.lspals.colTx) > 0:
387      i = len(sltgl.lspals.colTx)-1
388      if self.colTx[i].paltext == '.' or self.colTx[i].paltext == ',' or self.colTx[i].paltext == ':' or self.colTx[i].paltext == ';':
389        paltx.postsignopunt = sltgl.SI
390      else:
391        paltx.postsignopunt = sltgl.NO
392    else:
393      paltx.postsignopunt = sltgl.NO
394
395  def Modif(self, i, nue):
396    #
397    #   Modifica el contenido de un ítem de la colección colTx
398    #   Para ello lo elimina y lo vuelve a crear en la posición correspondiente
399    #
400    #   Entrada: i: índice del ítem a modificar
401    #            nue: Nuevo contenido
402    #
403    #self.colTx.Remove(i)
404    #if self.colTx.Count == 0 or i > self.colTx.Count:
405      #self.colTx.Add(nue)
406    #else:
407      #self.colTx.Add(nue, i)
408    self.colTx[i]=nue
409
410  def InsertarPost(self, pal):
411    #
412    #   Insertar un elemento en la colección colTx a continuación del elemento actual.
413    #   El elemento actual sigue siendo el mismo
414    #   Hereda el nordori de la palabra actual
415    #
416    #   Entrada: pal: Palabra a insertar
417    #
418    txpal=sltinfopal.infopal()
419    txpal.nordori = self.colTx[self.ipa].nordori
420    txpal.palori = ''
421    txpal.paltext = pal
422    txpal.italica = sltgl.NO
423    self.InfCompl(txpal)
424    if self.ipa < len(self.colTx):
425      #insertar post actual = insertar antes del siguiente
426      i=self.ipa+1
427      self.colTx.insert(i,txpal)
428    else:
429      #añadir
430      self.colTx.append(txpal)
431
432  def InsertarAnt(self, pal):
433    #
434    #   Insertar un elemento en la colección colTx antes del elemento actual.
435    #   El elemento actual sigue siendo el mismo ipa (el insertado)
436    #   Hereda toda la información original de la palabra actual
437    #
438    #   Entrada: pal: Palabra a insertar
439    #
440    txpal=sltinfopal.infopal()
441    txpal.nordori = self.colTx[self.ipa].nordori
442    txpal.palori = self.colTx[self.ipa].palori
443    txpal.paltext = pal
444    txpal.italica = self.colTx[self.ipa].italica
445    self.InfCompl(txpal)
446    self.colTx.insert(self.ipa,txpal)
447
448  def Modif_paltext(self, i, ptext):
449    #
450    #   Modifica el contenido de paltext de un ítem de la lista colTx
451    #
452    #   Entrada: i: índice del ítem a modificar
453    #            ptext: Nuevo contenido
454    #
455    self.colTx[i].paltext=ptext
456    self.InfCompl(self.colTx[i])
457
458  def ListaDoc(self):
459    #
460    #   Modificar el documento a partir de la lista de palabras
461    #
462    #
463    #Posición de partida y de final
464    pf=0
465    pi = 1
466    cf=""
467    pft = pi + len(sltgl.txDOC)
468    #Primera palabra
469    pal,pi,pf,cf = PalabraAct(pi, pi, pf, cf)
470    i = 0
471    j = 0
472    while pal <> '' and pi < pft:
473      #Hay nueva palabra
474      if self.colTx[j].nordori > i:
475        #Eliminar palabra en el documento
476        if pi > 1:
477          if vbfunctions.Mid(sltgl.txDOC, pi - 1, 1) == ' ':
478            #Eliminar el espacio anterior
479            pi = pi - 1
480        #vbfunctions.Mid(txDOC, pi, pf - pi + 1) = ""
481        sltgl.txDOC = vbfunctions.Left(sltgl.txDOC, pi - 1) + vbfunctions.Mid(sltgl.txDOC, pf + 1)
482        pf = pi
483      elif self.colTx[j].nordori == i:
484        #Sustituir / insertar palabras
485        pal = self.colTx[j].paltext
486        while j < len(self.colTx)-1:
487          if self.colTx[j + 1].nordori == i:
488            j = j + 1
489            pal = pal + ' ' + self.colTx[j].paltext
490          else:
491            break
492        #txDOC.SelStart = pi - 1
493        #txDOC.SelLength = pf - pi + 1
494        #If colTx(j).italica <> colTx(j).italicaori Then
495        #    txDOC.FontItalic = colTx(j).italica
496        #End If
497        #txDOC.SelText = pal
498        #vbfunctions.Mid(txDOC, pi, pf - pi + 1) = pal
499        sltgl.txDOC = vbfunctions.Left(sltgl.txDOC, pi - 1) + pal + vbfunctions.Mid(sltgl.txDOC, pf + 1)
500        j = j + 1
501        pf = pi + len(pal) - 1
502      #Siguiente palabra
503      pi = pf
504      pal,pi,pf,cf = PalabraSig(pi, pi, pf, cf)
505      i = i + 1
506 
507  def OooListaDoc(self,cursor):
508    #
509    #   Copiar una lista de palabras a un documento OOo
510    #
511    #   Entrada: cursor: Cursor al documento cuyas palabras hay que pasar a la lista.
512    #               Si SelLenght=0 se pasa todo; sino la parte seleccionada
513    #
514    #
515    i = 0
516    j = 0
517    ret=cursor.gotoStartOfWord(0)
518    while ret == True:
519      cursor.gotoEndOfWord(1)
520      #Hay nueva palabra
521      if self.colTx[j].nordori > i:
522        #Eliminar palabra en el documento
523        cursor.vbfunctions.String=""
524      elif self.colTx[j].nordori == i:
525        #Sustituir / insertar palabras
526        pal = self.colTx[j].paltext
527        while j < len(self.colTx)-1:
528          if self.colTx[j + 1].nordori == i:
529            j = j + 1
530            pal = pal + ' ' + self.colTx[j].paltext
531          else:
532            break
533        cursor.vbfunctions.String=pal
534        j = j + 1
535      #Siguiente palabra
536      ret=cursor.gotoNextWord(0)
537      i = i + 1
538   
539  def PrAuListaDoc(self):
540    #
541    #   Guardar en el documento actual la información
542    #   asociada a cada palabra dudosa, para poder presentar
543    #   posteriormente las opciones al operador
544    #
545    sltgl.ls_paldu.append('--------------------')
546    for pal in self.colTx:
547      txt = pal.paltext + ' ' + str(pal.nordori) + ' ' + pal.palori
548      sltgl.ls_paldu.append(txt)
549      #print txt
550
551  def QuitaApopstrofes(self):
552    #
553    #   Quitar todos los apóstrofes de la lista colTx substituyéndolos por la
554    #   palabra correspondiente
555    #
556    ipaini = self.ipa
557    i = 0
558    while i <= len(self.colTx)-1:
559      pal = ''
560      if vbfunctions.LCase(vbfunctions.Left(self.colTx[i].paltext, 2)) == "d'" or vbfunctions.LCase(vbfunctions.Left(self.colTx[i].paltext, 2)) == "d"+chr(146):
561        #Es d'
562        tl = self.colTx[i].tipoletra
563        if tl == sltgl.TL_TODOMAYUS and VerMayuscula(vbfunctions.Left(self.colTx[i].paltext, 3)) <> sltgl.TL_TODOMAYUS:
564          tl = sltgl.TL_PRIMERAMAYUS
565        pal = PonMayuscula('de', tl)
566      elif vbfunctions.LCase(vbfunctions.Left(self.colTx[i].paltext, 2)) == "l'" or vbfunctions.LCase(vbfunctions.Left(self.colTx[i].paltext, 2)) == "l"+chr(146):
567        #Es l'
568        tl = self.colTx[i].tipoletra
569        if tl == sltgl.TL_TODOMAYUS and VerMayuscula(vbfunctions.Left(self.colTx[i].paltext, 3)) <> sltgl.TL_TODOMAYUS:
570          tl = sltgl.TL_PRIMERAMAYUS
571        pal = PonMayuscula('el', tl)
572      if pal <> '':
573        #Modificar palabra actual
574        pal2 = vbfunctions.Mid(self.colTx[i].paltext, 3)
575        self.Modif_paltext(i, pal2)
576        #Insertar palabra antes de la actual
577        self.ipa = i
578        self.InsertarAnt(pal)
579        #Saltar palabra insertada
580        i = i + 1
581      #Siguiente elemento
582      i = i + 1
583    self.ipa = ipaini
584
585  def Modif_italica(self, i, ital):
586    #
587    #   Modifica el contenido de italica de un ítem de la colección colTx
588    #
589    #   Entrada: i: índice del ítem a modificar
590    #            ptext: Nuevo contenido
591    #
592    self.colTx[i].italica=ital
593
594  def Picklar2(self,com):
595    #Obtener información adicional a partir de las variables globales en caso de comandos tipo trad
596    #Entrada: com: Comando
597    #Retorno: (colTx,colPalDu) a partir de información en memoria
598    if com=='trad' or com=='tradi' or com=='corr' or com=='rev' or com=='revi' or com=='void':
599      #Afinar palabras dudosas
600      for m in sltgl.lspals.colPalDu.keys():
601        i=m
602        if i>len(sltgl.lspals.colTx)-1:
603          i=len(sltgl.lspals.colTx)-1
604        #if sltgl.lspals.colPalDu[m]['Clave']!=sltgl.lspals.colTx[i].paldic:
605        if sltgl.lspals.colPalDu[m]['Clave']!=sltgl.lspals.colTx[i].paltext:
606          #Hay que afinar
607          n=sltgl.lspals.colPalDu[m]['Clave'].count(' ')+1
608          k=-1
609          for j in range(-2,2):
610            if i+j>=0 and i+j+n-1<len(sltgl.lspals.colTx):
611              pal=paldic=""
612              for jj in range(n):
613                pal=pal+" "+sltgl.lspals.colTx[i+j+jj].paltext
614                paldic=paldic+" "+sltgl.lspals.colTx[i+j+jj].paldic
615              pal=pal.strip()
616              paldic=paldic.strip()
617              if sltgl.lspals.colPalDu[m]['Clave']==pal or sltgl.lspals.colPalDu[m]['Clave']==paldic:
618                k=i+j
619                break
620          if k>-1 and k!=m:
621            #Se ha encontrado una palabra que coincide
622            sltgl.lspals.colPalDu[k]=sltgl.lspals.colPalDu[m]
623            sltgl.lspals.colPalDu[k]['pos']=k
624            del sltgl.lspals.colPalDu[m]
625          elif k==-1:
626            #No se ha encontrado una palabra que coincida
627            del sltgl.lspals.colPalDu[m]
628 
629      #Componer lista de palabras
630      lsTx=[]
631      for paltx in sltgl.lspals.colTx:
632        tx=(paltx.paltext,paltx.nordori,paltx.carfinpal,paltx.italica,paltx.italicaori)
633        lsTx.append(tx)
634      return (lsTx,sltgl.lspals.colPalDu)
635    elif com=='txtrad' or com=='txtradi' or com=='txcorr':
636      for m in sltgl.lspals.colPalDu.keys():
637        newkey=sltgl.lspals.colPalDu[m]['Clave']+"_("+str(m)+")"
638        sltgl.lspals.colPalDu[newkey]=sltgl.lspals.colPalDu[m]
639        del sltgl.lspals.colPalDu[m]
640     
641      #Componer lista de palabras
642      lsTx=[]
643      for paltx in sltgl.lspals.colTx:
644        tx=(paltx.paltext,paltx.nordori,paltx.carfinpal,paltx.italica,paltx.italicaori)
645        lsTx.append(tx)
646      txt=self.ListaaTxt(lsTx)
647      return (txt,sltgl.lspals.colPalDu)
648
649  def Unpicklar2(self,com,masdatos):
650    #Unpiclar la información recibida
651    #Entrada: com: Comando recibido
652    #         masdatos: (colTx,colPalDu) es el resto de la información que
653    #                   hay que guardar en variables globales (en el caso de comandos tipo trad)
654    sltgl.lspals.ipa=0
655    if com=='trad' or com=='tradi' or com=='corr' or com=='rev' or com=='revi':
656      lsTx,sltgl.lspals.colPalDu=masdatos
657      sltgl.lspals.colTx=[]
658      for tx in lsTx:
659        paltx=self.infopal()
660        paltx.paltext=tx[tx_paltext]
661        paltx.palori=tx[tx_paltext]
662        paltx.nordori=tx[tx_nordori]
663        paltx.carfinpal=tx[tx_carfinpal]
664        paltx.italica=tx[tx_italica]
665        paltx.italicaori=tx[tx_italicaori]
666        sltgl.lspals.InfCompl(paltx)
667        sltgl.lspals.colTx.append(paltx)
668    elif com=='txtrad' or com=='txtradi' or com=='txcorr':
669      txt,sltgl.lspals.colPalDu=masdatos
670      sltgl.lspals.colTx=[]
671      lsTx=self.TxtaLista(txt)
672      for tx in lsTx:
673        paltx=self.infopal()
674        paltx.paltext=tx[tx_paltext]
675        paltx.palori=tx[tx_paltext]
676        paltx.nordori=tx[tx_nordori]
677        paltx.carfinpal=tx[tx_carfinpal]
678        paltx.italica=tx[tx_italica]
679        paltx.italicaori=tx[tx_italicaori]
680        sltgl.lspals.InfCompl(paltx)
681        sltgl.lspals.colTx.append(paltx)
682
683  def TxtaLista(self,txt):
684    #Obtener lista de palabras a partir de un texto
685    #Entrada: Texto a pasar a lista
686    #Retorno: Lista de palabras del texto
687    colTx=[]
688    lspals=txt.split()
689    i=0
690    for pal in lspals:
691      if ",;:.?!".find(pal[-1])>-1:
692        p1=pal[0:-1]
693        s=pal[-1]
694        p2=s
695      elif "¿¡".find(pal[0])>-1:
696        p1=pal[0]
697        s=pal[0]
698        p2=pal[1:]
699      else:
700        p1=pal
701        s=" "
702        p2=""
703      txpal=(p1,i,s,0,0)
704      colTx.append(txpal)
705      i=i+1
706      if p2!="":
707        txpal=(p2,i," ",0,0)
708        colTx.append(txpal)
709        i=i+1
710    return colTx
711 
712  def ListaaTxt(self,colTx):
713    #Convertir lista de palabras a texto
714    #Entrada: colTx: Lista de palabras
715    #Retorno: texto correspondiente a colTx
716    txt=""
717    for e in colTx:
718      if txt!="" and e[0]!="." and e[0]!="," and e[0]!=";" and e[0]!=":" and e[0]!="?" and e[0]!="!":
719        txt=txt+" "
720      txt=txt+e[0]
721    return txt
722
723# end of class sltsalt
724
725  # VB2PY (UntranslatedCode) Attribute VB_Name = "sltsalt"
726  # VB2PY (UntranslatedCode) Attribute VB_GlobalNameSpace = True
727  # VB2PY (UntranslatedCode) Attribute VB_Creatable = True
728  # VB2PY (UntranslatedCode) Attribute VB_PredeclaredId = False
729  # VB2PY (UntranslatedCode) Attribute VB_Exposed = True
730  # VB2PY (UntranslatedCode) Option Explicit
731  # --------------------------------------------------------
732  #   Párrafo a traducir (colección de palabras)
733  # --------------------------------------------------------
734  # --------------------------------------------------------
735  #   Definición del elemento que corresponde a una palabra
736  #   o frase dudosa, guardado en memoria hasta que se
737  #   termine de traducir o corregir el texto
738  # --------------------------------------------------------
Note: See TracBrowser for help on using the repository browser.