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


#
# by Michel Claveau Informatique
# http://mclaveau.com
#



import time
from win32com.client import Dispatch


GlobalPVersion='1.8.1'


class exl(object):
    wdAlignLeft=0
    wdAlignCenter=1
    wdAlignRight=2

    def __init__(self, fichier=None, visible=True, exist="NON"):
        import time
        import win32com,win32com.client
        self.ox=None
        if exist.upper()=="OUI":
            try:
                if fichier is None:
                    self.ox=win32com.client.GetObject(Class='Excel.Application')
                else:
                    self.ox=win32com.client.GetObject(fichier)
            except:
                self.ox=win32com.client.Dispatch('Excel.Application')
                time.sleep(1)
        else:
            self.ox=win32com.client.Dispatch('Excel.Application')
            time.sleep(1)
        self.ox.Application.DisplayAlerts = False
        if exist.upper()!="OUI":
            if fichier is None:
                self.visible(visible)
            else:
                self.open(fichier, visible)


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


    def runexcel(self, fichier=None, visible=True):
        """
        Lance excel
        Si fichier est renseigné, l'ouvre
        """
        if self.ox is None:
            import win32com,win32com.client
            self.ox=win32com.client.Dispatch('Excel.Application')
            self.ox.Application.DisplayAlerts = False
        if not fichier is None:
            time.sleep(2)
            self.open(fichier, visible)


    def open(self, fichier, visible=True):
        """
        Ouvre un document excel
        """
        if self.ox is None:
            import win32com,win32com.client
            self.ox=win32com.client.Dispatch('Excel.Application')
            self.ox.Application.DisplayAlerts = False
        self.doc=self.ox.Workbooks.Open(fichier)
        self.visible(visible)


    def pxopen(self, fichier, visible=True):
        """
        synonyme d' open
        """
        self.open(fichier, visible)


    def close(self):
        """
        ferme le document, en sauvegardant, sans demander
        """
        self.ox.ActiveDocument.Close(SaveChanges = self.wdDoNotSaveChanges)


    def newdoc(self):
        """
        Nouveau document Excel (nouvelle feuille/classeur)
        """
        if self.ox is None:
            import win32com.client
            self.ox=win32com.client.Dispatch('Excel.Application')
            self.ox.Application.DisplayAlerts = False
            time.sleep(2)
        self.doc=self.ox.Workbooks.Add()


    def newsheet(self):
        """
        Nouveau document Excel (nouvelle feuille/classeur)
        """
        if self.ox is None:
            import win32com.client
            self.ox=win32com.client.Dispatch('Excel.Application')
            self.ox.Application.DisplayAlerts = False
            time.sleep(2)
        self.doc=self.ox.Workbooks
        self.doc.Add()
        sheet=self.ox.Worksheets
        sheet.Add()


    def sheetselect(self,num=1):
        sheet = self.ox.Worksheets
        sheet[num].Select()
        sheet[num].Name = "XXXXX"


    def pxclose(self):
        """
        synonyme de close
        """
        self.quit()


    def saveas(self,fichier,typ=56):
        """
        Enregistre le document courant sous un (autre) nom de fichier ;
        au besoin, préciser l'extension.
        
        Type peut être :
            51  .xlsx  (openXML - Office 2007)
            56  .xls  (Excel97 à 2003)
        Exemples :
            saveas('C:\\toto3.xlsx')
            saveas('C:\\essai2.xls',56)
        """
        #self.ox.ActiveWorkbook.SaveAs(fichier,typ)
        self.ox.ActiveWorkbook.SaveAs(fichier)


    def save(self):
        """
        enregistre le document courant
        """
        self.ox.ActiveWorkbook.Save()


    def exportpdf(self,fichier="C:\\test.pdf"):
        #enregistre le document au format PDF
        xlTypePDF=0
        xlQualityStandard = 0
        xlQualityMinimum = 1
        xlTypePDF = 0
        xlTypeXPS = 1

        self.ox.ActiveWorkbook.ExportAsFixedFormat(xlTypePDF,fichier,xlQualityStandard)

        #Excel:
        #ExportAsFixedFormat(Type:=xlTypePDF, Filename:="L:\essai.pdf", Quality:=xlQualityStandard, IncludeDocProperties:=True, IgnorePrintAreas :=False, OpenAfterPublish:=False )


    def exportxps(self,fichier="C:\\test.pdf"):
        #enregistre le document au format PDF
        xlTypePDF=0
        xlQualityStandard = 0
        xlQualityMinimum = 1
        xlTypePDF = 0
        xlTypeXPS = 1

        self.ox.ActiveWorkbook.ExportAsFixedFormat(xlTypeXPS,fichier,xlQualityStandard)

        #Excel:
        #ExportAsFixedFormat(Type:=xlTypePDF, Filename:="L:\essai.pdf", Quality:=xlQualityStandard, IncludeDocProperties:=True, IgnorePrintAreas :=False, OpenAfterPublish:=False )


    def quit(self):
        """
        Ferme excel
        """
        #self.doc.Close(SaveChanges=0)
        self.doc.Close()
        self.ox.Quit()


    def quitSaveChange(self):
        """
        Ferme excel, en sauvant les changements
        """
        self.doc.Close(SaveChanges=1)
        self.ox.Quit()


    def quitCancel(self):
        """
        Ferme excel, SANS sauver les changements
        """
        self.doc.Close(SaveChanges=0)
        self.ox.Quit()


    def visible(self, par=True):
        """
        Rend excel visible (True), ou invisible (False) ; True par défaut
        Note : c'est plus rapide en invisible
        """
        if not self.ox is None:
            if par:
                self.ox.Visible=True
            else:
                self.ox.Visible=False


    def hide(self):
        """
        Cache excel
        """
        self.ox.visible=False


    def xprint(self):
        """
        Imprime le document
        """
        self.doc.PrintOut()


    def preview(self):
        """
        Pré-visualise le document
        """
        self.ox.Worksheets.PrintPreview(False)


    def previewclose(self):
        """
        Ferme la prévisualisation du document (envoie {Alt}{F4})
        """
        import win32api,win32con
        win32api.keybd_event(win32con.VK_MENU, 0, 0, 0)
        win32api.keybd_event(win32con.VK_F4, 0, win32con.KEYEVENTF_EXTENDEDKEY | 0, 0) 
        time.sleep(0.05)
        win32api.keybd_event(win32con.VK_F4, 0, win32con.KEYEVENTF_EXTENDEDKEY | win32con.KEYEVENTF_KEYUP, 0)
        time.sleep(0.05)
        win32api.keybd_event(win32con.VK_MENU, 0, win32con.KEYEVENTF_KEYUP, 0)



    def cellAlpha(self, nom):
        """
        Retourne LIG,COL d'une cellule nommée en alpha (e.g. D4)
        """
        scol=''
        slig=''
        for l in str(nom):
            if l>='A' and l<='Z':
                scol+=l
            else:
                slig+=l
        lig=int(slig)
        col=0
        for l in scol:
            col=col*26+ord(l)-64
        return (lig,col)


    def setFormula(self, lig, col, valeur, sheet=None):
        """
        Met une formule dans une cellule
        Exemple :  x.setFormula(4,4,"=A1*2",'Feuil2')
        Exemple :  x.setFormula(4,4,"=222*Feuil3!B12",'Feuil4')
        """
        if sheet:
            self.ox.ActiveWorkbook.Worksheets(sheet).Cells(lig, col).Formula=valeur
        else:
            self.ox.ActiveSheet.Cells(lig, col).Formula=valeur



    def setAFormula(self, alphacellule, valeur, sheet=None):
        """
        Met une formule dans une cellule
        Exemple :  x.setFormula('E5',"=A1*3",'Feuil2')
        Exemple :  x.setAFormula("E5","=Feuil3!G12*3.14",'Feuil1')
        """
        if sheet:
            self.ox.ActiveWorkbook.Worksheets(sheet).Range(str(alphacellule)).Formula=valeur
        else:
            self.ox.ActiveSheet.Range(str(alphacellule)).Formula=valeur



    def setCellule(self, lig, col, valeur, sheet=None):
        """Met la valeur dans la cellule
        """
        if sheet:
            self.ox.ActiveWorkbook.Worksheets(sheet).Cells(lig, col).Value=valeur
        else:
            self.ox.ActiveSheet.Cells(lig, col).Value=valeur



    def setACellule(self, alphacellule, valeur, sheet=None):
        """Met la valeur dans la cellule nommée en alpha (e.g. 'D4')
        """
        if sheet:
            self.ox.ActiveWorkbook.Worksheets(sheet).Range(str(alphacellule)).Value=valeur
        else:
            self.ox.ActiveSheet.Range(str(alphacellule)).Value=valeur
        """
        vieille méthode :
        lig,col=self.cellAlpha(alphacellule)
        self.setCellule(lig,col,valeur)
        """


    def getCellule(self, lig, col, sheet=None):
        """
        Obtient la valeur d'une cellule
        """
        if sheet:
            return self.ox.ActiveWorkbook.Worksheets(sheet).Cells(lig, col).Value
        else:
            return self.ox.ActiveSheet.Cells(lig, col).Value


    def getACellule(self, nomcellule, sheet=None):
        """
        Obtient la valeur dans la cellule nommée en alpha (e.g. D4)
        """
        if sheet:
            return self.ox.ActiveWorkbook.Worksheets(sheet).Range(str(nomcellule)).Value
        else:
            return self.ox.ActiveSheet.Range(str(nomcellule)).Value
        """
        vieille méthode
        lig,col=self.cellAlpha(nomcellule)
        return self.getCellule(lig,col)
        """


    def getRCellule(self, ligdepart=1, *cols):
        """
        (generator) Obtient une tranche (plusieurs colonnes) pour 1ère cellule non vide
        
        Exemple :
            x.SheetActivate("Feuil1")
            g=x.getRCellule(3,6,10,11)
            for i in g:
                print i
        """
        lig=ligdepart-1
        vcritere=999
        lresult=[]
        while (not (vcritere is None)) and lig<12:
            lresult=[]
            lig+=1
            for col in cols:
                lresult.append(self.ox.ActiveSheet.Cells(lig, col).Value)
            vcritere=lresult[0]
            if vcritere:
                yield (lresult)


    def selRange(self, srlig, col=0, haut=0, larg=0, sheet=None):
        """
        Sélectionne une plage de cellules
        Exemples :
            x.selRange(3,3,2,4)
            x.selRange("B2:C3;D4:F8;G9:H12")
            x.selRange("B2:C3",sheet='Feuil3')
            x.selRange(3,3,2,4,sheet='XXX')

        c'est cumulatif si avec des onglets différents ; mais l'affectation
        (ou l'effacement) ne joue que sur l'onglet actif.
        """
        import types
        if sheet:
            self.SheetActivate(sheet)
        if isinstance(srlig,types.StringTypes):
            self.ox.Range(str(srlig)).Select()
        else:
            self.ox.Range(self.ox.Cells(srlig, col), self.ox.Cells(srlig+haut-1, col+larg-1)).Select()


    def fillRange(self, valeur=None):
        """
        Remplit la sélection de l'onglet actif avec une valeur
        None (ou appel sans paramètre) efface
        """
        self.ox.Selection.Value=valeur


    def cutRange(self):
        """
        coupe la sélection de l'onglet actif (==> presse-papier)
        Attention : pas sur des sélections multiples
        """
        self.ox.Selection.Cut()


    def copyRange(self):
        """
        copie la sélection de l'onglet actif dans le presse-papier
        Attention : pas sur des sélections multiples
        """
        self.ox.Selection.Copy()


    def pasteRange(self):
        """
        Coller le contenu du presse-papier, à partir de la cellule en haut à gauche
        """
        self.ox.Selection.PasteSpecial()


    def SheetActivate(self, sheet):
        """
        Active l'onglet (sheet) donné
        """
        self.ox.ActiveWorkbook.Worksheets(sheet).Activate()


    def GetNbSheets(self):
        """
        obtient le nom de l'onglet (sheet) actif
        """
        return self.ox.ActiveWorkbook.Worksheets.Count


    def GetSheetName(self):
        """
        obtient le nom de l'onglet (sheet) actif
        """
        return self.ox.ActiveWorkbook.ActiveSheet.Name


    def SetSheetName(self, nom=None, sheet=None):
        """
        Renomme l'onglet donné (ou actif si vide)
        """
        if nom:
            if sheet:
                self.ox.ActiveWorkbook.Worksheets(sheet).Name=nom
            else:
                self.ox.ActiveWorkbook.ActiveSheet.Name=nom


    def AddSheet(self, nom=None, aftersheet=None):        #"après"
        """
        Ajoute un onglet après l'onglet donné (ou l'actif si vide)
        """
        if not nom:
            nom="F_"+str(self.GetNbSheets()+1)
        if aftersheet:
            self.ox.ActiveWorkbook.Worksheets.Add(None,self.ox.ActiveWorkbook.Worksheets(aftersheet))
            self.ox.ActiveWorkbook.ActiveSheet.Name=nom
        else:
            self.ox.ActiveWorkbook.Worksheets.Add()
            self.ox.ActiveWorkbook.ActiveSheet.Name=nom


    def AddSheetBefore(self, nom=None, beforesheet=None):
        """
        Insère un nouvel onglet avant l'onglet donné (ou l'actif si vide)
        """
        if not nom:
            nom="F_"+str(self.GetNbSheets()+1)
        if not beforesheet:
            beforesheet=self.ox.ActiveWorkbook.ActiveSheet.Name
        self.ox.ActiveWorkbook.Worksheets.Add(self.ox.ActiveWorkbook.Worksheets(beforesheet))
        self.ox.ActiveWorkbook.ActiveSheet.Name=nom


    #**** à voir
    def setActiveCellule(self, valeur):
        """
        Affecte la cellule active
        """
        self.ox.ActiveCell.Value=valeur


    #**** à voir
    def getActiveCellule(self):
        """
        Obtient la valeur de la cellule active
        """
        return self.ox.ActiveCell.Value

    def selActiveCelluleA(self, srlig, col=0):
        """
        Obtient la valeur de la cellule active nommée en alpha (e.g. D4)
        """
        import types
        if isinstance(srlig,types.StringTypes):
            self.ox.Range(str(srlig)).Select()
        else:
            self.ox.Range(self.ox.Cells(srlig,col),self.ox.Cells(srlig,col)).Select()


    def setLRange(self, lst, srlig, col=0):
        """
        Affecte le contenu d'une liste dans une cellule/tranche
        """
        import types
        if type(lst[0]) is types.ListType:
            if isinstance(srlig,types.StringTypes):
                self.ox.Range(str(srlig)).Value = lst
            else:
                self.ox.Range(self.ox.Cells(int(srlig),col),self.ox.Cells(int(srlig)+len(lst)-1,col+len(lst[0])-1)).Value = lst
        else:
            if isinstance(srlig,types.StringTypes):
                self.ox.Range(str(srlig)).Value = [[item] for item in lst]
            else:
                self.ox.Range(self.ox.Cells(int(srlig),col),self.ox.Cells(int(srlig)+len(lst)-1,col)).Value = [[item] for item in lst]


    def setGlobalLRange(self, srlig, col=0):
        """
        Affectation de GlobalPARAMliste
        """
        import types,pglobal
        lst=pglobal.GlobalPARAMliste
        if (type(lst[0]) is types.ListType) or (type(lst[0]) is types.TupleType):
            if isinstance(srlig,types.StringTypes):
                self.ox.Range(str(srlig)).Value = lst
            else:
                self.ox.Range(self.ox.Cells(srlig,col),self.ox.Cells(srlig+len(lst)-1,col+len(lst[0])-1)).Value = lst
        else:
            if isinstance(srlig,types.StringTypes):
                self.ox.Range(str(srlig)).Value = [[item] for item in lst]
            else:
                self.ox.Range(self.ox.Cells(srlig,col),self.ox.Cells(srlig+len(lst)-1,col)).Value = [[item] for item in lst]
        return True


    def getLRange(self, srlig, col=0, haut=0, larg=0):
        import types
        if isinstance(srlig,types.StringTypes):
            return self.ox.Range(str(srlig)).Value
        else:
            return self.ox.Range(self.ox.Cells(srlig,col),self.ox.Cells(srlig+haut-1,col+larg-1)).Value


    def getSelection(self):
        """
        Obtient le contenu de la sélection (de l'onglet actif ?)
        """
        return self.ox.Selection.Value


    def graph(self, srlig, col=0, haut=0, larg=0):
        self.selRange(srlig, col, haut, larg)
        self.ox.Charts.Add()
    
        # Cree un camenbert
        glignes = 65
        gcamembert = 69
        self.ox.ActiveChart.ChartType = gcamembert
    
        # Cree un titre
        self.ox.ActiveChart.HasTitle = 1


    def macroRun(self, name):
        """Lance la macro-exl (VBA) 'name'
        """
        self.ox.Run(name)


    def changePrinter(self, printerName):
        """Change l'imprimante active de exl
        """
        self.ox.ActivePrinter = printerName


    def printerstatus(self):
        return self.ox.BackgroundPrintingStatus 



    def setRangeColor(self, fcolor):
        oFond=self.ox.Selection.Interior
        oFond.Color=fcolor

    def setRangeFontColor(self, fcolor):
        class color(object):
            Black=0

            Red=255
            DarkRed=127

            Green=255*256
            DarkGreen=127*256

            Yellow=255*256+255
            Orange=127*256+255

            Blue=255*256*256
            DarkBlue=127*256*256
            Cyan=255*256*256+255*256

            Gray=127*256*256+127*256+127
            LightGray=220*256*256+220*256+220
            DarkGray=63*256*256+63*256+63

            Magenta=255*256*256+255

            White=255*256*256+255*256+255

        oFont=self.ox.Selection.Font
        oFont.Color=fcolor


    def setRangeFontBold(self):
        self.ox.Selection.Font.Bold=1

    def setRangeFontItalic(self):
        self.ox.Selection.Font.Italic=1

    def setRangeFontStrike(self, par=1):
        self.ox.Selection.Font.Strikethrough=par

    def setRangeFontSize(self, siz=11):
        self.ox.Selection.Font.Size=siz

    def setRangeFontName(self, nom="Arial"):
        oFont=self.ox.Selection.Font.Name=nom

    def setRangeFontUnderline(self, typ=2):
        """typ = -4142 (supprime)  ou  2 (souligne)
        """
        oFont=self.ox.Selection.Font.Underline = typ

    def setRangeOrientation(self, angle=0):
        """angle en degrés
        """
        self.ox.Selection.Orientation = angle



    def setPrintArea(self, srlig, col=0, haut=0, larg=0):
        """définit d'après la sélection active
        """
        import types
        if isinstance(srlig,types.StringTypes):
            self.ox.ActiveSheet.PageSetup.PrintArea = str(srlig)
        else:
            self.ox.ActiveSheet.PageSetup.PrintArea = (self.ox.Cells(srlig,col),self.ox.Cells(srlig+haut-1,col+larg-1))

    def setPageOrientation(self, typ=1):
        """ 1 = portrait   
            2 = paysage
        """
        self.ox.ActiveSheet.PageSetup.Orientation=typ

    def setPrintCentre(self, par=True):
        self.ox.ActiveSheet.PageSetup.CenterHorizontally = par
        self.ox.ActiveSheet.PageSetup.CenterVertically = par

    def setPageEnteteDroit(self, txt='Droit'):
        self.ox.ActiveSheet.PageSetup.RightHeader=txt

    def setPageEnteteGauche(self, txt='Gauche'):
        self.ox.ActiveSheet.PageSetup.LeftHeader=txt

    def setPageEnteteCentre(self, txt='Titre centré'):
        self.ox.ActiveSheet.PageSetup.CenterHeader=txt

    """
    &A  nom_onglet (doc)
    &H  heure 
    &J  date 
    &N  nom_classeur
    &P  numéro page
    &T  nb pages
    &Z  chemin
    
    """
    def setPagePiedDroit(self, txt='A &10 '):
        self.ox.ActiveSheet.PageSetup.RightFooter=txt

    def setPagePiedGauche(self, txt="B &11 "):
        self.ox.ActiveSheet.PageSetup.LeftFooter=txt

    def setPagePiedCentre(self, txt='C &12 '):
        self.ox.ActiveSheet.PageSetup.CenterFooter=txt

    def setDocName(self, txt='XXX'):
        self.ox.ActiveSheet.Name=txt



    def format(self,xformat="[Noir]0.00_ ;[Rouge]-0.00_;"):
        #print"Format préexistant :",self.ox.Selection.NumberFormat
        self.ox.Selection.NumberFormat = xformat

    def aligne(self,align=0):
        """ 0 droite
        1 gauche
        2 gauche
        3 centré
        """
        self.ox.Selection.HorizontalAlignment = align


    def insertline(self, lig):
        """
        insère une ligne dans l'onglet actif
        Exemple :
            x.insertlig(3)
        """
        if lig:
            sel=self.ox.Rows(str(lig)+":"+str(lig)).Select()
            self.ox.Selection.Insert()


    def deleteline(self, lig):
        """
        supprime une ligne dans l'onglet actif
        Exemple :
            x.deletelig(3)
        """
        if lig:
            sel=self.ox.Rows(str(lig)+":"+str(lig)).Select()
            self.ox.Selection.Delete()


    def insertcol(self,col=None):
        """
        insère une colonne dans l'onglet actif
        Exemple :
            x.insertcol("G")
        """
        if col:
            sel=self.ox.Columns(str(col)+":"+str(col)).Select()
            self.ox.Selection.Insert()

    def deletecol(self,col=None):
        """
        supprime une colonne dans l'onglet actif
        Exemple :
            x.deletecol("G")
        """
        if col:
            sel=self.ox.Columns(str(col)+":"+str(col)).Select()
            self.ox.Selection.Delete()


    def linehight(self, lined=1,linef=1, hauteur=14):
        """Détermine la hauteur de
        """
        st=str(lined)+':'+str(linef)
        sel=self.ox.Rows(st).Select()
        self.ox.Selection.RowHeight = hauteur


    def colwidth(self, cold=1,colf=1, largeur=15):
        """Détermine la largeur d'une sélection de colonnes
        """
        st=str(cold)+':'+str(colf)
        sel=self.ox.Columns(st).Select()
        self.ox.Selection.ColumnWidth = largeur



    def borderwidth(self, width=2):
        """0 ou 2 ou 4 
        """
        sel=self.ox.Selection.Borders.Weight=width
        
    def bordercolor(self, color=255):
        sel=self.ox.Selection.Borders.Color=color
        
    def borderstyle(self, styl=-4119):
        """-4119 double
        1 continu
        """
        sel=self.ox.Selection.Borders.LineStyle=styl

    def test(self):
        adr=self.ox.ActiveCell.Address
        a=adr.split('$')
        lig=int(a[2])
        col=0
        for c in a[1]:
            col=col*26+(ord(c)-64)
        print "Adresse",adr.replace('$',''),"   lig",lig,"   col",col
        print self.ox.ActiveCell.Font.ColorIndex
        print self.ox.ActiveCell.Font.Bold
        print self.ox.ActiveCell.Font.Size
        print self.ox.ActiveCell.Font.Name
        print self.ox.ActiveCell.Interior.ColorIndex
        print self.ox.ActiveCell.Value
        print self.ox.ActiveCell.HorizontalAlignment
        print self.ox.ActiveCell.VerticalAlignment
        print self.ox.ActiveCell.WrapText
        print self.ox.ActiveCell.Orientation
        print self.ox.ActiveCell.AddIndent
        print self.ox.ActiveCell.IndentLevel
        print self.ox.ActiveCell.ShrinkToFit
        print self.ox.ActiveCell.Borders.Color
        print self.ox.ActiveCell.Borders.Weight
        print self.ox.ActiveCell.ColumnWidth
        print self.ox.ActiveCell.RowHeight
        print 


if __name__=='__main__':

    x=exl("L:\\essai.xlsx")
    x.visible()
    time.sleep(4)
    x.test()
    #x.exportpdf("L:\\essai.pdf")
    #x.exportxps("L:\\essai.xps")
    #time.sleep(2)
    #x.quit()


    ''''
    pass
    delai=0.25

    x=exl(exist='OUI')
    x.newdoc()
    x.newsheet()
    x.newsheet()
    x.newsheet()
    x.sheetselect(2)
    x.visible()
    x.setCellule(2,1,"Attendez ! ")
    time.sleep(delai)

    #import sys
    #sys.exit()



    x.setCellule(2,1,u"écriture dans cellule D2 -->")
    x.aligne(1)
    x.setACellule('D2',12345.67)
    time.sleep(delai)

    x.setCellule(4,1,u"écriture dans cellule D4 -->")
    x.setACellule('D4','abcde')
    time.sleep(delai)

    x.linehight(4,5,48)

    x.setCellule(4,1,u"sélection de la cellule D4")
    x.selActiveCelluleA("D4")
    time.sleep(delai)

    """
    print 790

    x.preview()
    print 794
    time.sleep(1)
    x.previewclose()

    '''
    import sys
    sys.exit()
    '''
    """

    x.setRangeFontSize(24)
    time.sleep(delai)
    x.bordercolor(255*256+180*256)
    time.sleep(delai)
    x.borderwidth(4)
    time.sleep(delai)
    x.borderstyle(1)
    time.sleep(delai)
    x.aligne(2)
    time.sleep(delai)
    x.setRangeColor(255*256+255)
    time.sleep(delai)
    x.setRangeFontColor(255)
    time.sleep(delai)
    x.setRangeFontBold()
    time.sleep(delai)
    x.setRangeOrientation(30)
    x.selActiveCelluleA("B3")
    time.sleep(delai*2)


    x.setCellule(8,1,u"écriture liste (D8:E11)")
    time.sleep(delai)
    l=[[11,1111],[22,2222],[33,3333],[44,4444]]
    x.setLRange(l,"D8:E11")
    x.selRange("D8:E11")
    time.sleep(delai)
    x.setRangeFontColor(127*256*256)
    time.sleep(delai)
    x.bordercolor(127*256*256+200*256+200)
    time.sleep(delai)
    x.borderwidth(4)
    time.sleep(delai)
    x.borderstyle(1)


    print
    print x.getSelection()
    print x.getLRange("D8:E10")
    print 

    time.sleep(delai)
    x.selActiveCelluleA("A14")
    x.setRangeFontName('Arial Narrow')
    x.setRangeFontColor(255)
    x.setRangeFontSize(20)
    x.setRangeFontBold()
    x.selActiveCelluleA("B3")
    x.setACellule('A14',u'    Attendez ! Dans 6 secondes Excel sera fermé automatiquement      ')

    x.saveas("C:\\toto.xls")

    time.sleep(6)
    x.quit()
    '''