# -*- coding: utf-8 -*-


import time,sys,os,os.path,itertools
import win32com.client,win32clipboard
import _winreg
import urllib,base64,binascii,time
import htmlentitydefs

GlobalPVersion='3.15b'


"""
3.13    ouverture popmenu par code
3.12    + arbre + popmenu + fenêtres filles
3.06    possibilité d'injection de Ponx
3.05    optimisation tableau
3.02    '==None' ==> 'is None'
3.01    correction d'un bug
"""




try:
    name, ponxdir, typ = _winreg.EnumValue(_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, 'SOFTWARE\Classes\CLSID\{EC501258-201C-449C-BE20-837A316EA382}\PythonCOMPath'), 0)
    ponxdir+='\\'
    pluie_toolsdir=ponxdir+'putils\\'
    if not sys.path.__contains__(ponxdir[:-1]):  sys.path.append(ponxdir[:-1])
    include_dir=ponxdir+'pluie\\include\\'
    pluimg_dir=ponxdir+'pluie\\pluimg\\'
except:
    ponxdir=os.getcwd()+'\\'
    pluie_toolsdir=ponxdir+'putils\\'
    include_dir=ponxdir+'include\\'
    pluimg_dir=ponxdir+'pluimg\\'

try:
    
    import pluie_ini
    try:
        ponxdir=pluie_ini.ponxdir
    except:
        pass
    try:
        pluie_toolsdir=pluie_ini.pluie_toolsdir
    except:
        pass
    try:
        include_dir=pluie_ini.include_dir
    except:
        pass
    try:
        pluimg_dir=pluie_ini.pluimg_dir
    except:
        pass
except:
    pass
    #



#*** piqué à Ponx ***
def clipboardtxt(chaine=None):
    import win32clipboard,win32con
    try:
        win32clipboard.OpenClipboard()
        if chaine is None:
            try:
                chaine=win32clipboard.GetClipboardData(win32con.CF_TEXT)
                #win32clipboard.EmptyClipboard()
                #win32clipboard.SetClipboardText(chaine)
                return(chaine)
            except:
                chaineretour=''
                return('')
        else:
            try:
                win32clipboard.EmptyClipboard()
                win32clipboard.SetClipboardText(chaine)
            except:
                pass
    except:
        pass
    try:
        win32clipboard.CloseClipboard()
    except:
        pass




def u1252(chu):
    try:
        if type(chu) is unicode:
            return chu.encode('cp1252','replace')
        else:
            return chu
    except:
        return repr(chu)


def u850(chu):
    try:
        if type(chu) is unicode:
            return chu.encode('cp850','replace')
        else:
            return chu.decode('cp1252').encode('cp850','replace')
    except:
        return repr(chu)


def u437(chu):
    try:
        if type(chu) is unicode:
            return chu.encode('cp437','replace')
        else:
            return chu.decode('cp1252').encode('cp437','replace')
    except:
        return repr(chu)


def upe(chu):
    return str(chu)




class ieevents:
   def OnVisible(self, visible):
      print "Visible changed:", visible




class form(object):

    ie_id=100000
    fichecourante=None
    conteneurcourant=None

    def __init__(self, **pars):

        form.ie_id=100000
        form.fichecourante=None
        form.conteneurcourant=None

        self.elemid={}
        self.elemid[u'']=None
        self.elemid['pluie_menu_box']=None


        if 'formcaller' in pars:
            self.formcaller=pars['formcaller']

            ptaille=''
            if 'x' in pars:
                ptaille+=',left='+str(pars['x'])
            if 'left' in pars:
                ptaille+=',left='+str(pars['left'])
            if 'y' in pars:
                ptaille+=',top='+str(pars['y'])
            if 'top' in pars:
                ptaille+=',top='+str(pars['top'])
            if 'width' in pars:
                ptaille+=',width='+str(pars['width'])
            if 'height' in pars:
                ptaille+=',height='+str(pars['height'])


            self.window=self.formcaller.window.open(r'file:///'+os.getcwd().replace('\\','/')+'/pluie___.htm','',ptaille[1:])
            time.sleep(0.1)
            self.ie=self.window
            form.fichecourante=self
            self.doc=self.window.Document
            self.body=self.window.Document.Body

        else:

            self.ie=win32com.client.Dispatch('InternetExplorer.Application')
            #self.ie=win32com.client.DispatchWithEvents('InternetExplorer.Application', ieevents)
            #self.ie.Navigate(r'about:NoAdd-ons')

            form.fichecourante=self
            self.ie.ToolBar=False
            self.ie.AddressBar=False
            self.ie.MenuBar=False
            self.ie.StatusBar=True

            if 'x' in pars:
                self.ie.Left=pars['x']
            if 'left' in pars:
                self.ie.Left=pars['left']
            if 'y' in pars:
                self.ie.Top=pars['y']
            if 'top' in pars:
                self.ie.Top=pars['top']
            if 'width' in pars:
                self.ie.Width=pars['width']
            if 'height' in pars:
                self.ie.Height=pars['height']

            if 'url' in pars:
                self.ie.Navigate(pars['url'])
            elif 'template' in pars:
                self.ie.Navigate(pars['template'])
            else:
                self.ie.Navigate(r'file:///'+os.getcwd().replace('\\','/')+'/pluie___.htm')
                """
                stmp = r'file:///'+os.getcwd().replace('\\','/')+'/pluie___.htm'
                self.window=self.ie.Document.parentWindow
                print 210,stmp
                self.window.alert('AAAAAAA')
                self.window.location.href = stmp
                print 213
                """
            while self.ie.Busy==True:
                time.sleep(0.1)
            self.ie.Visible=True
            self.window=self.ie.Document.parentWindow
            self.doc=self.ie.Document
            self.body=self.ie.Document.Body

        self.alert=self.window.alert
        self.metevent=self.window.metevent
        self.pluietest=self.window.pluietest

        self.conteneurglobal=self.connectid('_GLOBAL_CONTENEUR_')


    def getx(self, par): 
        return self.ie.Top
    def setx(self, valeur): 
        self.ie.Top=valeur
    x = property(getx,setx)
    top=property(getx,setx)

    def gety(self, par): 
        return self.ie.Left
    def sety(self, valeur): 
        self.ie.Left=valeur
    y = property(gety,sety)
    left=property(gety,sety)

    def gety(self, par): 
        return self.ie.Left
    def sety(self, valeur): 
        self.ie.Left=valeur
    y = property(gety,sety)
    left=property(gety,sety)

    def getstatuaction(self, par): 
        return self.window.statuaction
    def setstatuaction(self, valeur): 
        self.window.statuaction=valeur
    statuaction = property(getstatuaction,setstatuaction)


    def visible(self, flag=True):
        """rend la fiche visible/invisible
        """
        if flag==True:
            self.ie.Visible=1
        else:
            self.ie.Visible=0


    def close(self):
        try:
            tmp=self.formcaller
            self.window.close()
            self.ie=None
            del(self.ie)
            self.window=None
            del(self.window)
            pass
        except:
            self.ie.Quit()
            self.ie=None
            del(self.ie)
            pass



    def calljscript(self,code):
        """execute un code jscript dans le fiche
        """
        self.ie.Navigate(' javascript:'+code)
        self.waitBusy()


    def getdocument(self):
        """HTML de le fiche
        """
        return self.doc.documentElement.outerHTML


    def connectid(self,id):
        return self.doc.getElementById(id)



    def imprim(self):
        """imprime la page courante sans confirmation
        """
        self.ie.Document.recalc()
        time.sleep(0.5)
        self.ie.Document.execCommand('Print',True)

    def imprime(self):
        """imprime la page courante sans confirmation
        """
        self.ie.Document.recalc()
        time.sleep(0.5)
        self.ie.ExecWB(6,2,0,0)   #pour choisir imprimante: self.ie.ExecWB(6,0,0,0)


    def saveas(self, nomfichier):
        """
        sauve la page courante ; problème, ça sauve la page d'origine, non actualisée.
        voir plutôt  sauvefiche() 
        """
        self.ie.Document.recalc()
        time.sleep(0.5)
        self.ie.Document.execCommand('SaveAs',True,nomfichier)


    def test(self):
        self.ie.ExecWB(7,0)   #preview


    def sauvefiche(self,fichier='temp.htm'):
        st=self.doc.documentElement.outerHTML
        open(fichier,'wb').write(st.encode('cp1252','replace'))


    def poptext(self, texte="Pop-Texte", duree=3000, y=-1, couleur='OMBRE'):
        import os
        #prog=os.getcwd()+'\\PopText.exe'
        prog=pluie_toolsdir+'PopText.exe'
        lparam=[' "'+texte+'"',' '+str(duree),' '+str(y),' '+couleur]
        os.spawnv(os.P_NOWAIT, prog,lparam)



    class element(object):
        def __init__(self, typ=None, containeur=None, repere=None, valeur=None):
            self.form=form.fichecourante
            if containeur is self.form:
                containeur=self.form.conteneurglobal
            if containeur is None:
                if form.conteneurcourant is None:
                    form.conteneurcourant=self.form.conteneurglobal
                containeur=form.conteneurcourant
            if not(form.conteneurcourant is containeur):
                form.conteneurcourant=containeur
            form.ie_id+=1
            self.typ=typ
            self.conteneur=containeur
            if self.typ=='text':
                self.handle=self.form.doc.createTextNode(valeur)
                self.attrib=self.handle
            else:
                self.handle=self.form.doc.createElement(self.typ)
                self.style=self.handle.style
                self.attrib=self.handle
                self.attrib.id=str(form.ie_id)

            self.id=str(form.ie_id)
            self.met(repere)
            self.form.elemid[unicode(form.ie_id)]=self
            

        def met(self, repere=None):
            """
            if repere, insertion avant (before)
            si repere is None, ajout en fin
            """
            if repere is None:
                if self.conteneur is self.form.conteneurglobal:
                    self.conteneur.appendChild(self.handle)
                else:
                    self.conteneur.handle.appendChild(self.handle)
            else:
                if self.conteneur is self.form.conteneurglobal:
                    self.conteneur.insertBefore(self.handle, repere.handle)
                else:
                    self.conteneur.handle.insertBefore(self.handle, repere.handle)


        def setattribut(self,nom,valeur):
            setattr(self.handle,nom,valeur)

        def getattribut(self,nom):
            return getattr(self.handle,nom)

        def setstyle(self,nom,valeur):
            setattr(self.handle.style,nom,valeur)

        def getstyle(self,nom):
            return getattr(self.handle.style,nom)

        def listattrib(self, mode='specified'):
            """
            'all'  tous les attributs
            'specified' uniquement ceux spécifiés (non standards)
            """
            st=''
            for a in self.handle.attributes:
                if mode=='all':
                    st+='\r\n'+u1252(a.name).ljust(22)+str(a.specified).ljust(8)+u1252(a.value)
                else:
                    if a.specified:
                        st+='\r\n'+u1252(a.name).ljust(22)+u1252(a.value)
            return st

        def labeltxt(self, texte=""):
            ttext=self.form.doc.createTextNode(texte)
            self.handle.appendChild(ttext)


        def replacelabel(self, texte=""):
            ttext=self.form.doc.createTextNode(texte)
            self.handle.replaceChild(ttext, self.handle.firstChild)



    #------------------------ fin form.element


    def aj_txt(self, txt='', containeur=None, repere=None):
        """Ajout d'un texte (label) brut 
        """
        tmp=self.element('text',containeur,repere, valeur=txt)
        return tmp


    def aj_text(self, txt='', containeur=None, repere=None):
        """Ajout d'un texte (label) dans un SPAN 
        """
        tmp=self.element('span',containeur,repere)
        tmp.labeltxt(txt)
        #tmp.style.color='#ffffff'
        return tmp


    def aj_br(self, nb=1, containeur=None, repere=None):
        for i in range(nb):
            tmp=self.element('br',containeur,repere)
        return tmp


    def aj_espace(self, nb=1, containeur=None, repere=None):
        st=''
        for i in range(nb):
            st+=' '
        tmp=self.element('text',containeur,repere, valeur=st)
        return tmp


    def aj_bouton(self, txt=u'Bouton', containeur=None, repere=None):
        tmp=self.element('button',containeur,repere)
        tmp.attrib.className='freebouton'
        tmp.attrib.value=txt
        return tmp


    def aj_champ(self, label=None, longmax=8, taille=8, valeur='', containeur=None, repere=None):
        tmp=self.element('input',containeur,repere)
        tmp.attrib.className='champ'
        tmp.attrib.maxlength=str(longmax)
        tmp.attrib.size=str(taille)
        tmp.attrib.value=valeur
        tmp.attrib.type="text"
        if longmax>12:
            tmp.style.textAlign='left'
        else:
            tmp.style.textAlign='right'
        lc=None
        if not(label is None):
            lc=self.element('SPAN',containeur,tmp)
            lc.labeltxt(label)
            lc.attrib.className='labelchamp'
        self.metevent(tmp.id)
        return(tmp,lc)


    def aj_checkbox(self, label=None, valeur=False, containeur=None, repere=None):
        tmp=self.element("<input type=checkbox>",containeur,repere)
        tmp.attrib.checked=valeur
        lc=None
        if not(label is None):
            lc=self.aj_text(label)
            lc.attrib.className='labelcheck'
        self.metevent(tmp.id)
        return(tmp,lc)



    def aj_select(self, valeur=[], multiple=None, nblig=0, containeur=None, repere=None):
        """
        noter le 'multiple' dans select, pour une multiple sélection (sinon, un seul choix)
        Utilisez {Shift} ou {Ctrl} pour une sélection multiple
        noter le 'size' dans select, pour le nombre de lignes affichées (scroll si >) 
        si pas de size, ou 1, liste déroulante
        en lecture, voir selected==True ou False ; puis lire la valeur
        si pas de select.style.width, largeur ajustée sur le texte le pus grand
        (dé)-sélectionner synamiquement une ligne : choix3.attrib.selected=True/False
        modifier dynamiquement un libellé : choix3txt.replacelabel(u'Nouvelle ligne 3') (sélectionner ensuite pour forcer l'affichage)
        """ 

        st='<select'
        if multiple:
            st+=' multiple'
        if nblig>0:
            st+=' size="'+str(nblig)+'"'
        st+='>'
        select=self.element(st,containeur,repere)

        lc=[]
        lct=[]
        for val,txt in valeur:
            tmpv=self.element("<option value="+str(val)+">", select)
            tmpt=self.aj_text(txt,tmpv)
            lc.append(tmpv)
            lct.append(tmpv)
        self.metevent(tmpv.id)
        return(select,lc,lct)



    def aj_htmlbrut(self, htmloufichier="AAAAA", largeur=480, hauteur=320, containeur=None, repere=None):
        cadre = self.element('SPAN',containeur,repere) 
        cadre.style.width = str(largeur)
        cadre.style.height = str(hauteur)
        htm=self.window.idhtml(cadre.id,htmloufichier)
        return(cadre,htm)



    def aj_flash(self, fichier=None, largeur=480, hauteur=320, containeur=None, repere=None):
        cadreflash = self.element('SPAN',containeur,repere) 
        cadreflash.style.width = str(largeur)
        cadreflash.style.height = str(hauteur)
        flash=self.window.idhtml(cadreflash.id,'''<object id='INNER' classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="100%" height="100%"></object>''')
        if fichier:
            flash.Movie=fichier
        flash.BackgroundColor=0*256+0*256+0    #noir
        return(cadreflash,flash)



    def aj_navigateur2(self, url='http://ponx.org', largeur=700, hauteur=400, containeur=None, repere=None):
        cadre = self.element('SPAN',containeur,repere) 
        cadre.style.width = str(largeur)
        cadre.style.height = str(hauteur)
        cadre = self.element('SPAN',containeur,repere) 

        navig=self.window.idhtml(cadre.id,'''<iframe id='INNER' overflow=yes scroll=yes classid="clsid:8856F961-340A-11D0-A96B-00C04FD705A2" align="baseline" border="0" width="100%" height="98%">
<param id='INNERLOCATION' name="Location" value="'''+url+'''">
<param name="AutoSize" value="0">
<param name="AutoSizePercentage" value="100%">
<param name="AutoArrange" value="0">
<param name="ViewMode" value="2">
<param name="NoClientEdge" value="true">
</object>''')
        return(cadre,navig)


    def aj_navigateur(self, url='http://ponx.org', largeur=700, hauteur=400, containeur=None, repere=None):
        cadre = self.element('IFRAME',containeur,repere) 
        cadre.style.width = str(largeur)
        cadre.style.height = str(hauteur)
        cadre.attrib.src=url
        return(cadre)


    def aj_navigateururl(self, cadre, url='http://ponx.org'):
        navig=self.window.idhtml(cadre.id,'''<object id='INNER' classid="clsid:8856F961-340A-11D0-A96B-00C04FD705A2" align="baseline" border="0" width="100%" height="98%">
<param id='INNERLOCATION' name="Location" value="'''+url+'''">
<param name="AutoSize" value="0">
<param name="AutoSizePercentage" value="100%">
<param name="AutoArrange" value="0">
<param name="ViewMode" value="2">
<param name="NoClientEdge" value="true">
</object>''')
        return(navig)



    def aj_arbre(self, valeurs=[], racine="Racine", ouvert=True, x=10, y=40, largeur=120, hauteur=400, containeur=None, repere=None):
        cadre = self.element('SPAN',containeur,repere) 
        cadre.attrib.className='tree'
        cadre.style.position='absolute'
        cadre.style.left=str(x)
        cadre.style.top=str(y)
        cadre.style.width=str(largeur)
        cadre.style.height=str(hauteur)
        cadre.style.textAlign='left'

        la=[]
        lo=[]
        for num,i in enumerate(valeurs):
            la.append("%s|%s|%s|#" % (i[0],i[1],i[2]))
            if ouvert:
                lo.append(num)
        self.window.cretree(cadre.id, la, 0, lo, racine)
        return cadre


    def aj_arbreremplace(self, repere, valeurs=[], racine="Racine", ouvert=True):
        la=[]
        lo=[]
        for num,i in enumerate(valeurs):
            la.append("%s|%s|%s|#" % (i[0],i[1],i[2]))
            if ouvert:
                lo.append(num)
        lo=[]
        self.window.cretree(repere.id, la, 0, lo, racine)
        return repere



    def aj_menu(self,larg=200,*l):
        def metenliste3(l):
            return list(l[0::3]),list(l[1::3]),list(l[2::3])

        txt,raccourci,cod=metenliste3(*l)
        for i in range(len(txt)):
            k=raccourci[i]
            k=k.lower()
            KK=k.upper()
            t=txt[i]
            if k=='':
                raccourci[i]='-'
                pass
            else:
                t=t.replace(k,'<u><b>'+k+'</b></u>')
                t=t.replace(KK,'<u><b>'+KK+'</b></u>')
                txt[i]=t
        #larg1 = '"'+str(larg)+'"'
        #larg2 = '"'+str(larg-5)+'"'
        larg1 = str(larg)
        larg2 = str(larg-5)
        self.window.pluie_menu_prepare_ext(larg1,larg2,txt,raccourci,cod)
        tmp=self.connectid('pluie_menu_box')
        self.elemid['pluie_menu_box']=tmp
        return tmp




    def tableau(self, containeur=None, repere=None, larg=580,haut=280,nblignes=20,tlarg=560,titre='Ttiittrree',descriptif=''):

        cols=[l.split() for l in descriptif.splitlines()]
        if cols[-1]==[]:
            cols.pop()
        for i in cols:
            i[0]=int(i[0])

        cadretable=self.element('span',containeur,repere)
        cadretable.className='cad1'
        cadretable.style.overflow='auto'
        cadretable.style.backgroundColor='#D8DDDD'
        cadretable.style.width=str(larg)
        cadretable.style.height=str(haut)

        #table=fiche.element('table',cadretable)
        table=self.doc.createElement('table')
        table.id='_TABLEAU_'
        table.className='tbl'
        table.style.width=tlarg
        cadretable.handle.appendChild(table) #+++

        #création du titre
        caption=None
        if not(titre is None):
            caption=self.doc.createElement("CAPTION")
            table.appendChild(caption)
            caption.innerHTML=titre

        # création de l'en-tête des colonnes
        thead=self.doc.createElement("THEAD")
        table.appendChild(thead)

        tete = self.doc.createElement("TR")
        thead.appendChild(tete)

        total=0
        for c in cols:
            total+=c[0]

        for c in cols:
            tmp=self.doc.createElement("TH")
            tmp.innerHTML = c[1].replace('_',' ')
            tete.appendChild(tmp)
            pourcentage=int(c[0]*100/total)
            tmp.width=str(pourcentage)+'%'


        lid=[]
        mettreevent=[]
        psize=[]
        palign=[]
        for c in cols:
            psize.append(c[0])
            palign.append(c[2])
        td=time.time()
        tobj,tid=self.window.prepartableau('_TABLEAU_',nblignes,len(cols),psize,palign)
        tf=time.time()
        print "pluie 702",tf-td


        self.elemid['_TABLEAU_REDIR_']=tobj
        self.elemid['_TABLEAU_']=cadretable
        #tmplid=list(tobj)
        #self.elemid.update(zip(tid,tmplid))
        #nbcols=len(cols)        
        #for num in range(0,nblignes*nbcols,nbcols):
        #    lid.append(tmplid[num:num+nbcols])

        #lid=tobj #-------------------------------------------------------------------

        """
        nbcols=len(cols)
        num=-1
        for i in range(0,nblignes):
            llig=[]
            for c in range(0,nbcols):
                num+=1
                llig.append(tobj[num])
                #self.elemid[tid[num]]=tobj[num]
            lid.append(llig)
        print 507
        """


        """
        nbcols=len(cols)
        tmpconnect=self.doc.getElementById
        for i in range(0,nblignes):
            llig=[]
            for c in range(0,nbcols):
                #llig.append(self.connectid(u'CTBL_'+str(i)+'_'+str(c)))
                tempid=u'CTBL_'+str(i)+'_'+str(c)
                tmp=tmpconnect(tempid)
                llig.append(tmp)
                self.elemid[tempid]=tmp
            lid.append(llig)
        """


        #for l in range(len(lid)):
        #    for c in range(len(cols)):
        #        self.elemid[lid[l][c].id]=lid[l][c]

        pied=None
        ltmp=[ c[3] for c in cols]
        if ltmp.count('_')<len(cols):
            pied=self.doc.createElement("TFOOT")
            table.appendChild(pied)
            piedlig=self.doc.createElement("TR")
            pied.appendChild(piedlig)
            pied=[]
            for c in cols:
                tmp=self.doc.createElement("TH")
                if c[3]=='_':
                    tmp.innerHTML = ''
                else:
                    tmp.innerHTML = c[3].replace('_',' ')
                tmp.style.textAlign=c[2]
                piedlig.appendChild(tmp)
                pied.append(tmp)

        #self.conteneurglobal.appendChild(cadretable)
        #self.conteneurglobal.insertBefore(cadretable, repere.handle)
        #+++cadretable.handle.appendChild(table)

        #return(caption,pied,lid,cols)
        cadretable.caption=caption
        cadretable.pied=pied
        cadretable.tlid=tobj
        cadretable.cols=cols
        cadretable.nbcols=len(cols)
        cadretable.nblignes=nblignes
        #return(caption,pied,tobj,cols,nblignes)
        return(cadretable)


    def remplitableauOLD(self, tlid, tvaleurs,filtre):
        for l,lig in enumerate(tvaleurs):
            for c,index in enumerate(filtre):
                val=lig[index]
                tlid[l*len(filtre)+c].value=val


    def remplitableau(self, htableau, tvaleurs,filtre):
        htableau.filtre=filtre
        l1=[]
        for l in tvaleurs:
            for idx in filtre:
                l1.append(l[idx])
        self.window.tblset('_TABLEAU_',l1,0,len(tvaleurs),len(filtre))


    def videligtableau(self, htableau, ligdepart=0, nblig=1, nbcol=1):
        self.window.tblvide('_TABLEAU_',ligdepart,nblig,nbcol)


    def littableau(self, htableau,tvaleurs,filtre):
        for l in range(len(tvaleurs)):
            for c in range(len(filtre)):
                tvaleurs[l][filtre[c]]=htableau.tlid[l*len(filtre)+c].value



    '''
    def itest(self, source=""):
        """
        exemple pour texte avec une partie en gras
        """
        t1=self.form.doc.createTextNode('AAAA')
        self.handle.appendChild(t1)

        temp=self.form.doc.createElement('B')
        self.handle.appendChild(temp)

        tt2=self.form.doc.createTextNode(u'BBé€èBB')
        self.handle.lastChild.appendChild(tt2)


        t3=self.form.doc.createTextNode('CCCC')
        self.handle.appendChild(t3)
    '''





class pluievent(object):

    def __init__(self,fiche):
        self.form=fiche
        self.actionnum=self.form.window.actionnum
        self.num=-1
        self.complement=""

    def getnextaction(self):
        try:
            tnum=self.form.window.actionnum
        except:
            self.type='break'
            return False

        #if True:
        try:
            self.type=''
            if tnum>self.num:
                self.num+=1
                tmp=unicode(self.form.window.filaction[self.num])
                fia=tmp.split(',')
                self.type=fia[0]
                #print 783,fia[0],fia[1]
                if self.type not in ('clic','key','blur','focus','changevalue'):
                    self.type=''
                    return False
                
                if fia[1].startswith(u'CTBL_'):
                    #self.cible=fia[1]
                    self.cible=self.form.elemid['_TABLEAU_']
                    tmpid=fia[1].split('_')
                    self.complement=int(tmpid[1]),int(tmpid[2])
                elif fia[1].startswith(u'_pluie_menu_box_'):
                    ttmp=fia[1].split('_')
                    self.cible=self.form.elemid['pluie_menu_box']
                    self.complement=ttmp[-1]
                elif fia[1].startswith(u'_tree_'):
                    if fia[1].startswith(u'_tree_join'):
                        return False
                    else:
                        ttmp=fia[1].split('_')
                        self.cible=self.form.elemid[ttmp[2]]
                        self.complement=int(ttmp[3])
                else:
                    try:
                        self.cible=self.form.elemid[fia[1]]
                    except:
                        return False
                self.mousebutton=fia[2]
                self.kbuffer=fia[3]
                self.kbskey=fia[4]
                self.nbtotalfilaction=self.form.window.filaction.length
                self.nbresteaction=self.nbtotalfilaction-self.num-1

                return True
            else:
                return False
        except:
            #else:
            self.type='break'
            return False








"""

Exemple de descriptif : 

    
Les cellules (colonnes) sont composées : 
  - soit de label(s), non modifiables
  - soit de champs, saisissables



descriptif=u''' \
6   Code                 label left   _
40  Libellé_de_l'article label left   Total_:
10  Montant              champ right  _      
10  Date                 champ center _
'''


On a : 
    largeur (en nb de caractères ; pour les champs, )
    nom du titre de colonne  (_ sera remplacé par {espace} )
    type   (label ou champ)
    alignement l r ou c   left right center
    libellé du pied

Les titres de colonnes sont centrés
Les pieds sont alignés comme les colonnes
Les pieds  _  sont ignorés
Si tous les pieds sont  _  alors, pas de pied.


L'appel à  tableau() retourne ces objets : 
    ttitre  pointe le titre
    tpied   liste pointant vers les pieds
    tlid    liste de listes pointant vers les cellules
    cols    liste de listes pointant vers la liste descriptive des colonnes ('descripteur analysé')



Le remplissage accepte les paramètres suivants : 
    remplitableau(tlid, val, filtre)
    tlig    liste de listes des cellules, retournée par tableau()
    val     liste de listes contenant les valeurs
    filtre  liste des index (de val) à utiliser pour le remplissage des colonnes

    
"""