def SqlMouvementsPeriode(debut=None,fin=None):
# retourne une liste de mouvements en forme de liste
lstChamps = ['date','origine','stMouvements.IDarticle','qte','prixUnit','IDmouvement']
if fin == None: fin = datetime.date.today()
if debut == None: debut = fin - datetime.timedelta(days=180)
finIso = xformat.DatetimeToStr(fin,iso=True)
debutIso = xformat.DatetimeToStr(debut,iso=True)
db = xdb.DB()
# Appelle les mouvements de la période
req = """ SELECT %s
FROM stMouvements
WHERE ( (date > '%s' )
AND (date <= '%s' ))
;""" % (",".join(lstChamps),debutIso,finIso)
retour = db.ExecuterReq(req, mess='UTILS_Stocks.SqlMouvementsPeriode')
llMouvements = []
if retour == "ok":
recordset = db.ResultatReq()
for record in recordset:
mouvement = []
for ix in range(len(lstChamps)):
mouvement.append(record[ix])
llMouvements.append(mouvement)
db.Close()
return llMouvements
def MajDepot(dlg, db, IDdepot):
modes = ""
mindte, maxdte = datetime.date(2999, 12, 31), datetime.date(2000, 1, 1)
nb = len(dlg.ctrlOlv.modelObjects)
for track in dlg.ctrlOlv.modelObjects:
if track.mode and len(track.mode) > 0:
if not track.mode[:3] in modes: modes += track.mode[:3] + ', '
mindte = min(mindte, track.date)
maxdte = max(maxdte, track.date)
if mindte == maxdte:
dates = "le %s" % (xformat.DatetimeToStr(mindte, iso=False))
else:
dates = "du %s au %s" % (xformat.DatetimeToStr(
mindte, iso=False), xformat.DatetimeToStr(maxdte, iso=False))
label = "Noelite: %d %s datés %s" % (nb, modes, dates)
lstDonnees = [
("date", xformat.DateFrToSql(dlg.pnlParams.ctrlDate.GetValue())),
("nom", label),
("IDcompte", dlg.GetIDbanque()),
]
# Mise à jour du libellé dépôt
db.ReqMAJ('depots', lstDonnees, 'IDdepot', IDdepot, affichError=True)
return
def SetDepot(dlg, db):
# cas d'un nouveau depot à créer, retourne l'IDdepot
IDdepot = None
today = xformat.DatetimeToStr(datetime.date.today(), iso=False)
if not 'userdomain' in dlg.dictUtilisateur.keys():
dlg.dictUtilisateur['userdomain'] = '_'
dlg.dictUtilisateur['config'] = '_'
label = "saisie '%s' sur '%s' via '%s' le %s" % (
dlg.dictUtilisateur['utilisateur'], dlg.dictUtilisateur['userdomain'],
dlg.dictUtilisateur['config'], today)
lstDonnees = [("date",
xformat.DateFrToSql(dlg.pnlParams.ctrlDate.GetValue())),
("nom", "Saisie règlements via Noelite"),
("verrouillage", 0), ("IDcompte", dlg.GetIDbanque()),
("observations", label)]
if not hasattr(dlg, "IDdepot"):
ret = db.ReqInsert(
"depots",
lstDonnees=lstDonnees,
mess="UTILS_Reglements.SetDepot",
)
if ret == 'ok':
IDdepot = db.newID
# affichage de l'IDdepot créé
dlg.pnlParams.ctrlRef.SetValue(str(IDdepot))
return IDdepot
def SqlLastInventaire(cloture=None):
# retourne l'inventaire précédent la date de cloture
if cloture == None:
cloture = datetime.date.today()
db = xdb.DB()
# Appelle l'inventaire précédent
lstChamps = ['IDdate','IDarticle','qteStock','prixMoyen',]
finIso = xformat.DatetimeToStr(cloture,iso=True)
req = """ SELECT %s
FROM stInventaires
WHERE (stInventaires.IDdate =
(SELECT MAX(stInv.IDdate)
FROM stInventaires as stInv
WHERE stInv.IDdate < '%s')
)
;""" % (",".join(lstChamps),finIso)
retour = db.ExecuterReq(req, mess='UTILS_Stocks.SqlLastInventaire')
llInventaire = []
if retour == "ok":
recordset = db.ResultatReq()
for record in recordset:
mouvement = []
for ix in range(len(lstChamps)):
mouvement.append(record[ix])
llInventaire.append(mouvement)
db.Close()
return llInventaire
def PostInventaire(cloture=datetime.date.today(),inventaire=[[],]):
# delete puis recrée l'inventaire à la date de cloture
if cloture == None:
cloture = datetime.date.today()
ordi = os.environ['USERDOMAIN']
dteSaisie = xformat.DatetimeToStr(datetime.date.today(),iso=True)
# Appelle l'inventaire précédent
lstChamps = ['IDdate',
'IDarticle',
'qteStock',
'prixMoyen',
'prixActuel',
'ordi',
'dateSaisie',]
llDonnees = []
# lignes reçues [date,article,qte,prixMoyen,montant,lastPrix]
for dte,article,qte,pxMoy,mtt,pxLast in inventaire:
if dte != str(cloture): raise Exception(
"cloture = %s diff de inventaire = %s"%(str(cloture),str(dte)))
llDonnees.append([dte,article,qte,pxMoy,pxLast,ordi,dteSaisie])
# test présence inventaire
db = xdb.DB()
finIso = xformat.DatetimeToStr(cloture,iso=True)
condition = "stInventaires.IDdate = '%s'"%finIso
req = """ SELECT *
FROM stInventaires
WHERE %s
;""" %(condition)
retour = db.ExecuterReq(req, mess='UTILS_Stocks.testPrésenceInventaire')
if retour == "ok":
recordset = db.ResultatReq()
if len(recordset) > 0:
mess = "UTILS_Stoks.PostInventaire.ReqDel"
ret = db.ReqDEL('stInventaires',condition=condition,mess=mess)
ret = db.ReqInsert('stInventaires',lstChamps=lstChamps,lstlstDonnees=llDonnees,
mess="UTILS_Stocks.PostInventaires")
db.Close()
if ret == 'ok':
return True
return ret
def RechercheFormat(valeur):
""" Recherche le type de la donnée """
if type(valeur) == decimal.Decimal:
valeur = float(valeur)
return (valeur, styleEuros)
if type(valeur) == float:
return (valeur, None)
if type(valeur) == int:
return (valeur, None)
if type(valeur) == datetime.date:
valeur = xformat.DatetimeToStr(valeur)
return (valeur, styleDate)
if type(valeur) == datetime.timedelta:
return (valeur, styleHeure)
try:
if len(valeur) > 3:
if ":" in valeur:
separateur = ":"
elif "h" in valeur:
separateur = "h"
else:
separateur = None
if separateur != None:
donnees = valeur.split(separateur)
if len(donnees) == 2:
heures, minutes = donnees
if len(donnees) == 3:
heures, minutes, secondes = donnees
valeur = datetime.timedelta(minutes=int(heures) * 60 +
int(minutes))
# valeur = datetime.time(hour=int(valeur.split(separateur)[0]), minute=int(valeur.split(separateur)[1]))
return (valeur, styleHeure)
except:
pass
if type(valeur) in (str, six.text_type):
if len(valeur) == 10:
if valeur[2] == "/" and valeur[5] == "/":
return (valeur, styleDate)
if valeur[4] == "-" and valeur[7] == "-":
return (xformat.DateSqlToIso(valeur), styleDate)
return str(valeur), None
def SetComposants(self,IDimmo,lstNews,lstCancels,lstModifs,lstChamps):
champs = lstChamps + ['dtMaj','user']
donUser = [xformat.DatetimeToStr(datetime.date.today(), iso=True),
self.GetUser()]
# écriture des composants d'une immo particulière dans la base de donnée
for donnees in lstNews:
donnees += donUser
donnees[1] = IDimmo
self.db.ReqInsert('immosComposants',champs[1:],[donnees[1:],],mess="U_Noegest.SetComposants_ins")
for donnees in lstCancels:
self.db.ReqDEL('immosComposants','IDcomposant',donnees[0],mess="U_Noegest.SetComposants_del")
for donnees in lstModifs:
donnees += donUser
self.db.ReqMAJ('immosComposants',nomChampID='IDcomposant',ID=donnees[0],lstChamps=champs[1:],
lstValues=donnees[1:], mess="U_Noegest.SetComposants_maj")
return
def CalculInventaire(self, fin=None):
# retourne un inventaire: liste de liste
if fin == None: fin = self.cloture
debut = None
if self.lastInventaire:
# présence d'un inventaire antérieur
debut = xformat.DateSqlToDatetime(self.lastInventaire[0][0])
#['jour', 'origine', 'nomArticle', 'qteMouvement','prixUnit']
llMouvements = GetMouvements(debut=debut, fin=fin)
self._xAjoutInventaire(llMouvements)
# liste préalable pour traitement par article
lstArticles = []
for jour, origine, article, qte, pu, id in llMouvements:
if not article:
raise Exception("Article disparu! mvt du %s qte= %d" %
(jour, qte))
if not article in lstArticles:
lstArticles.append(article)
lstArticles.sort()
if lstArticles == None:
raise Exception("Aucun mouvement dans la période du %s au %s"\
%(debut,fin))
# composition de l'inventaire
llinventaire = []
for article in lstArticles:
lstMvts = [x[0:2] + x[3:] for x in llMouvements if x[2] == article]
qte, mtt, lastPrix = self._CalculInventaireUnArticle(lstMvts)
if qte == 0:
pu = 0.0
else:
pu = round(mtt / qte, 4)
if qte != 0 and mtt != 0:
# compose [dte,article,qte,prixMoyen,montant,lastPrix]
llinventaire.append([
xformat.DatetimeToStr(fin, iso=True),
article,
round(qte, 4),
pu,
round(mtt, 4),
lastPrix,
])
return llinventaire
def SetConsoKm(self,track):
# --- Sauvegarde de la ligne consommation ---
dteFacturation = self.GetParam('filtres','datefact')
if track.observation == None: track.observation = ""
if track.typetiers != 'A' and track.nomtiers and len(track.nomtiers.strip())>0:
if not (track.nomtiers.strip() in track.observation):
track.nomtiers = track.nomtiers.replace('/','-')
track.observation = "%s / %s"%(track.nomtiers.strip(),track.observation.strip())
if track.idactivite == None: track.idactivite = ''
lstDonnees = [
("IDconso", track.IDconso),
("IDanalytique", track.idvehicule),
("cloture", xformat.DateFrToSql(self.cloture)),
("typeTiers", track.typetiers[:1]),
("IDtiers", track.idactivite),
("dteKmDeb", xformat.DateFrToSql(track.datekmdeb)),
("kmDeb", track.kmdeb),
("dteKmFin", xformat.DateFrToSql(track.datekmfin)),
("kmFin", track.kmfin),
("observation", track.observation),
("dtFact", xformat.DateFrToSql(dteFacturation)),
("dtMaj", xformat.DatetimeToStr(datetime.date.today(),iso=True)),
("user", self.GetUser()),
]
if not track.IDconso or track.IDconso == 0:
ret = self.db.ReqInsert("vehiculesConsos",lstDonnees= lstDonnees[1:], mess="UTILS_Noegest.SetConsoKm")
track.IDconso = self.db.newID
IDcategorie = 6
categorie = ("Saisie")
else:
ret = self.db.ReqMAJ("vehiculesConsos", lstDonnees, "IDconso", track.IDconso)
IDcategorie = 7
categorie = "Modification"
"""
# --- Mémorise l'action dans l'historique ---
if ret == 'ok':
nuh.InsertActions([{
"IDcategorie": IDcategorie,
"action": "Noelite %s de la conso ID%d : %s %s %s" % (
categorie, track.IDconso, track.nomvehicule,track.nomtiers,track.observation,),
}, ],db=self.db)
"""
return ret
def SetReglement(dlg, track, db):
# --- Sauvegarde du règlement ---
IDemetteur = None
IDpayeur = None
if not hasattr(track, 'IDprestation'): track.IDprestation = None
# transposition du payeur en son ID
if not hasattr(dlg.pnlOlv, 'ldPayeurs'):
dlg.pnlOlv.ldPayeurs = GetPayeurs(db, track.IDfamille)
for dicPayeur in dlg.pnlOlv.ldPayeurs:
if track.payeur in dicPayeur['nom']:
IDpayeur = dicPayeur['IDpayeur']
break
if not IDpayeur:
IDpayeur = SetPayeur(db, track.IDfamille, track.payeur)
dlg.pnlOlv.ldPayeurs = GetPayeurs(db, track.IDfamille)
IDmode = dlg.dicModesChoices[track.mode]['IDmode']
# transposition de l'émetteur en son ID
lstEmetteurs = dlg.dlEmetteurs[IDmode]
if len(lstEmetteurs
) >= 0 and track.emetteur and track.emetteur in lstEmetteurs:
IDemetteur = dlg.dlIDemetteurs[IDmode][lstEmetteurs.index(
track.emetteur)]
else:
track.emetteur = None
ixem = dlg.ctrlOlv.lstCodesColonnes.index('emetteur')
track.donnees[ixem]
if not track.libelle: track.libelle = ""
if not track.numero: track.numero = ""
lstDonnees = [
("IDreglement", track.IDreglement),
("IDcompte_payeur", track.IDfamille),
("date", xformat.DatetimeToStr(track.date, iso=True)),
("IDmode", IDmode),
("IDemetteur", IDemetteur),
("numero_piece", track.numero),
("montant", track.montant),
("IDpayeur", IDpayeur),
("observations", track.libelle),
("IDcompte", dlg.GetIDbanque()),
("date_saisie", xformat.DatetimeToStr(datetime.date.today(),
iso=True)),
("IDutilisateur", dlg.IDutilisateur),
("IDpiece", track.IDprestation),
]
if dlg.withDepot:
lstDonnees.append(("IDdepot", dlg.IDdepot))
if hasattr(track, 'differe'):
lstDonnees.append(
("date_differe", xformat.DatetimeToStr(track.differe, iso=True)))
if track.IDreglement in dlg.pnlOlv.lstNewReglements:
nouveauReglement = True
ret = db.ReqInsert("reglements",
lstDonnees=lstDonnees,
mess="UTILS_Reglements.SetReglement")
dlg.pnlOlv.lstNewReglements.remove(track.IDreglement)
else:
nouveauReglement = False
ret = db.ReqMAJ("reglements", lstDonnees, "IDreglement",
track.IDreglement)
# --- Mémorise l'action dans l'historique ---
if ret == 'ok':
if nouveauReglement == True:
IDcategorie = 6
categorie = ("Saisie")
else:
IDcategorie = 7
categorie = "Modification"
texteMode = track.mode
if track.numero != "":
texteNumpiece = u" n°%s" % track.numero
else:
texteNumpiece = u""
if texteNumpiece == "":
texteDetail = u""
else:
texteDetail = u"- %s - " % (texteNumpiece)
montant = u"%.2f %s" % (track.montant, SYMBOLE)
textePayeur = track.payeur
if not isinstance(track.IDreglement, int):
raise Exception('anomalie: IDreglement = %s' % track.IDreglement)
nuh.InsertActions([
{
"IDfamille":
track.IDfamille,
"IDcategorie":
IDcategorie,
"action":
"Noelite %s du règlement ID%d : %s en %s %spayé par %s" %
(categorie, track.IDreglement, montant, texteMode, texteDetail,
textePayeur),
},
],
db=db)
return True
def SetPrestation(track, db):
# --- Sauvegarde de la prestation ---
if not track.nature.lower() in ('don', 'donsscerfa', 'debour'):
raise Exception("UTILS_Reglements.SetPrestation ni don ni debour!!")
lstDonnees = [
("date", xformat.DatetimeToStr(datetime.date.today(), iso=True)),
("categorie", track.nature),
("label", track.libelle),
("montant_initial", track.montant),
("montant", track.montant),
("IDcompte_payeur", track.IDfamille),
("code_compta", track.compte),
("IDfamille", track.IDfamille),
("IDindividu", 0),
]
if (not hasattr(track, "IDprestation")) or (not track.IDprestation):
ret = db.ReqInsert(
"prestations",
lstDonnees=lstDonnees,
mess="UTILS_Reglements.SetPrestation",
)
IDcategorie = 6
categorie = ("Saisie")
if ret == 'ok':
track.IDprestation = db.newID
else:
ret = db.ReqMAJ("prestations", lstDonnees, "IDprestation",
track.IDprestation)
IDcategorie = 7
categorie = "Modification"
IDprestation = track.IDprestation
# supprime les ventilations du règlement
ret = db.ReqDEL("ventilation", "IDreglement", track.IDreglement)
# création d'une ventilation
lstDonnees = [('IDprestation', IDprestation),
('IDreglement', track.IDreglement),
('montant', track.montant),
('IDcompte_payeur', track.IDfamille)]
ret = db.ReqInsert(
"ventilation",
lstDonnees=lstDonnees,
mess="UTILS_Reglements.SetPrestation.ventilation",
)
# mise à jour du règlement sur son numéro de pièce (ID de la prestation
lstDonnees = [("IDpiece", IDprestation)]
ret = db.ReqMAJ("reglements", lstDonnees, "IDreglement", track.IDreglement)
# --- Mémorise l'action dans l'historique ---
if ret == 'ok':
texteMode = track.mode
montant = u"%.2f %s" % (track.montant, SYMBOLE)
if not IDprestation: IDprest = 0
else: IDprest = IDprestation
nuh.InsertActions([
{
"IDfamille":
track.IDfamille,
"IDcategorie":
IDcategorie,
"action":
"Noelite %s de prestation associée regl ID%d : %s en %s " %
(categorie, IDprest, montant, track.libelle),
},
],
db=db)
return IDprestation
'txtSize': 90
},
{
'name':
'date',
'genre':
'Texte',
'label':
"",
'help':
"%s\n%s\n%s" %
("Saisie JJMMAA ou JJMMAAAA possible.",
"Les séparateurs ne sont pas obligatoires en saisie.",
"Saisissez la date de l'entrée en stock sans séparateurs, "),
'value':
xformat.DatetimeToStr(datetime.date.today()),
'ctrlAction':
'OnDate',
'ctrlMaxSize': (220, 35),
'txtSize':
90
},
],
("param2", "Comptes"): [{
'name': 'fournisseur',
'genre': 'Combo',
'label': 'Fournisseur',
'help':
"La saisie d'un fournisseurfacilite les commandes par fournisseur, on peut mettre 'NONAME'",
'value': 0,
'values': [''],
def InitParametres(self):
""" Récupération des paramètres d'impression """
# DLG des paramètres d'impression
dictOptions = {
"titre": self.titre,
"introduction": self.intro,
"conclusion": self.total,
"orientation": self.orientation,
}
dlg = OptionsImpression.Dialog(None, dictOptions=dictOptions)
if dlg.ShowModal() == wx.OK:
dictOptions = dlg.GetOptions()
dlg.Destroy()
else:
dlg.Destroy()
return False
# Remplacement des mots-clés
lstChamps = [
"pied_page_texte_gauche", "pied_page_texte_milieu",
"pied_page_texte_droite"
]
for key, valeur in dictOptions.items():
if key in lstChamps:
valeur = valeur.replace(
"{DATE_JOUR}",
xformat.DatetimeToStr(datetime.date.today()))
valeur = valeur.replace("{TITRE_DOCUMENT}", self.titre)
valeur = valeur.replace("{NUM_PAGE}", "%(currentPage)d")
valeur = valeur.replace("{NBRE_PAGES}", "%(totalPages)d")
dictOptions[key] = valeur
# Préparation du printout
self.printer = ListCtrlPrinter.LCprinter(self.listview,
dictOptions["titre"])
self.printer.printout.margins = (wx.Point(dictOptions["marge_gauche"],
dictOptions["marge_haut"]),
wx.Point(dictOptions["marge_droite"],
dictOptions["marge_bas"]))
self.printer.printout.printData.SetOrientation(
dictOptions["orientation"])
self.printer.printout.printData.SetQuality(
dictOptions["qualite_impression"])
self.printer.PageFooter = (dictOptions["pied_page_texte_gauche"],
dictOptions["pied_page_texte_milieu"],
dictOptions["pied_page_texte_droite"])
ListCtrlPrinter.LISTINTRO = dictOptions["introduction"]
ListCtrlPrinter.LISTFOOTER = dictOptions["conclusion"]
# Préparation du format
fmt = ReportFormat()
# Entête de page
## fmt.PageHeader.Font = wx.FFont(10, wx.FONTFAMILY_DECORATIVE, wx.FONTFLAG_BOLD, face=headerFontName)
## fmt.PageHeader.TextColor = wx.WHITE
## fmt.PageHeader.Background(wx.GREEN, wx.RED, space=(16, 4, 0, 4))
## fmt.PageHeader.Padding = (0, 0, 0, 12)
# Titre de liste
fmt.ListHeader.Font = wx.Font(dictOptions["titre_taille_texte"],
wx.SWISS,
wx.NORMAL,
dictOptions["titre_style"],
faceName="Arial")
fmt.ListHeader.TextColor = dictOptions["titre_couleur"]
fmt.ListHeader.Padding = (0, 12, 0, 10)
fmt.ListHeader.TextAlignment = dictOptions["titre_alignement"]
fmt.ListHeader.Frame(wx.Pen(wx.BLACK, 0.25, wx.SOLID), space=10)
# Intro
fmt.ListIntro.Font = wx.Font(dictOptions["intro_taille_texte"],
wx.SWISS,
wx.NORMAL,
dictOptions["intro_style"],
faceName="Arial")
fmt.ListIntro.TextColor = dictOptions["intro_couleur"]
fmt.ListIntro.Padding = (12, 2, 12, 2)
fmt.ListIntro.TextAlignment = dictOptions["intro_alignement"]
fmt.ListIntro.CanWrap = True
# Titre de colonne
fmt.ColumnHeader.Font = wx.Font(
dictOptions["titre_colonne_taille_texte"],
wx.SWISS,
wx.NORMAL,
dictOptions["titre_colonne_style"],
faceName="Arial")
fmt.ColumnHeader.TextColor = dictOptions["titre_colonne_couleur"]
fmt.ColumnHeader.Padding = (0, 15, 0, 0)
fmt.ColumnHeader.Background(dictOptions["titre_colonne_couleur_fond"])
fmt.ColumnHeader.CellPadding = 5
fmt.ColumnHeader.TextAlignment = dictOptions[
"titre_colonne_alignement"]
fmt.ColumnHeader.GridPen = wx.Pen(
dictOptions["grille_trait_couleur"],
dictOptions["grille_trait_epaisseur"], wx.SOLID)
fmt.ColumnHeader.SetAlwaysCenter(True)
# Titre d'un groupe
fmt.GroupTitle.Font = wx.FFont(10,
wx.FONTFAMILY_SWISS,
wx.FONTFLAG_BOLD,
faceName="Arial")
fmt.GroupTitle.Padding = (2, 10, 2, 2)
fmt.GroupTitle.CellPadding = 12
fmt.GroupTitle.GridPen = wx.Pen(dictOptions["grille_trait_couleur"],
dictOptions["grille_trait_epaisseur"],
wx.SOLID)
# Ligne
fmt.Row.Font = wx.Font(dictOptions["ligne_taille_texte"],
wx.SWISS,
wx.NORMAL,
dictOptions["ligne_style"],
faceName="Arial")
fmt.Row.TextColor = dictOptions["ligne_couleur"]
fmt.Row.CellPadding = 5
fmt.Row.GridPen = wx.Pen(dictOptions["grille_trait_couleur"],
dictOptions["grille_trait_epaisseur"],
wx.SOLID)
fmt.Row.CanWrap = dictOptions["ligne_multilignes"]
# Pied de page
fmt.PageFooter.Font = wx.Font(dictOptions["pied_page_taille_texte"],
wx.SWISS,
wx.NORMAL,
dictOptions["pied_page_style"],
faceName="Arial")
fmt.PageFooter.TextColor = dictOptions["pied_page_couleur"]
fmt.PageFooter.Line(wx.TOP, wx.BLACK, 1, space=3)
fmt.PageFooter.Padding = (0, 16, 0, 0)
# Pied de colonne
fmt.ColumnFooter.Font = wx.Font(
dictOptions["pied_colonne_taille_texte"],
wx.SWISS,
wx.NORMAL,
dictOptions["pied_colonne_style"],
faceName="Arial")
fmt.ColumnFooter.TextColor = dictOptions["pied_colonne_couleur"]
fmt.ColumnFooter.Padding = (0, 0, 0, 0)
fmt.ColumnFooter.Background(dictOptions["pied_colonne_couleur_fond"])
fmt.ColumnFooter.CellPadding = 5
fmt.ColumnFooter.TextAlignment = dictOptions["pied_colonne_alignement"]
fmt.ColumnFooter.GridPen = wx.Pen(
dictOptions["grille_trait_couleur"],
dictOptions["grille_trait_epaisseur"], wx.SOLID)
# Conclusion
fmt.ListFooter.Font = wx.Font(dictOptions["conclusion_taille_texte"],
wx.SWISS,
wx.NORMAL,
dictOptions["conclusion_style"],
faceName="Arial")
fmt.ListFooter.TextColor = dictOptions["conclusion_couleur"]
fmt.ListFooter.Padding = (12, 12, 0, 0)
fmt.ListFooter.CellPadding = 5
## fmt.ListFooter.Line(wx.TOP, wx.BLACK, 1, space=3)
fmt.ListFooter.TextAlignment = dictOptions["conclusion_alignement"]
fmt.ListFooter.CanWrap = True
# Divers paramètres
fmt.IsShrinkToFit = True
fmt.IncludeImages = dictOptions["inclure_images"]
fmt.IsColumnHeadingsOnEachPage = dictOptions["entetes_toutes_pages"]
fmt.UseListCtrlTextFormat = True
self.printer.ReportFormat = fmt
return True