#!/usr/bin/env python2.7
# -*- coding: utf-8 -*-


#attention la base fonctionne avec le bouton (sans mot de passe) pour un QCombobox, mais n'est par prévu pour fonctionner avec un QListWidget (sans mot de passe) dans ce cas, il faut coder en plus.
#ne pas supprimer de champs dans la base, sinon, les impressions des références vont déconner...
#BUG à régler
# mysql db en SSL + paramètre PORT qui ne sert à rien pour l'instant.
# bug visual: à priori c'est bon
# rajout d'un bouton: "tout voir ?"
# impression logos !!!

#test à vérifier:
#bug possible sur UPDATE fiche affaire avec accent double ou simple et salsh...et % ou " ??? chercher par update...
#BUG mettre un sablier pendant l'attente d'une recherche
#QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
#QtGui.QApplication.restoreOverrideCursor()




"""
#a taper en console:
C:\> assoc .py
.py = Python.File

C:\> ftype Python.File
Python.File = "C:\Program\Python27\python.exe" "%1" %*
"""

#### A VIRER
import sys
print "infos systeme"
print "version de python:"
print sys.version_info 
print "sys.stdin.encoding"
print sys.stdin.encoding
print ""
print "sys.stdout.encoding"
print sys.stdout.encoding
print "taille entier maxi"
print sys.maxint


#### A VIRER


from PyQt4 import QtCore, QtGui
from PyQt4 import QtXml
from PyQt4 import QtHelp

#from PyQt4 import*
try:
	_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
	_fromUtf8 = lambda s: s


from math import * 
from datetime import date, datetime
import csv
import ftplib	# On importe le module FTP de Python
import zipfile	#module dezip
import os.path #module dezip
import shutil #fonction dupliquer, move...
import os	#module dezip
import glob	#module dezip
import re
import sys
import copy

#SQLITE Initialisationh répertoire et import
import sqlite3
import MySQLdb


### j'importe ici mes fichiers Qtdesigner convertis en pyuic4
#sys.path.append("C:/pyth/ventilo") #definit le chemin de recherche quand python ne le trouve pas dans ses modules
from fenetre_principale6 import *       		# Ton fichier converti avec pyuic4
from fenetre_connexion1 import *       		# Ton fichier converti avec pyuic4
from fenetre_version1 import *       		# Ton fichier converti avec pyuic4
from impression_references1 import *       		# Ton fichier converti avec pyuic4

#from os import chdir
#chdir("C:/pyth/ventilo/") #définit le répertoire courant dans lequel python va écrire ses fichiers par défaut

###VARIABLES GLOBALES###

try:
	mon_setting = QtCore.QSettings("Echologos", "Basaffaire")
	GLOBAL_config_actuelle_finale = mon_setting.value('config_par_defaut/nom_config').toString()
except:
	GLOBAL_config_actuelle_finale = "_"
	
	
##DEBUGGAGE##DEBUGGAGE##DEBUGGAGE##DEBUGGAGE##DEBUGGAGE##DEBUGGAGE##DEBUGGAGE##DEBUGGAGE##DEBUGGAGE
global mode_debuggage
mode_debuggage = "non" #mettre cette valeur à "oui" ou "non" pour debbuger
##DEBUGGAGE##DEBUGGAGE##DEBUGGAGE##DEBUGGAGE##DEBUGGAGE##DEBUGGAGE##DEBUGGAGE##DEBUGGAGE##DEBUGGAGE

if mode_debuggage == 'oui': print "GLOBAL_config_actuelle_finale tout tout debut"
if mode_debuggage == 'oui': print unicode(GLOBAL_config_actuelle_finale).encode("cp850")
#GLOBAL_config_actuelle_finale = "_" #soit MD, JPO, VB; etc.... à mettre dans la base des registres et son équivalent windows
#GLOBAL_config_actuelle_finale = unicode("dada28", "iso-8859-1") #soit MD, JPO, VB; etc.... à mettre dans la base des registres et son équivalent windows
GLOBAL_mon_tuple_de_tuple_ORIGINAL = []  #GLOBAL_mon_tuple_de_tuple_ORIGINAL tuple de tuple des colonnes 
GLOBAL_mon_tuple_de_tuple_des_configs = [] #GLOBAL_mon_tuple_de_tuple_des_configs: contient toutes les configs des utilisateurs
GLOBAL_list_table_et_commentaires_tables = [] #tableau à deux dimensions contenant le nom de chqeu atble et son commentaire associé
#où GLOBAL_list_table_et_commentaires_tables[0][1] est le mot de passe des petites bases modificables par l'utilisateur
GLOBAL_chemin_icone = "visuel_images/" #bug possible sur ubuntu linux à cause du slash antislash
GLOBAL_QLW_hauteur_origine = 0
GLOBAL_nom_programme = "Chapty v"
GLOBAL_version_programme = "93"
GLOBAL_date_version = "  27 juin 2014"
GLOBAL_modif_unique_ou_multiple = "unique" #ne rien changer






mes_fonctions = 1
if mes_fonctions ==1: # ne sert à rien pour l'instant
	from htmlentitydefs import name2codepoint as n2cp

	def substitute_entity(match):
		ent = match.group(3)
		
		if match.group(1) == "#":
			if match.group(2) == '':
				return unichr(int(ent))
			elif match.group(2) == 'x':
				return unichr(int('0x'+ent, 16))
		else:
			cp = n2cp.get(ent)

			if cp:
				return unichr(cp)
			else:
				return match.group()

	def decode_htmlentities(string):
		entity_re = re.compile(r'&(#?)(x?)(\d{1,5}|\w{1,8});')
		return entity_re.subn(substitute_entity, string)[0]

class QHeaderView_special(QtGui.QHeaderView):
	#http://stackoverflow.com/questions/7697194/how-can-i-set-labels-of-qheaderview-in-pyqt
	#http://www.qtcentre.org/archive/index.php/t-31250.html
	def __init__(self, orientation , parent = None): 
		QtGui.QHeaderView.__init__(self, orientation , parent) #le 1 est un Qt.Orientation vertcail ou horizontal
		self.setMovable(True)
		self.setClickable(True)
	def contextMenuEvent(self, event): #CLIC DROIT UNIQUEMENT
		if mode_debuggage == 'oui': print "tu avances"
		self.emit(QtCore.SIGNAL("clic_droit_header_horiz"))
		
		#QtCore.QObject.connect(self,QtCore.SIGNAL("sectionClicked(int)"),app,QtCore.SLOT("quit()"))
		#QtCore.QObject.connect(ui_bdg.tableWidget1.horizontalHeader(),QtCore.SIGNAL("sectionClicked(int)"),self.menu_header_principal
		"""
		menu = QtGui.QMenu(self)
		quitAction = menu.addAction("Quit")
		afficher_toutes_colonnes = menu.addAction("Afficher toutes colonnes")
		action = menu.exec_(self.mapToGlobal(event.pos()))
		if action == afficher_toutes_colonnes:
			if mode_debuggage == 'oui': print "afficher toutes colonnes"
		"""

class MyDoubleValidator(QtGui.QDoubleValidator):
	def __init__(self, bottom, top, decimals, parent = None):
		QtGui.QDoubleValidator.__init__(self, bottom, top, decimals, parent)

	def validate(self, input, pos):
		state, pos = QtGui.QDoubleValidator.validate(self, input, pos)
		if input.isEmpty() or input == '.':
			return QtGui.QValidator.Intermediate, pos
		if state != QtGui.QValidator.Acceptable:
			return QtGui.QValidator.Invalid, pos
		return QtGui.QValidator.Acceptable, pos
	"""
	You then need to initialize an instance of this class and assign it to the widget, e.g. a lineEdit. E.g
	min = 0
	max = 1000
	no_decimals = 10
	aValidator = MyDoubleValidator(min, max, no_decimals, myLineEdit)
	myLineEdit.setValidator(aValidator)
	"""
		
class QLabel_boost(QtGui.QLabel):  
  
    def __init__(self, parent = None):  
        QtGui.QLabel.__init__(self, parent)  
  
    def mouseReleaseEvent(self, ev):  
        self.emit(QtCore.SIGNAL('clicked()')) 
	
		
class QTextEdit_boost(QtGui.QTextEdit):  
    def __init__(self, parent = None):  
        QtGui.QTextEdit.__init__(self, parent)  
  
    def mouseDoubleClickEvent(self, ev): 
		widgetActuel = QtGui.QApplication.focusWidget()
		ma_pos = widgetActuel.pos()
		#http://web.univ-pau.fr/~puiseux/enseignement/python/tutoQt-zero/tuto-PyQt-zero.4.html#Des%20param%C3%A8tres%20dans%20les%20signaux%20et%20slots%20|region
		self.emit(QtCore.SIGNAL('mon_cellDoubleclicked(QPoint*)'), ma_pos)
	

class QDateEdit_boost_SCROLL(QtGui.QDateEdit):  
	def __init__(self, parent = None):
		QtGui.QDateEdit.__init__(self, parent)
	
	
	def wheelEvent(self, event):  #pas de réinjection du signal, donc signal du combobox bloqué. A la place on réinjecte le wheelevent su scroll area
		if mode_debuggage == 'oui': print "roulette date"
		mon_form.qscrollArea_detail.wheelEvent(event)

	
class QComboBox_boost_SCROLL(QtGui.QComboBox): 
	def __init__(self, parent = None):
		QtGui.QComboBox.__init__(self, parent)
	
	
	def wheelEvent(self, event):  #pas de réinjection du signal, donc signal du combobox bloqué. A la place on réinjecte le wheelevent su scroll area
		if mode_debuggage == 'oui': print "roulette"
		mon_form.qscrollArea_detail.wheelEvent(event)


class QListWidget_boost_SCROLL(QtGui.QListWidget): 
	def __init__(self, parent = None):
		QtGui.QListWidget.__init__(self, parent)
	
	
	def wheelEvent(self, event): 
		if mode_debuggage == 'oui': print "roulette QLW"
		
		#if mon_form.qpush_valider_nouveau.isVisible() == True:
		#	QtGui.QListWidget.wheelEvent(self, event) #TIP TOP Au TOP: réinjection du signal event du propre objet mais pas besoin dans notres cas...
		mon_form.qscrollArea_detail.wheelEvent(event) 	#on crée le signal roulette sur l'autre widget SCROLL
	
	"""
	def contextMenuEvent(self, event): #CLIC DROIT UNIQUEMENT
	#def contextMenuRequested(self, event): #CLIC DROIT UNIQUEMENT
	#http://stackoverflow.com/questions/4815925/python-pyqt4-contextmenu-on-pushbutton     #pas suffisant car le clicdroit est capté en amont
	#http://lists.trolltech.com/qt-interest/2005-07/thread00544-0.html ##peut être ??
	
		if mode_debuggage == 'oui': print "clic droit QLW"
		widgetActuel = QtGui.QApplication.focusWidget()
		if mode_debuggage == 'oui': print "widgetActuel.size()"
		if mode_debuggage == 'oui': print widgetActuel.size()
		
		taille = 0
		
		for num in range(widgetActuel.count()):
			taille += widgetActuel.sizeHintForRow(num)

		taille += widgetActuel.sizeHintForRow(0) #rajoute encore une ligne
		
		if widgetActuel.size().height() < taille:
			#widgetActuel.setMinimumSize(QtCore.QSize(widgetActuel.size().width(), 160))
			widgetActuel.setMinimumSize(QtCore.QSize(widgetActuel.size().width(), taille))
		else:
			widgetActuel.setMinimumSize(QtCore.QSize(widgetActuel.size().width(),89))
	"""
	
	def mousePressEvent(self, event):
		global GLOBAL_QLW_hauteur_origine
		if mode_debuggage == 'oui': print ""
		if mode_debuggage == 'oui': print "mousePressEvent"
		if event.button() == QtCore.Qt.RightButton:
			if mode_debuggage == 'oui': print "clic droit"
			widgetActuel = QtGui.QApplication.focusWidget()
			if mode_debuggage == 'oui': print "widgetActuel.size()"
			if mode_debuggage == 'oui': print widgetActuel.size()
			if GLOBAL_QLW_hauteur_origine == 0:
				GLOBAL_QLW_hauteur_origine = widgetActuel.size().height()
			
			taille = 0
			
			for num in range(widgetActuel.count()):
				taille += widgetActuel.sizeHintForRow(num)

			taille += widgetActuel.sizeHintForRow(0) #rajoute encore une ligne
			
			if widgetActuel.size().height() < taille:
				#widgetActuel.setMinimumSize(QtCore.QSize(widgetActuel.size().width(), 160))
				widgetActuel.setMinimumSize(QtCore.QSize(widgetActuel.size().width(), taille))
			else:
				widgetActuel.setMinimumSize(QtCore.QSize(widgetActuel.size().width(),GLOBAL_QLW_hauteur_origine))
	
			
		elif event.button() == QtCore.Qt.LeftButton:
			if mode_debuggage == 'oui': print "clic gauche"
			QtGui.QListWidget.mousePressEvent(self, event)
		
		
class QMessageBox_derive():
	def box_erreur(self,texte_titre,texte_avertissement):
		QtGui.QApplication.restoreOverrideCursor()
		QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
		ma_boite = QtGui.QMessageBox(MainWindow)
		ma_boite.setIcon(QtGui.QMessageBox.Information)
		ma_boite.setInformativeText(texte_avertissement)
		ma_boite.setWindowTitle(texte_titre)
		ma_boite.addButton(_fromUtf8("Fermer"), 0)
		reponse = ma_boite.exec_()
			
class QDialog_surclasse(QtGui.QDialog):
	def __init__(self, parent = None): 
		QtGui.QDialog.__init__(self, parent) #le 1 est un Qt.Orientation vertcail ou horizontal
	
	def closeEvent(self, event):
		if mode_debuggage == 'oui': print "coucou je ferme"
		self.emit(QtCore.SIGNAL("fermeture_fenetre_bases"))
		
				
class Fenetre_SQL_ajout_modif_suppression():
	def fermeture_petite_fenetre(self):
		if mode_debuggage == 'oui': print "la suite ici doudou"
		#lors de la fermeture de la fenetre
		#il faut récupérer le type_champ, nom_de_table, num_row_grid pour relancer ensuite le remplissage situé dans la fonction:
		#SCROLL_remplissage_champs
		mon_widget = mon_form.mon_grid_area.itemAtPosition(self.num_row_grid,1).widget()
		mon_libelle = mon_form.mon_grid_area.itemAtPosition(self.num_row_grid,0).widget().text()
		if mode_debuggage == 'oui': print ""
		if mode_debuggage == 'oui': print "libelle: %s" % (mon_libelle)
		if mode_debuggage == 'oui': print "type widget: %s" % (mon_widget)
		if mode_debuggage == 'oui': print "nom base: %s" % (self.nom_de_table)
		if mode_debuggage == 'oui': print "num_ligne grid: %s" %(self.num_row_grid)
	
		
		if type(mon_widget) == type(QComboBox_boost_SCROLL()) or type(mon_widget) == type(QListWidget_boost_SCROLL()):
			mon_widget.clear()
			#for chaque_item1 in self.mon_list_de_list_tables_annexes:
			#	mon_widget.addItem(chaque_item1)
			
			#ma_liste = SCROLL_remplissage_des_QListWidget(self,nom_de_table,num_de_colonne_de_table)
			ma_liste = mon_form.SCROLL_remplissage_des_QListWidget(self.nom_de_table,0)
			
			for mon_text in ma_liste:
				#monItem = QtGui.QListWidgetItem(mon_text)
				mon_widget.addItem(mon_text)
		



		
	def creation_fenetre(self,type_champ, nom_de_table, num_row_grid): #num row grid est la ligne correspondante du gridlayout
		if mode_debuggage == 'oui': print "\ndef creation_fenetre"
		if mode_debuggage == 'oui': print type_champ
		if mode_debuggage == 'oui': print nom_de_table
		self.nom_de_table = nom_de_table #malin: on transforme le nom en self.nom pour l'utiliser ailleurs dans les autres def
		self.num_row_grid = num_row_grid
	

		self.ma_Bdg_dialog = QDialog_surclasse(MainWindow)
		QtCore.QObject.connect(self.ma_Bdg_dialog,QtCore.SIGNAL("fermeture_fenetre_bases"),self.fermeture_petite_fenetre)
		
		self.ma_Bdg_dialog.setWindowModality(QtCore.Qt.ApplicationModal) #fenetre modale: non_modal: setWindowModality(QtCore.Qt.NonModal)
		self.ma_Bdg_dialog.setWindowTitle(self.nom_de_table) #nome de la fenetre

		#exec("MainWindow.setWindowIcon(QtGui.QIcon(_fromUtf8('%s%s')))" % (chemin_icone, "/listen.png"))
		self.ma_Bdg_dialog.setObjectName(_fromUtf8("self.ma_Bdg_dialog"))
		self.ma_Bdg_dialog.resize(600, 500)


		self.horizontalLayout = QtGui.QHBoxLayout(self.ma_Bdg_dialog)
		self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
		self.verticalLayout = QtGui.QVBoxLayout()
		self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
		self.horizontalLayout_2 = QtGui.QHBoxLayout()
		self.horizontalLayout_2.setObjectName(_fromUtf8("horizontalLayout_2"))
		self.listWidget = QtGui.QListWidget(self.ma_Bdg_dialog)
		self.listWidget.setObjectName(_fromUtf8("listWidget"))
		self.horizontalLayout_2.addWidget(self.listWidget)
		self.scrollArea = QtGui.QScrollArea(self.ma_Bdg_dialog)
		self.scrollArea.setWidgetResizable(True)
		self.scrollArea.setObjectName(_fromUtf8("scrollArea"))
		self.scrollAreaWidgetContents = QtGui.QWidget()
		self.scrollAreaWidgetContents.setGeometry(QtCore.QRect(0, 0, 400, 500))
		self.scrollAreaWidgetContents.setObjectName(_fromUtf8("scrollAreaWidgetContents"))
		self.scrollArea.setWidget(self.scrollAreaWidgetContents)

		self.verticalLayout_4 = QtGui.QVBoxLayout(self.scrollAreaWidgetContents)
		self.verticalLayout_4.setObjectName(_fromUtf8("verticalLayout_4"))
		self.verticalLayout_3 = QtGui.QVBoxLayout()
		self.verticalLayout_3.setObjectName(_fromUtf8("verticalLayout_3"))
		self.verticalLayout_4.addLayout(self.verticalLayout_3)
		self.scrollArea.setWidget(self.scrollAreaWidgetContents)
		self.horizontalLayout_2.addWidget(self.scrollArea)
		self.verticalLayout.addLayout(self.horizontalLayout_2)
		self.horizontalLayout.addLayout(self.verticalLayout)

		self.buttonBox = QtGui.QDialogButtonBox(self.ma_Bdg_dialog)
		self.buttonBox.setOrientation(QtCore.Qt.Vertical)

		self.bouton_nouveau = QtGui.QPushButton("Nouveau")
		self.buttonBox.addButton(self.bouton_nouveau,QtGui.QDialogButtonBox.ActionRole)
		QtCore.QObject.connect(self.bouton_nouveau,QtCore.SIGNAL("clicked()"),self.element_nouveau) #(utiliser fonction lambda)

		self.bouton_modifier = QtGui.QPushButton("Modifier")
		self.buttonBox.addButton(self.bouton_modifier,QtGui.QDialogButtonBox.ActionRole)
		QtCore.QObject.connect(self.bouton_modifier,QtCore.SIGNAL("clicked()"),self.element_modifier) #(utiliser fonction lambda)

		self.bouton_supprimer = QtGui.QPushButton("Supprimer")
		self.buttonBox.addButton(self.bouton_supprimer,QtGui.QDialogButtonBox.ActionRole)
		QtCore.QObject.connect(self.bouton_supprimer,QtCore.SIGNAL("clicked()"),self.element_supprimer) #(utiliser fonction lambda)

		self.bouton_valider_nouveau = QtGui.QPushButton("Valider Nouv")
		self.buttonBox.addButton(self.bouton_valider_nouveau,QtGui.QDialogButtonBox.ActionRole)
		QtCore.QObject.connect(self.bouton_valider_nouveau,QtCore.SIGNAL("clicked()"),self.element_valider_nouveau) #(utiliser fonction lambda)

		self.bouton_valider_modif = QtGui.QPushButton("Valider Modif")
		self.buttonBox.addButton(self.bouton_valider_modif,QtGui.QDialogButtonBox.ActionRole)
		QtCore.QObject.connect(self.bouton_valider_modif,QtCore.SIGNAL("clicked()"),self.element_valider_modif) #(utiliser fonction lambda)

		self.bouton_annuler = QtGui.QPushButton("Annuler")
		self.buttonBox.addButton(self.bouton_annuler,QtGui.QDialogButtonBox.ActionRole)
		QtCore.QObject.connect(self.bouton_annuler,QtCore.SIGNAL("clicked()"),self.element_annuler) #(utiliser fonction lambda)


		self.horizontalLayout.addWidget(self.buttonBox)

		QtCore.QObject.connect(self.listWidget,QtCore.SIGNAL("itemClicked(QListWidgetItem*)"),self.selection_item) #action sur le listWidget de gauche
		QtCore.QObject.connect(self.listWidget,QtCore.SIGNAL("currentItemChanged(QListWidgetItem *,QListWidgetItem *)"),self.selection_item) #action sur le listWidget de gauche
		

		self.bouton_nouveau.show()
		self.bouton_modifier.show()
		self.bouton_supprimer.show()

		self.bouton_valider_nouveau.hide()
		self.bouton_valider_modif.hide()
		self.bouton_annuler.show()

		self.ma_Bdg_dialog.show()

		self.remplissage(type_champ)

	def element_nouveau(self):		
		if mode_debuggage == 'oui': print "element_nouveau"
		QtCore.QObject.disconnect(self.listWidget,QtCore.SIGNAL("currentItemChanged(QListWidgetItem *,QListWidgetItem *)"),self.selection_item) #action sur le listWidget de gauche
		QtCore.QObject.disconnect(self.listWidget,QtCore.SIGNAL("itemClicked(QListWidgetItem*)"),self.selection_item) #action sur le listWidget de gauche
	
		
		
		self.bouton_nouveau.hide()
		self.bouton_modifier.hide()
		self.bouton_supprimer.hide()
		
		self.bouton_valider_nouveau.show()
		self.bouton_valider_modif.hide()
		self.bouton_annuler.show()
		
		
		#gestion
		self.mon_Qline.setEnabled(True)
		self.listWidget.setEnabled(True)
		self.mon_Qline.setText('')

	def element_modifier(self):
		if mode_debuggage == 'oui': print "element_modifier"
	
		QtCore.QObject.connect(self.listWidget,QtCore.SIGNAL("currentItemChanged(QListWidgetItem *,QListWidgetItem *)"),self.selection_item) #action sur le listWidget de gauche
		QtCore.QObject.connect(self.listWidget,QtCore.SIGNAL("itemClicked(QListWidgetItem*)"),self.selection_item) #action sur le listWidget de gauche
		self.bouton_nouveau.hide()
		self.bouton_modifier.hide()
		self.bouton_supprimer.hide()
		
		self.bouton_valider_nouveau.hide()
		self.bouton_valider_modif.show()
		self.bouton_annuler.show()
		
		#gestion
		self.mon_Qline.setEnabled(True)
		self.listWidget.setEnabled(False)
		item_actuel = self.listWidget.currentItem()
		text_ligne_item_actuel = item_actuel.text()
		self.mon_Qline.setText(text_ligne_item_actuel)
					
	def element_supprimer(self):
		if mode_debuggage == 'oui': print "element_supprimer"
		
		#gestion
		self.mon_Qline.setEnabled(False)
		
		##################
		#on vérifie que le lineedit n'est pas nul et qu'il n'y a pas de doublon avec la base
		if self.mon_Qline.text() != "":
			try:
				mon_ftp = class_FTP_ou_SFTP()
				id=mon_ftp.FTP_ou_SFTP()

				cur=id.cursor()
				##ENVOI EN UNICODE DE TOUTES LES VALEURS dans la base MySQL ET TOUT SE PASSE TRES BIEN !!!
				
				if mode_debuggage == 'oui': print "suppresion"
				#exec(ma_requete1 = "insert into preferences_utilisateurs (nom_utilisateur)" % )
				#	http://stackoverflow.com/questions/775296/python-mysql-with-variables    gestion des injection SQL grâce à la virgule
				
				#cur.execute("delete from preferences_utilisateurs where (nom_utilisateur = %s)" ,(unicode(text_actuel)))
				debut_requete = ("delete from %s where (%s=" % (self.nom_de_table, self.ma_structure_table[0][0]))
				
				suite_requete = debut_requete + "%s)"
				if mode_debuggage == 'oui': print "suite_requete"
				if mode_debuggage == 'oui': print suite_requete
				
				cur.execute(suite_requete, unicode(self.mon_Qline.text()))
			
				cur.close()
				id.commit()
				id.close()
				#on ajoute la nouvelle valeur à la liste de gauche des configs puis on la range puis on la sélectionne et on met le scroll dessus
				
				#QtCore.QObject.disconnect(self.listWidget,QtCore.SIGNAL("currentItemChanged(QListWidgetItem *,QListWidgetItem *)"),self.selection_item) #action sur le listWidget de gauche
				#QtCore.QObject.disconnect(self.listWidget,QtCore.SIGNAL("itemClicked(QListWidgetItem*)"),self.selection_item) #action sur le listWidget de gauche
				monItem = QtGui.QListWidgetItem(self.mon_Qline.text())
				blabla = self.mon_Qline.text()
				#self.listWidget.removeItemWidget(monItem)
				#self.listWidget.takeItem(self.listWidget.row(monItem))
				
				
				mon_mes_items = self.listWidget.findItems(self.mon_Qline.text(), QtCore.Qt.MatchFlags())
				for piti_item in mon_mes_items:
					if mode_debuggage == 'oui': print "piti_item.text()"
					if mode_debuggage == 'oui': print unicode(piti_item.text()).encode("CP850")
					self.listWidget.takeItem(self.listWidget.row(piti_item))
				
				
				
				#sortItems (self, Qt.SortOrder order = Qt.AscendingOrder)
				self.listWidget.sortItems()
				self.listWidget.setCurrentRow(-1)
				#scrollToItem (self, QListWidgetItem item, QAbstractItemView.ScrollHint hint = QAbstractItemView.EnsureVisible)
				self.mon_Qline.setText('')
				#QtCore.QObject.connect(self.listWidget,QtCore.SIGNAL("currentItemChanged(QListWidgetItem *,QListWidgetItem *)"),self.selection_item) #action sur le listWidget de gauche
				
				texte_titre = "Suppression"
				msg_debut = "La ligne:\n " 
				msg_debut2 = unicode(msg_debut, "iso-8859-1") #ce que j'écris en texte dans mon code est en ISO-8859-1 c'est pour ça que unicode(machaine, sys.stdin.encoding) ne sert pas
				msg_variable = unicode(blabla, "iso-8859-1") # pas besoin de sys.stdin.encoding, puisque ça vient d'ailleurs
				msg_fin = "\na bien été supprimée"
				msg_fin2 = unicode(msg_fin, "iso-8859-1")
				msg_total = msg_debut2 + msg_variable + msg_fin2					
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Warning)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_total)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				reponse = ma_boite.exec_()
				
			except MySQLdb.IntegrityError, e: 
				texte_titre = "Erreur"
				msg_debut = "Erreur de suppression" 
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Warning)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_debut)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				reponse = ma_boite.exec_()
			
			except MySQLdb.OperationalError,e:
				texte_titre = "Erreur de connection au serveur"
				msg_debut = "Connexion impossible:  \n Vérifier si la connection au serveur de base de données est bien établie" 
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Warning)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_debut)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				reponse = ma_boite.exec_()
				
			
			
		elif self.mon_Qline.text() == "":
			texte_titre = "Pas de donnée !"
			msg_total = "Vous devez rentrer une valeur"
			QtGui.QApplication.restoreOverrideCursor()
			QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
			ma_boite = QtGui.QMessageBox(MainWindow)
			ma_boite.setIcon(QtGui.QMessageBox.Warning)
			ma_boite.setWindowTitle(texte_titre)
			ma_boite.setInformativeText(msg_total)
			ma_boite.addButton(_fromUtf8("Ok"), 0)
			reponse = ma_boite.exec_()
			
			self.element_annuler() #raz affichage
		
	def element_valider_nouveau(self):
		if mode_debuggage == 'oui': print "element_valider_nouveau"
		#on vérifie que le lineedit n'est pas nul et qu'il n'y a pas de doublon avec la base
		if self.mon_Qline.text() != "":
			try:
				mon_ftp = class_FTP_ou_SFTP()
				id=mon_ftp.FTP_ou_SFTP()

				cur=id.cursor()
				##ENVOI EN UNICODE DE TOUTES LES VALEURS dans la base MySQL ET TOUT SE PASSE TRES BIEN !!!
				
				if mode_debuggage == 'oui': print "insertion nouveau"
				#exec(ma_requete1 = "insert into preferences_utilisateurs (nom_utilisateur)" % )
				#	http://stackoverflow.com/questions/775296/python-mysql-with-variables    gestion des injection SQL grâce à la virgule
				
				#cur.execute("i	nsert into preferences_utilisateurs (nom_utilisateur) values (%s)" ,( unicode(self.mon_Qline.text())))
				"""
				if mode_debuggage == 'oui': print "self.nom_de_table"
				if mode_debuggage == 'oui': print self.nom_de_table
				if mode_debuggage == 'oui': print "self.ma_structure_table[0]"
				if mode_debuggage == 'oui': print self.ma_structure_table[0]
				if mode_debuggage == 'oui': print "unicode(self.mon_Qline.text())"
				if mode_debuggage == 'oui': print unicode(self.mon_Qline.text())
				"""
				
				debut_requete = ("insert into %s (%s) values " % (self.nom_de_table, self.ma_structure_table[0][0]))
				
				suite_requete = debut_requete + "(%s)"
				if mode_debuggage == 'oui': print "suite_requete"
				if mode_debuggage == 'oui': print suite_requete
				
				cur.execute(suite_requete, unicode(self.mon_Qline.text()))
			
				cur.close()
				id.commit()
				id.close()
				#on ajoute la nouvelle valeur à la liste de gauche des configs puis on la range puis on la sélectionne et on met le scroll dessus
				
				QtCore.QObject.disconnect(self.listWidget,QtCore.SIGNAL("currentItemChanged(QListWidgetItem *,QListWidgetItem *)"),self.selection_item) #action sur le listWidget de gauche
				QtCore.QObject.disconnect(self.listWidget,QtCore.SIGNAL("itemClicked(QListWidgetItem*)"),self.selection_item) #action sur le listWidget de gauche
				monItem = QtGui.QListWidgetItem(self.mon_Qline.text())
				self.listWidget.addItem(monItem)
				#sortItems (self, Qt.SortOrder order = Qt.AscendingOrder)
				self.listWidget.sortItems()
				self.listWidget.setCurrentItem(monItem)
				#scrollToItem (self, QListWidgetItem item, QAbstractItemView.ScrollHint hint = QAbstractItemView.EnsureVisible)
				self.listWidget.scrollToItem(monItem)
				self.mon_Qline.setText('')
				#QtCore.QObject.connect(self.listWidget,QtCore.SIGNAL("currentItemChanged(QListWidgetItem *,QListWidgetItem *)"),self.selection_item) #action sur le listWidget de gauche
				
				texte_titre = "Opération"
				msg_debut = "Ligne ajoutée " 
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Information)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_debut)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				reponse = ma_boite.exec_()
				
			except MySQLdb.IntegrityError, e: 
				texte_titre = "Doublon impossible"
				msg_debut = "Doublon impossible ! " 
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Warning)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_debut)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				reponse = ma_boite.exec_()
			
			except MySQLdb.OperationalError,e:
				texte_titre = "Erreur de connection au serveur"
				msg_debut = "Connexion impossible:  \n Vérifier si la connection au serveur de base de données est bien établie" 
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Warning)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_debut)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				reponse = ma_boite.exec_()
				
			
			
		elif self.mon_Qline.text() == "":
			texte_titre = "Pas de donnée !"
			msg_total = "Vous devez rentrer une valeur"
			QtGui.QApplication.restoreOverrideCursor()
			QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
			ma_boite = QtGui.QMessageBox(MainWindow)
			ma_boite.setIcon(QtGui.QMessageBox.Warning)
			ma_boite.setWindowTitle(texte_titre)
			ma_boite.setInformativeText(msg_total)
			ma_boite.addButton(_fromUtf8("Ok"), 0)
			reponse = ma_boite.exec_()
			
			self.element_annuler() #raz affichage
		
	def element_valider_modif(self):
		if mode_debuggage == 'oui': print "element_valider_modif"
		
		#on vérifie que le lineedit n'est pas nul et qu'il n'y a pas de doublon avec la base
		if self.mon_Qline.text() != "":
			try:
				mon_ftp = class_FTP_ou_SFTP()
				id=mon_ftp.FTP_ou_SFTP()

				cur=id.cursor()
				##ENVOI EN UNICODE DE TOUTES LES VALEURS dans la base MySQL ET TOUT SE PASSE TRES BIEN !!!
				
				if mode_debuggage == 'oui': print "modification"
				mon_ancien_Item = self.listWidget.currentItem()
				ancien_blabla = mon_ancien_Item.text()
				if mode_debuggage == 'oui': print "ancien_blabla"
				if mode_debuggage == 'oui': print unicode(ancien_blabla).encode("CP850")
				
				mon_nouveau_Item = QtGui.QListWidgetItem(self.mon_Qline.text())
				nouveau_blabla = self.mon_Qline.text()
				
				#on supprime l'ancien
				for SelectedItem in self.listWidget.selectedItems():
					self.listWidget.takeItem(self.listWidget.row(SelectedItem))
				
				#exec(ma_requete1 = "insert into preferences_utilisateurs (nom_utilisateur)" % )
				#	http://stackoverflow.com/questions/775296/python-mysql-with-variables    gestion des injection SQL grâce à la virgule
				
				#cur.execute("delete from preferences_utilisateurs where (nom_utilisateur = %s)" ,(unicode(text_actuel)))
				
				
				#cur.execute("UPDATE preferences_utilisateurs SET nom_utilisateur=%s, ordre_col_tableau_resultat=%s, ordre_zone_scroll_area=%s WHERE (nom_utilisateur=%s)" , \
				#(nouveau_text, str(matrice_colonnes_resultat), str(nouvelle_matrice_colonnes_scroll),ancien_text))
				
				
				#"UPDATE self.nom_de_table SET self.ma_structure_table[0][0]='nouveau_blabla' WHERE self.ma_structure_table[0][0]='ancien_blabla'"
				#remise à jour toute la table "principale" avec la modification effectuée sur la petite table
				#pour cela, il faut: 
				#1 prendre le nom de la table: self.nom_de_table (et donc s'assurer que les noms de table soient les mêmes que les noms de champ de "base_des_affaires1"
				#2 chercher l'équivalence self.nom_de_table dans "base_des_affaires1" / premier champ / element[0] du split # ==> on en déduit le bon champ dans base_des_affaires1
				# scanner toute la base "base_des_affaires1" et modifier (UPDATE)tous les élements rencontrés
				
				#### premiere requete
				A = ("update %s set %s=" % (self.nom_de_table, self.ma_structure_table[0][0]))
				B = A + "%s"
				C = (" WHERE %s=" % (self.ma_structure_table[0][0]))
				D = C + "%s"
				tot = B + D
				if mode_debuggage == 'oui': print "total"
				if mode_debuggage == 'oui': print tot
				
				cur.execute(tot, (unicode(nouveau_blabla), unicode(ancien_blabla)))
				cur.close()
				
				
				
				
				######début seconde requete 
				
				cur2=id.cursor()
				
				mon_libelle_col0 = mon_form.mon_grid_area.itemAtPosition(self.num_row_grid,0).widget().text()
				for num_elem in range(len(mon_form.TRI_mon_list_de_list_de_parametres_de_tri)):
					if mon_libelle_col0 == mon_form.TRI_mon_list_de_list_de_parametres_de_tri[num_elem][6]:
						if mode_debuggage == 'oui': print "va au dodo"
						if mode_debuggage == 'oui': print "champ a mettre a jour dans la base principale"
						
						champ_mis_a_jour =  mon_form.TRI_mon_list_de_list_de_parametres_de_tri[num_elem][0]
						if mode_debuggage == 'oui': print champ_mis_a_jour
				
				
				
				A2 = ("update `%s` set `%s`=" % (mysql_Nom_de_table, champ_mis_a_jour))
				B2 = A2 + "%s"
				C2 = (" WHERE `%s`=" % (champ_mis_a_jour))
				D2 = C2 + "%s"
				tot2 = B2 + D2
				if mode_debuggage == 'oui': print "total2"
				if mode_debuggage == 'oui': print tot2
				cur2.execute(tot2, (unicode(nouveau_blabla), unicode(ancien_blabla)))
				cur2.close()
				
				id.commit()
				id.close()
				#on ajoute la nouvelle valeur à la liste de gauche des configs puis on la range puis on la sélectionne et on met le scroll dessus
				
				#QtCore.QObject.disconnect(self.listWidget,QtCore.SIGNAL("currentItemChanged(QListWidgetItem *,QListWidgetItem *)"),self.selection_item) #action sur le listWidget de gauche
				#QtCore.QObject.disconnect(self.listWidget,QtCore.SIGNAL("itemClicked(QListWidgetItem*)"),self.selection_item) #action sur le listWidget de gauche
				
				
				self.listWidget.addItem(mon_nouveau_Item)
				self.listWidget.sortItems()
				self.listWidget.setCurrentItem(mon_nouveau_Item)
				self.listWidget.scrollToItem(mon_nouveau_Item)
				
				
				texte_titre = "Modification effectuée"
				msg_debut = "Ligne modifiée dans base des donneurs d'ordre\nLignes correspondantes également modifiées dans la base des affaires" 				
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Information)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_debut)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				reponse = ma_boite.exec_()
			
			
			except MySQLdb.IntegrityError, e: 
				if mode_debuggage == 'oui': print e
				texte_titre = "Erreur"
				msg_debut = "Erreur de Modification" 
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Warning)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_debut)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				reponse = ma_boite.exec_()
			
			except MySQLdb.OperationalError,e:
				texte_titre = "Erreur de connection au serveur"
				msg_debut = "Connexion impossible:  \n Vérifier si la connection au serveur de base de données est bien établie" 
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Warning)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_debut)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				reponse = ma_boite.exec_()
				
			
			
		elif self.mon_Qline.text() == "":
			texte_titre = "Pas de donnée !"
			msg_total = "Vous devez rentrer une valeur"
			QtGui.QApplication.restoreOverrideCursor()
			QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
			ma_boite = QtGui.QMessageBox(MainWindow)
			ma_boite.setIcon(QtGui.QMessageBox.Warning)
			ma_boite.setWindowTitle(texte_titre)
			ma_boite.setInformativeText(msg_total)
			ma_boite.addButton(_fromUtf8("Ok"), 0)
			reponse = ma_boite.exec_()
			
		self.element_annuler() #raz affichage
		
	def element_annuler(self):
		if mode_debuggage == 'oui': print "element_annuler"
		QtCore.QObject.connect(self.listWidget,QtCore.SIGNAL("currentItemChanged(QListWidgetItem *,QListWidgetItem *)"),self.selection_item) #action sur le listWidget de gauche
		QtCore.QObject.connect(self.listWidget,QtCore.SIGNAL("itemClicked(QListWidgetItem*)"),self.selection_item) #action sur le listWidget de gauche
		if self.bouton_nouveau.isHidden() == False and self.bouton_modifier.isHidden() == False and self.bouton_supprimer.isHidden() == False:
			self.ma_Bdg_dialog.close()
		
		
		else:
			self.bouton_nouveau.show()
			self.bouton_modifier.show()
			self.bouton_supprimer.show()
			
			self.bouton_valider_nouveau.hide()
			self.bouton_valider_modif.hide()
			self.bouton_annuler.show()
			
			self.mon_Qline.setEnabled(False)
			self.listWidget.setEnabled(True)
			
			if self.mon_Qline.text() == "":
				self.listWidget.setCurrentRow(0)
			else:
				
				mon_mes_items = self.listWidget.findItems(self.mon_Qline.text(), QtCore.Qt.MatchFlags())
				for piti_item in mon_mes_items:
					if mode_debuggage == 'oui': print "piti_item.text()"
					if mode_debuggage == 'oui': print unicode(piti_item.text()).encode("CP850")
					self.listWidget.setCurrentItem(piti_item)
					self.listWidget.scrollToItem(piti_item)	
			
			"""
			mon_ancien_Item = self.listWidget.currentItem()
			ancien_blabla = mon_ancien_Item.text()
			if mode_debuggage == 'oui': print "ancien_blabla"
			if mode_debuggage == 'oui': print unicode(ancien_blabla).encode("CP850")
			
			mon_nouveau_Item = QtGui.QListWidgetItem(self.mon_Qline.text())
			nouveau_blabla = self.mon_Qline.text()
			
			#on supprime l'ancien
			for SelectedItem in self.listWidget.selectedItems():
				self.listWidget.takeItem(self.listWidget.row(SelectedItem))
			"""
		
	def remplissage(self,type_champ):
		if mode_debuggage == 'oui': print "\ndef remplissage"
		
		mon_ftp = class_FTP_ou_SFTP()
		id=mon_ftp.FTP_ou_SFTP()
		
		cur=id.cursor()
		cur.execute("select * from %s ORDER BY 1 ASC" % self.nom_de_table)
		#cur.execute("select * from %s order by affaire_QLE" % mysql_Nom_de_table)
		self.mon_list_de_list_tables_annexes = list(cur.fetchall())
		cur.close()
		
		cur2=id.cursor()
		cur2.execute("SELECT COLUMN_NAME, COLUMN_TYPE, IS_NULLABLE, COLUMN_KEY, COLUMN_DEFAULT, COLUMN_COMMENT FROM INFORMATION_SCHEMA.COLUMNS WHERE table_name = '%s'" % self.nom_de_table)
		self.ma_structure_table = list(cur2.fetchall())
		cur2.close()
		
		id.commit()
		id.close()
		
		
		if mode_debuggage == 'oui': print self.mon_list_de_list_tables_annexes #toutes la base est dedans
		#if mode_debuggage == 'oui': print "%d lignes\n" % cur.rowcount
		
		if mode_debuggage == 'oui': print "Remplissage Qscroll Area de fenetre"
		nb_total_champs = len(self.mon_list_de_list_tables_annexes)
		if mode_debuggage == 'oui': print nb_total_champs
		
		
		if mode_debuggage == 'oui': print "self.ma_structure_table"
		if mode_debuggage == 'oui': print self.ma_structure_table
		#on crée autant de QlineEdit qu'il y a de champs. Dans notres cas, il n'y en a qu'un
		for elem in self.ma_structure_table:
			self.mon_Qlabel = QtGui.QLabel()
			self.mon_Qlabel.setText(elem[0]) #elem[0] est le nom du champ
			self.verticalLayout_4.addWidget(self.mon_Qlabel)
			
			self.mon_Qline = QtGui.QLineEdit()
			self.verticalLayout_4.addWidget(self.mon_Qline)
			self.mon_Qline.setEnabled(False)
			
			self.mon_Qlabel_separat = QtGui.QLabel()
			self.mon_Qlabel_separat.setText("---------------")
			self.verticalLayout_4.addWidget(self.mon_Qlabel_separat)
			
			spacerItem = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
			self.verticalLayout_4.addItem(spacerItem)
		
		
		for elem in self.mon_list_de_list_tables_annexes:
			monItem = QtGui.QListWidgetItem(elem[0])
			self.listWidget.addItem(monItem)
					
		#self.listWidget.setCurrentRow(0)

	def selection_item(self):
		try:
			item_actuel = self.listWidget.currentItem()
			text_ligne_item_actuel = item_actuel.text()
			#if mode_debuggage == 'oui': print "text_ligne_item_actuel"
			#if mode_debuggage == 'oui': print text_ligne_item_actuel
			self.mon_Qline.setText(text_ligne_item_actuel)
		except:
			self.mon_Qline.setText('')
	


class Fenetre_CONFIG_UTILISATEUR_SQL_ajout_modif_suppression():
	def creation_fenetre_config(self, table_liste_des_configs):
		if mode_debuggage == 'oui': print "\ndef creation_fenetre_config"
		if mode_debuggage == 'oui': print table_liste_des_configs
		
		self.table_liste_des_configs = table_liste_des_configs #on passe la variable accessible dans toute la classe!!
	
		self.dialogConfig = QtGui.QDialog(MainWindow)
		self.dialogConfig.setWindowModality(QtCore.Qt.ApplicationModal) #fenetre modale: non_modal: setWindowModality(QtCore.Qt.NonModal)
		self.dialogConfig.setWindowTitle("Gestion des configurations") #nom de la fenetre
		
		#exec("MainWindow.setWindowIcon(QtGui.QIcon(_fromUtf8('%s%s')))" % (chemin_icone, "/listen.png"))

		self.dialogConfig.setObjectName(_fromUtf8("self.dialogConfig"))
		self.dialogConfig.resize(800, 600)
		self.dialogConfig.setWindowTitle(QtGui.QApplication.translate("self.dialogConfig", "Enregistrement des parametres + Ordre des champs", None, QtGui.QApplication.UnicodeUTF8))
		self.horizontalLayout = QtGui.QHBoxLayout(self.dialogConfig)
		self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
		
		self.verticalLayout = QtGui.QVBoxLayout()
		self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
		
		self.horizontalLayout_2 = QtGui.QHBoxLayout()
		self.horizontalLayout_2.setObjectName(_fromUtf8("horizontalLayout_2"))
		
		self.verticalLayout_3 = QtGui.QVBoxLayout()
		self.verticalLayout_3.setObjectName(_fromUtf8("verticalLayout_3"))
		
		self.verticalLayout_4 = QtGui.QVBoxLayout()
		self.verticalLayout_4.setObjectName(_fromUtf8("verticalLayout_4"))
		
		self.lineEdit_info = QtGui.QLineEdit(self.dialogConfig)
		self.lineEdit_info.setObjectName(_fromUtf8("lineEdit_info"))
		self.lineEdit_info.setDisabled(True)
		self.verticalLayout_4.addWidget(self.lineEdit_info)
		
		self.horizontalLayout_Haut = QtGui.QHBoxLayout()
		self.horizontalLayout_Haut.setObjectName(_fromUtf8("horizontalLayout_Haut"))
		self.label_haut = QtGui.QLabel(self.dialogConfig)
		self.label_haut.setObjectName(_fromUtf8("label_haut"))
		self.label_haut.setText("Nom config:")
		self.horizontalLayout_Haut.addWidget(self.label_haut)
		self.lineEdit = QtGui.QLineEdit(self.dialogConfig)
		self.lineEdit.setObjectName(_fromUtf8("lineEdit"))
		#self.lineEdit.setDisabled(True)
		self.horizontalLayout_Haut.addWidget(self.lineEdit)
		self.verticalLayout_3.addLayout(self.horizontalLayout_Haut)
		
		self.listConfig = QtGui.QListWidget(self.dialogConfig)
		self.listConfig.setObjectName(_fromUtf8("listConfig"))
		self.verticalLayout_3.addWidget(self.listConfig)
		
		self.horizontalLayout_2.addLayout(self.verticalLayout_3)
		
		self.tableColonnes = QtGui.QTableWidget(self.dialogConfig)
		self.tableColonnes.setObjectName(_fromUtf8("self.tableColonnes"))
		self.verticalLayout_4.addWidget(self.tableColonnes)
		self.tableColonnes.setColumnCount(2)
		self.tableColonnes.horizontalHeader().hide()
		self.tableColonnes.verticalHeader().hide()
				
		######
		self.horizontalLayout_Bas = QtGui.QHBoxLayout()
		self.horizontalLayout_Bas.setObjectName(_fromUtf8("horizontalLayout_Bas"))
		self.label_bas = QtGui.QLabel(self.dialogConfig)
		self.label_bas.setObjectName(_fromUtf8("label_bas"))
		self.label_bas.setText("Config en cours:")
		self.horizontalLayout_Bas.addWidget(self.label_bas)
		self.line_edit_config_en_cours = QtGui.QLineEdit(self.dialogConfig)
		self.line_edit_config_en_cours.setObjectName(_fromUtf8("line_edit_config_en_cours"))
		self.line_edit_config_en_cours.setText(GLOBAL_config_actuelle_finale)
		self.line_edit_config_en_cours.setReadOnly(True)
		self.horizontalLayout_Bas.addWidget(self.line_edit_config_en_cours)
		self.verticalLayout_3.addLayout(self.horizontalLayout_Bas)
		######
		
		self.horizontalLayout_2.addLayout(self.verticalLayout_4)
		self.verticalLayout_2 = QtGui.QVBoxLayout()
		self.verticalLayout_2.setObjectName(_fromUtf8("verticalLayout_2"))
		spacerItem = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
		self.verticalLayout_2.addItem(spacerItem)
		self.bouton_haut = QtGui.QPushButton(self.dialogConfig)
		self.bouton_haut.setText("Haut")
		self.bouton_haut.setObjectName(_fromUtf8("bouton_haut"))
		self.verticalLayout_2.addWidget(self.bouton_haut)
		self.bouton_bas = QtGui.QPushButton(self.dialogConfig)
		self.bouton_bas.setText("Bas")
		self.bouton_bas.setObjectName(_fromUtf8("bouton_bas"))
		self.verticalLayout_2.addWidget(self.bouton_bas)
		spacerItem1 = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
		self.verticalLayout_2.addItem(spacerItem1)
		self.horizontalLayout_2.addLayout(self.verticalLayout_2)
		self.verticalLayout.addLayout(self.horizontalLayout_2)
		self.horizontalLayout.addLayout(self.verticalLayout)

		self.buttonBox = QtGui.QDialogButtonBox(self.dialogConfig)
		self.buttonBox.setOrientation(QtCore.Qt.Vertical)

		QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL(_fromUtf8("rejected()")), self.dialogConfig.reject)
		#########################

		
		self.bouton_nouveau = QtGui.QPushButton("Nouveau", self.dialogConfig)
		self.buttonBox.addButton(self.bouton_nouveau,QtGui.QDialogButtonBox.ActionRole)
		QtCore.QObject.connect(self.bouton_nouveau,QtCore.SIGNAL("clicked()"),self.element_nouveau)

		self.bouton_valider_nouveau = QtGui.QPushButton("Valider Nouv", self.dialogConfig)
		self.buttonBox.addButton(self.bouton_valider_nouveau,QtGui.QDialogButtonBox.ActionRole)
		QtCore.QObject.connect(self.bouton_valider_nouveau,QtCore.SIGNAL("clicked()"),self.valider_nouveau)
		
		self.bouton_modifier = QtGui.QPushButton("Modifier", self.dialogConfig)
		self.buttonBox.addButton(self.bouton_modifier,QtGui.QDialogButtonBox.ActionRole)
		QtCore.QObject.connect(self.bouton_modifier,QtCore.SIGNAL("clicked()"),self.element_modifier)
		
		self.bouton_valider_modif = QtGui.QPushButton("Valider Modif", self.dialogConfig)
		self.buttonBox.addButton(self.bouton_valider_modif,QtGui.QDialogButtonBox.ActionRole)
		QtCore.QObject.connect(self.bouton_valider_modif,QtCore.SIGNAL("clicked()"),self.valider_modif)
		
		self.bouton_supprimer = QtGui.QPushButton("Supprimer", self.dialogConfig)
		self.buttonBox.addButton(self.bouton_supprimer,QtGui.QDialogButtonBox.ActionRole)
		QtCore.QObject.connect(self.bouton_supprimer,QtCore.SIGNAL("clicked()"),self.supprimer)
			
		
		#spacerItem2 = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
		#self.buttonBox.addButton(spacerItem2)
		
		self.bouton_defaut = QtGui.QPushButton("Définir par \ndéfaut", self.dialogConfig)
		self.buttonBox.addButton(self.bouton_defaut,QtGui.QDialogButtonBox.ActionRole)
		QtCore.QObject.connect(self.bouton_defaut,QtCore.SIGNAL("clicked()"),self.element_par_defaut)

		self.bouton_annuler = QtGui.QPushButton("Annuler", self.dialogConfig)
		self.buttonBox.addButton(self.bouton_annuler,QtGui.QDialogButtonBox.ActionRole)
		QtCore.QObject.connect(self.bouton_annuler,QtCore.SIGNAL("clicked()"),self.element_annuler)
		
		self.bouton_fermer2 = QtGui.QPushButton("Fermer", self.dialogConfig)
		self.buttonBox.addButton(self.bouton_fermer2,QtGui.QDialogButtonBox.ActionRole)
		QtCore.QObject.connect(self.bouton_fermer2,QtCore.SIGNAL("clicked()"),self.element_fermer)
		
		self.horizontalLayout.addWidget(self.buttonBox)
		
		#QtCore.QObject.connect(self.listConfig,QtCore.SIGNAL("itemClicked(QListWidgetItem *)"),self.selection_item2) #action sur le listWidget de gauche
		#QtCore.QObject.connect(self.listConfig,QtCore.SIGNAL("currentItemChanged(QListWidgetItem *,QListWidgetItem *)"),self.selection_item2) #action sur le listWidget de gauche
		QtCore.QObject.connect(self.listConfig,QtCore.SIGNAL("itemSelectionChanged()"),self.selection_item2) #action sur le listWidget de gauche
		QtCore.QObject.connect(self.bouton_haut,QtCore.SIGNAL("clicked()"),lambda self=self, haut_ou_bas="haut": self.element_bouton_haut_ou_bas(haut_ou_bas))
		QtCore.QObject.connect(self.bouton_bas,QtCore.SIGNAL("clicked()"),lambda self=self, haut_ou_bas="bas": self.element_bouton_haut_ou_bas(haut_ou_bas))
		
		
		self.affichage_initial()
		
		self.dialogConfig.show()

		self.remplissage_GLOBAL_mon_tuple_de_tuple_des_configs()
		
		
		#######
		"""
		self.bouton_nouveau					self.element_nouveau
		self.bouton_valider_nouveau			self.valider_nouveau
		self.bouton_modifier				self.element_modifer
		self.bouton_valider_modif			self.valider_modif
		self.bouton_supprimer				self.supprimer
		self.bouton_defaut					self.element_par_defaut
		self.bouton_annuler					self.element_annuler
		self.bouton_fermer2					self.element_fermer
		"""
		
	def affichage_initial(self):
		self.bouton_nouveau.show()
		self.bouton_valider_nouveau.hide()
		self.bouton_modifier.show()
		self.bouton_valider_modif.hide()
		self.bouton_supprimer.show()
		self.bouton_defaut.show()
		self.bouton_annuler.hide()
		self.bouton_fermer2.show()
		
		self.lineEdit.setEnabled(False)
		self.listConfig.setEnabled(True)
		self.tableColonnes.setEnabled(False)
		self.bouton_haut.setEnabled(False)
		self.bouton_bas.setEnabled(False)
		
		if self.listConfig.currentRow() == -1:
			self.bouton_modifier.setEnabled(False)
			self.bouton_supprimer.setEnabled(False)
			self.bouton_defaut.setEnabled(False)
		
	def element_nouveau(self):
		if mode_debuggage == 'oui': print "element_nouveau"
		
		self.bouton_nouveau.hide()
		self.bouton_valider_nouveau.show()
		self.bouton_modifier.hide()
		self.bouton_valider_modif.hide()
		
		self.bouton_supprimer.hide()
		self.bouton_defaut.hide()
		
		self.bouton_annuler.show()
		self.bouton_fermer2.hide()
		
		
		self.lineEdit.setEnabled(True)
		self.listConfig.setEnabled(False)
		self.tableColonnes.setEnabled(True)
		self.bouton_haut.setEnabled(True)
		self.bouton_bas.setEnabled(True)
		
		self.lineEdit.setText('')
		self.listConfig.setCurrentRow(-1)  
		
		
		self.selection_item2() #appelle la fonction selection_item2 pour la  toute première initialisation
				
	def element_modifier(self):
		if mode_debuggage == 'oui': print "element_nouveau"
		self.bouton_nouveau.hide()
		self.bouton_valider_nouveau.hide()
		self.bouton_modifier.hide()
		self.bouton_valider_modif.show()
		self.bouton_supprimer.hide()
		self.bouton_defaut.hide()
		self.bouton_annuler.show()
		self.bouton_fermer2.hide()
		
		self.lineEdit.setEnabled(True)
		self.listConfig.setEnabled(False)
		self.tableColonnes.setEnabled(True)
		self.bouton_haut.setEnabled(True)
		self.bouton_bas.setEnabled(True)
				
	def valider_nouveau(self):
		if mode_debuggage == 'oui': print "def element_valider_nouv_ou_modif_ou_enreg"
		doublon = "non"
		#on vérifie que le lineedit n'est pas nul et qu'il n'y a pas de doublon avec la base
		if self.lineEdit.text() != "":
			for elem in GLOBAL_mon_tuple_de_tuple_des_configs:
				if mode_debuggage == 'oui': print "elem[0]"
				if mode_debuggage == 'oui': print elem[0]
				
				 #GESTION DOUBLON
				if (elem[0]) == (self.lineEdit.text()): #doublon trouvé   
					texte_titre = "Doublon interdit !"
					msg_debut = "La configuration:\n " 
					msg_debut2 = unicode(msg_debut, "iso-8859-1") #ce que j'écris en texte dans mon code est en ISO-8859-1 c'est pour ça que unicode(machaine, sys.stdin.encoding) ne sert pas
					msg_variable = unicode(elem[0], "iso-8859-1") # pas besoin de sys.stdin.encoding, puisque ça vient d'ailleurs
					msg_fin = "\nexiste déjà"
					msg_fin2 = unicode(msg_fin, "iso-8859-1")
					msg_total = msg_debut2 + msg_variable + msg_fin2					
					QtGui.QApplication.restoreOverrideCursor()
					QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
					ma_boite = QtGui.QMessageBox(MainWindow)
					ma_boite.setIcon(QtGui.QMessageBox.Warning)
					ma_boite.setWindowTitle(texte_titre)
					ma_boite.setInformativeText(msg_total)
					ma_boite.addButton(_fromUtf8("Ok"), 0)
					reponse = ma_boite.exec_()
					
					self.element_annuler() #raz affichage
					
					doublon = "oui"
				
				
			if doublon == "non": # pas de doublon, on insère dans MySQL
				mon_ftp = class_FTP_ou_SFTP()
				id=mon_ftp.FTP_ou_SFTP()
	
				cur=id.cursor()
				##ENVOI EN UNICODE DE TOUTES LES VALEURS dans la base MySQL ET TOUT SE PASSE TRES BIEN !!!
				
				if mode_debuggage == 'oui': print "insertion nouveau"
				if mode_debuggage == 'oui': print self.table_liste_des_configs
				if mode_debuggage == 'oui': print unicode(self.table_liste_des_configs)
				if mode_debuggage == 'oui': print repr( unicode(self.table_liste_des_configs))
				if mode_debuggage == 'oui': print unicode(self.lineEdit.text())
				if mode_debuggage == 'oui': print repr(unicode(self.lineEdit.text()))
				
				#	http://stackoverflow.com/questions/775296/python-mysql-with-variables    gestion des injection SQL grâce à la virgule
				cur.execute("insert into preferences_utilisateurs (nom_utilisateur) values (%s)" ,(unicode(self.lineEdit.text())))
				
				cur.close()
				id.commit()
				id.close()
				#on réactualise la liste de gauche des configs puis on retrouve sa valeur dans les champs et on lance "valider modif"
		
				QtCore.QObject.disconnect(self.listConfig,QtCore.SIGNAL("itemSelectionChanged()"),self.selection_item2) #action sur le listWidget de gauche
				#if mode_debuggage == 'oui': print "self.lineEdit.text()"
				#if mode_debuggage == 'oui': print unicode(self.lineEdit.text()).encode("CP850")
				self.remplissage_GLOBAL_mon_tuple_de_tuple_des_configs()
				#if mode_debuggage == 'oui': print "self.lineEdit.text()"
				#if mode_debuggage == 'oui': print unicode(self.lineEdit.text()).encode("CP850")
				
				#list-of-QListWidgetItem findItems (self, QString text, Qt.MatchFlags flags)
				#mon_mes_items = self.listConfig.findItems(self.lineEdit.text(), QtCore.Qt.MatchRegExp)
				mon_mes_items = self.listConfig.findItems(self.lineEdit.text(), QtCore.Qt.MatchFlags())
				for piti_item in mon_mes_items:
					if mode_debuggage == 'oui': print "piti_item.text()"
					if mode_debuggage == 'oui': print unicode(piti_item.text()).encode("CP850")
					self.listConfig.setCurrentItem(piti_item)
					self.listConfig.scrollToItem(piti_item)
		
				if mode_debuggage == 'oui': print ""
				if mode_debuggage == 'oui': print "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
				if mode_debuggage == 'oui': print "item nouveau avant moulinette modif"
				if mode_debuggage == 'oui': print unicode(self.listConfig.currentItem().text()).encode("CP850")
				QtCore.QObject.connect(self.listConfig,QtCore.SIGNAL("itemSelectionChanged()"),self.selection_item2) #action sur le listWidget de gauche
				self.valider_modif("nouveau")
							
			#self.affichage_initial()
		elif self.lineEdit.text() == "":
			texte_titre = "Pas de titre !"
			msg_total = "Vous devez rentrer une valeur"
			QtGui.QApplication.restoreOverrideCursor()
			QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
			ma_boite = QtGui.QMessageBox(MainWindow)
			ma_boite.setIcon(QtGui.QMessageBox.Warning)
			ma_boite.setWindowTitle(texte_titre)
			ma_boite.setInformativeText(msg_total)
			ma_boite.addButton(_fromUtf8("Ok"), 0)
			reponse = ma_boite.exec_()
			
			self.element_annuler() #raz affichage
	
	def valider_modif(self, nouv_ou_modif = "modif"):
		if mode_debuggage == 'oui': print "Valider _modif"
		num_ligne = self.listConfig.currentRow()
		if mode_debuggage == 'oui': print unicode(self.listConfig.item(num_ligne).text()).encode("cp850")
		doublon = "non"
		#on vérifie que le lineedit n'est pas nul et qu'il n'y a pas de doublon avec la base
		if self.lineEdit.text() != "" and self.listConfig.currentRow() != -1:				
			try:
				### partie ordre des champs + UPDATE de tout le monde ###
				if mode_debuggage == 'oui': print "valider modif"
				#marche à suivre:
				#intervertir la matrice en retenant l'ordre uniquement
				nouvelle_matrice_colonnes_scroll = []
				nouvelle_matrice_colonnes_scroll.append(0)
				for i in range(self.tableColonnes.rowCount()):
					mon_num = self.tableColonnes.item(i,0).data(0).toString()
					nouvelle_matrice_colonnes_scroll.append(int(mon_num))
				if mode_debuggage == 'oui': print "nouvelle_matrice_colonnes_scroll"
				#if mode_debuggage == 'oui': print nouvelle_matrice_colonnes_scroll
				if nouv_ou_modif == "modif":
					ancien_text = unicode(self.listConfig.item(num_ligne).text())
					nouveau_text = unicode(self.lineEdit.text())
					
				elif nouv_ou_modif == "nouveau":
					ancien_text = unicode(self.listConfig.item(num_ligne).text())
					nouveau_text = ancien_text
				
				if mode_debuggage == 'oui': print "ancien_text"
				if mode_debuggage == 'oui': print ancien_text
				if mode_debuggage == 'oui': print "nouveau_text"
				if mode_debuggage == 'oui': print nouveau_text
				
				mon_ftp = class_FTP_ou_SFTP()
				id=mon_ftp.FTP_ou_SFTP()
				cur=id.cursor()
				#cur.execute("UPDATE preferences_utilisateurs SET nom_utilisateur=%s, ordre_zone_scroll_area=%s WHERE (nom_utilisateur=%s)" ,(nouveau_text, str(nouvelle_matrice_colonnes_scroll),ancien_text))
				cur.execute("UPDATE preferences_utilisateurs SET nom_utilisateur=%s, ordre_zone_scroll_area=%s WHERE (nom_utilisateur=%s)" , \
				(nouveau_text, str(nouvelle_matrice_colonnes_scroll),ancien_text))
				
				cur.close()
				id.commit()
				id.close()
				
				#on réactualise la liste de gauche des configs!
				self.remplissage_GLOBAL_mon_tuple_de_tuple_des_configs()
				
				texte_titre = "Enregistrement effectué"
				msg_debut = "Configuration:\n " 
				msg_debut2 = unicode(msg_debut, "iso-8859-1") #ce que j'écris en texte dans mon code est en ISO-8859-1 c'est pour ça que unicode(machaine, sys.stdin.encoding) ne sert pas
				msg_variable = nouveau_text # pas besoin de sys.stdin.encoding, puisque ça vient d'ailleurs
				msg_fin = "\nOrdre des champs enregistrés"
				msg_fin2 = unicode(msg_fin, "iso-8859-1")
				msg_total = msg_debut2 + msg_variable + msg_fin2					
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Information)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_total)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				reponse = ma_boite.exec_()
				
				self.affichage_initial()
			except MySQLdb.IntegrityError, e: 
				texte_titre = "Doublon impossible"
				msg_debut = "Doublon impossible ! " 
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Warning)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_debut)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				reponse = ma_boite.exec_()
				
				self.affichage_initial()
				
		elif self.lineEdit.text() == "":
			texte_titre = "Pas de titre !"
			msg_total = "Vous devez rentrer une valeur"
			QtGui.QApplication.restoreOverrideCursor()
			QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
			ma_boite = QtGui.QMessageBox(MainWindow)
			ma_boite.setIcon(QtGui.QMessageBox.Warning)
			ma_boite.setWindowTitle(texte_titre)
			ma_boite.setInformativeText(msg_total)
			ma_boite.addButton(_fromUtf8("Ok"), 0)
			reponse = ma_boite.exec_()
			
			self.element_annuler() #raz affichage
	
	def supprimer(self):
		if mode_debuggage == 'oui': print "supprimer"
		mon_ftp = class_FTP_ou_SFTP()
		id=mon_ftp.FTP_ou_SFTP()

		cur=id.cursor()
		##ENVOI EN UNICODE DE TOUTES LES VALEURS dans la base MySQL ET TOUT SE PASSE TRES BIEN !!!
		ligne_aactu = self.listConfig.currentItem()
		text_actuel = ligne_aactu.text()
		cur.execute("delete from preferences_utilisateurs where (nom_utilisateur = %s)" ,(unicode(text_actuel)))
		
		for i in range (self.tableColonnes.rowCount()):
			self.tableColonnes.removeRow(0)
		
		cur.close()
		id.commit()
		id.close()
		self.lineEdit.setText('')
		#on réactualise la liste de gauche des configs!
		self.remplissage_GLOBAL_mon_tuple_de_tuple_des_configs()
	
	def element_par_defaut(self):
		global GLOBAL_config_actuelle_finale
		ma_var_defaut = self.listConfig.currentItem().text()
		GLOBAL_config_actuelle_finale = ma_var_defaut
		self.line_edit_config_en_cours.setText(GLOBAL_config_actuelle_finale)
		
		#statusBar dans mon_form
		ma_var1 = 'Config: '
		ma_var_tot = ma_var1 + GLOBAL_config_actuelle_finale
		mon_form.mon_Qlabel_status_bar.setText(ma_var_tot)
		
		#qmessagebox
		texte_titre = "Config en cours !"
		msg_debut = "Configuration en cours:\n " 
		msg_debut2 = unicode(msg_debut, "iso-8859-1") #ce que j'écris en texte dans mon code Notepad est en ANSI ISO-8859-1 c'est pour ça que unicode(machaine, sys.stdin.encoding) ne sert pas
		msg_variable = unicode(GLOBAL_config_actuelle_finale) # pas besoin de sys.stdin.encoding, puisque ça vient d'ailleurs
		
		
		#rechargement des fenetres
		mon_form.initialisation_et_chargement()
		if mode_debuggage == 'oui': print "zaza38"
		
		msg_total = msg_debut2 + msg_variable
		QtGui.QApplication.restoreOverrideCursor()
		QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
		ma_boite = QtGui.QMessageBox(MainWindow)
		ma_boite.setIcon(QtGui.QMessageBox.Information)
		ma_boite.setWindowTitle(texte_titre)
		ma_boite.setInformativeText(msg_total)
		ma_boite.addButton(_fromUtf8("Ok"), 0)
		reponse = ma_boite.exec_()
		
		mon_setting = QtCore.QSettings("Echologos", "Basaffaire")
		mon_setting.setValue('config_par_defaut/nom_config', GLOBAL_config_actuelle_finale)
		#GLOBAL_config_actuelle_finale = unicode("dada28", "iso-8859-1")
		
	def element_annuler(self):
		self.affichage_initial()
		
	def element_fermer(self):
		if mode_debuggage == 'oui': print "element_fermer"
		self.dialogConfig.close()	
	
	def element_bouton_haut_ou_bas(self,haut_ou_bas):
		if mode_debuggage == 'oui': print "def element_bouton_haut_ou_bas"
		if mode_debuggage == 'oui': print haut_ou_bas
		if mode_debuggage == 'oui': print self.tableColonnes.currentRow()
		if self.tableColonnes.currentRow() == -1 or self.tableColonnes.currentRow() == None:
			if mode_debuggage == 'oui': print "ligne non selectionnee"
		else:
			if haut_ou_bas == "haut":
				self.moveUp()
			elif haut_ou_bas == "bas":
				self.moveDown()
		
	def moveDown(self):
		row = self.tableColonnes.currentRow()
		column = self.tableColonnes.currentColumn()
		if row < self.tableColonnes.rowCount()-1:
			self.tableColonnes.insertRow(row+2)
			for i in range(self.tableColonnes.columnCount()):
				self.tableColonnes.setItem(row+2,i,self.tableColonnes.takeItem(row,i))
				self.tableColonnes.setCurrentCell(row+2,column)
			self.tableColonnes.removeRow(row)        
		self.tableColonnes.resizeRowsToContents()
		
	def moveUp(self):    
		row = self.tableColonnes.currentRow()
		column = self.tableColonnes.currentColumn()
		if row > 0:
			self.tableColonnes.insertRow(row-1)
			for i in range(self.tableColonnes.columnCount()):
				self.tableColonnes.setItem(row-1,i,self.tableColonnes.takeItem(row+1,i))
				self.tableColonnes.setCurrentCell(row-1,column)
			self.tableColonnes.removeRow(row+1)        
		self.tableColonnes.resizeRowsToContents()
		
	def remplissage_GLOBAL_mon_tuple_de_tuple_des_configs(self):
		global GLOBAL_mon_tuple_de_tuple_des_configs
		if mode_debuggage == 'oui': print "\ndef remplissage_GLOBAL_mon_tuple_de_tuple_des_configs"
		#if mode_debuggage == 'oui': print	self.table_liste_des_configs
		
		mon_ftp = class_FTP_ou_SFTP()
		id=mon_ftp.FTP_ou_SFTP()
		
		cur=id.cursor()
		cur.execute("select * from %s ORDER BY 1 ASC" % self.table_liste_des_configs)
		#cur.execute("select * from %s order by affaire_QLE" % mysql_Nom_de_table)
		#cur.execute("SELECT COLUMN_NAME, COLUMN_TYPE, IS_NULLABLE, COLUMN_KEY, COLUMN_DEFAULT, COLUMN_COMMENT FROM INFORMATION_SCHEMA.COLUMNS WHERE table_name = '%s'" % mysql_Nom_de_table)
		GLOBAL_mon_tuple_de_tuple_des_configs = list(cur.fetchall())
		cur.close()
		
		id.commit()
		id.close()
		
		
		#if mode_debuggage == 'oui': print GLOBAL_mon_tuple_de_tuple_des_configs #toutes la base est dedans
		#if mode_debuggage == 'oui': print "%d lignes\n" % cur.rowcount
		
		if mode_debuggage == 'oui': print "Remplissage Qscroll Area de fenetre"
		nb_total_champs = len(GLOBAL_mon_tuple_de_tuple_des_configs)
		#if mode_debuggage == 'oui': print nb_total_champs
		
		self.listConfig.clear()
		for elem in GLOBAL_mon_tuple_de_tuple_des_configs:
			monItem = QtGui.QListWidgetItem(elem[0])
			self.listConfig.addItem(monItem)
		
		
		if GLOBAL_config_actuelle_finale != "" or GLOBAL_config_actuelle_finale != "_":
			#http://stackoverflow.com/questions/4629584/pyqt4-how-do-you-iterate-all-items-in-a-qlistwidget
			mon_mes_items = self.listConfig.findItems(GLOBAL_config_actuelle_finale, QtCore.Qt.MatchFlags())
			for piti_item in mon_mes_items:
				self.listConfig.setCurrentItem(piti_item)
				self.listConfig.scrollToItem(piti_item)
		
	def selection_item2(self): 
		if self.listConfig.currentRow() != -1:
			self.bouton_modifier.setEnabled(True)
			self.bouton_supprimer.setEnabled(True)
			self.bouton_defaut.setEnabled(True)
		
		if mode_debuggage == 'oui': print "selection_item2 - num_ligne_item_actuel"
		#if mode_debuggage == 'oui': print monqlistwidgetitem.text()
		#if mode_debuggage == 'oui': print GLOBAL_mon_tuple_de_tuple_des_configs
		
		if mode_debuggage == 'oui': print "selection_item2 - self.tableColonnes.rowCount()"
		if mode_debuggage == 'oui': print self.tableColonnes.rowCount()
		if mode_debuggage == 'oui': print ""
		if mode_debuggage == 'oui': print ""
		if mode_debuggage == 'oui': print "selection_item2 - GLOBAL_mon_tuple_de_tuple_ORIGINAL"
		#if mode_debuggage == 'oui': print len(GLOBAL_mon_tuple_de_tuple_ORIGINAL)
		#if mode_debuggage == 'oui': print GLOBAL_mon_tuple_de_tuple_ORIGINAL
		
		#on actualise le text dans le lineEdit du haut ou réciproquement
		try:
			mon_text_actuel = self.listConfig.currentItem().text()
			self.lineEdit.setText(mon_text_actuel)
		except:
			mon_text_actuel = self.lineEdit.text()
			
		for i in range (self.tableColonnes.rowCount()):
			self.tableColonnes.removeRow(0)
		
		correspondance = "non"
		
		for elem in GLOBAL_mon_tuple_de_tuple_des_configs:
			if elem[0] == mon_text_actuel and elem[3] != None:
				if mode_debuggage == 'oui': print "selection_item2 - correspondance ok"
				correspondance = "oui"
				if elem[1] == "":
					self.lineEdit_info.setText('Liste non enregistrée')
				else:
					self.lineEdit_info.setText('Liste enregistrée')
		
		
		ligne_config_actuelle = self.listConfig.currentRow()
		if	correspondance == "non" or ligne_config_actuelle == -1:
			if mode_debuggage == 'oui': print "selection_item2 - correspondance: non ou bien ligne a -1"
			self.lineEdit_info.setText('Liste non enregistrée')
			self.tableColonnes.clear()
			i=0
			for element in (GLOBAL_mon_tuple_de_tuple_ORIGINAL):
				#if element[5] != None:
				self.tableColonnes.insertRow(self.tableColonnes.rowCount())  #insere ligne à la dernière ligne
				self.tableColonnes.setItem(self.tableColonnes.rowCount()-1,0,QtGui.QTableWidgetItem((unicode(i))))
				self.tableColonnes.setItem(self.tableColonnes.rowCount()-1,1,QtGui.QTableWidgetItem((element[6])))
				i=i+1
		
			self.tableColonnes.removeRow(0) #suppression de la première ligne INDEX
			
		elif correspondance == "oui" and ligne_config_actuelle != -1:
			if mode_debuggage == 'oui': print "selection_item2 - correspondance: oui"
			
			list_ordre_de_transposition = eval(GLOBAL_mon_tuple_de_tuple_des_configs[ligne_config_actuelle][3])
			if mode_debuggage == 'oui': print ("selection_item2 - ligne_config_actuelle:  %s" % (ligne_config_actuelle))
			if mode_debuggage == 'oui': print "selection_item2 - list_ordre_de_transposition- taille: %s" % (len(list_ordre_de_transposition))
			if mode_debuggage == 'oui': print list_ordre_de_transposition
			
			mon_transpose = Transposition_selon_ordre()
			#mon_transpose.transpose_list_multiple(self,debut_list_taille_quelconque,list_ordre_simple)
			matrice_transposee = mon_transpose.transpose_list_multiple(GLOBAL_mon_tuple_de_tuple_ORIGINAL,list_ordre_de_transposition,mon_text_actuel)
			#matrice_transposee contient en 0 le GLOBAL_mon_tuple_de_tuple_ORIGINAL dans le bon ordre, et en 1 le list_ordre_de_transposition rallongé ou raccourci
			self.tableColonnes.clear()
			i=0
			for element in (matrice_transposee[0]):
				#if element[5] != None:
				self.tableColonnes.insertRow(self.tableColonnes.rowCount())  #insere ligne à la dernière ligne
				self.tableColonnes.setItem(self.tableColonnes.rowCount()-1,0,QtGui.QTableWidgetItem(unicode(matrice_transposee[1][i])))
				self.tableColonnes.setItem(self.tableColonnes.rowCount()-1,1,QtGui.QTableWidgetItem((element[6])))
				i=i+1
			
			self.tableColonnes.removeRow(0) #suppression de la première ligne INDEX
			
		
		monheaderH = self.tableColonnes.horizontalHeader()
		monheaderH.hide()
		monheaderV = self.tableColonnes.verticalHeader()
		monheaderV.hide()
		self.tableColonnes.resizeColumnsToContents()
		self.tableColonnes.resizeRowsToContents()
		
		#empêche l'édition du tableau - éditable
		self.tableColonnes.setItemDelegate(QtGui.QItemDelegate(self.tableColonnes))
		toto = QtGui.QAbstractItemView.NoEditTriggers
		self.tableColonnes.setEditTriggers(toto)
		
		#sélection de la ligne au lieu de la cellule cliquée
		titi = QtGui.QAbstractItemView.SelectRows 
		self.tableColonnes.setSelectionBehavior(titi)
		
		#désactive la sélection multiple
		self.tableColonnes.setSelectionMode(QtGui.QAbstractItemView.SingleSelection) #désactive la sélection multiple
				
class Ui_MainWindow_surclasse(Ui_MainWindow): #surclasse? le fichier Mainwindow.form en provenance de Qt
	#MainWindow = QtGui.QMainWindow()
	#mon_form = Ui_MainWindow_surclasse()    # Ton interface,
	#mon_form.setupUi2(MainWindow)
	
	def close_Event(self, event):
		if mode_debuggage == 'oui': print "je ferme directement"	
		
	def setupUi2(self,Form):
		"""Ajoutons ce qu'il manque à la fenêtre"""
		self.ma_fenetreMain = Form #promotion: permet de monter d'un cran la fenetre et de l'utiliser ailleurs
		Ui_MainWindow.setupUi(self, self.ma_fenetreMain) # on charge la fenetre en provenance de modélisation via Qt
		QtCore.QObject.connect(self.qpush_rechercher,QtCore.SIGNAL("clicked()"),self.rechercher)
		QtCore.QObject.connect(self.qpush_effacer,QtCore.SIGNAL("clicked()"),self.effacer)
		QtCore.QObject.connect(self.qpush_nouveau,QtCore.SIGNAL("clicked()"),self.FICHE_nouveau)
		QtCore.QObject.connect(self.qpush_modifier,QtCore.SIGNAL("clicked()"),self.FICHE_modifier)
		QtCore.QObject.connect(self.qpush_supprimer,QtCore.SIGNAL("clicked()"),self.FICHE_supprimer)
		QtCore.QObject.connect(self.lineEdit_rapide,QtCore.SIGNAL("textEdited(const QString&)"),self.recherche_rapide)
		self.ma_fenetreMain.closeEvent = self.close_Event
		
		QtCore.QObject.connect(self.CBBX_archives_ou_affaires,QtCore.SIGNAL("currentIndexChanged(int)"),self.pre_recherche_rapide)
		
		self.lineEdit_rapide.setToolTip("Recherche rapide ne tenant pas compte du tableau de paramètres de tri")
		self.lineEdit_rapide.setStatusTip("youpi defure")
		
		QtCore.QObject.connect(self.lineEdit_rapide,QtCore.SIGNAL("returnPressed()"),self.pre_recherche_rapide)

		self.qpush_valider_nouveau = QtGui.QPushButton(self.groupBox)
		self.qpush_valider_nouveau.setText(QtGui.QApplication.translate("MainWindow", "Valider nouveau", None, QtGui.QApplication.UnicodeUTF8))
		self.qpush_valider_nouveau.setObjectName(_fromUtf8("qpush_modifier"))
		self.verticalLayout_8.addWidget(self.qpush_valider_nouveau)
		#QtCore.QObject.connect(self.qpush_valider_nouveau,QtCore.SIGNAL("clicked()"),self.FICHE_valider_nouveau_ou_modif('nouveau'))
		QtCore.QObject.connect(self.qpush_valider_nouveau,QtCore.SIGNAL("clicked()"),self.FICHE_valider_nouveau_ou_modif)
		
		self.qpush_valider_modif = QtGui.QPushButton(self.groupBox)
		self.qpush_valider_modif.setText(QtGui.QApplication.translate("MainWindow", "Valider modif", None, QtGui.QApplication.UnicodeUTF8))
		self.qpush_valider_modif.setObjectName(_fromUtf8("qpush_modifier"))
		self.verticalLayout_8.addWidget(self.qpush_valider_modif)
		QtCore.QObject.connect(self.qpush_valider_modif,QtCore.SIGNAL("clicked()"),self.FICHE_valider_modif)

		self.qpush_annuler = QtGui.QPushButton(self.groupBox)
		self.qpush_annuler.setText(QtGui.QApplication.translate("MainWindow", "Annuler", None, QtGui.QApplication.UnicodeUTF8))
		self.qpush_annuler.setObjectName(_fromUtf8("qpush_modifier"))
		self.verticalLayout_8.addWidget(self.qpush_annuler)
		
		QtCore.QObject.connect(self.qpush_annuler,QtCore.SIGNAL("clicked()"),self.FICHE_annuler)
		
		
		
		
		#visu
		self.qpush_nouveau.show()
		self.qpush_modifier.show()
		self.qpush_supprimer.show()
		self.qpush_valider_nouveau.hide()
		self.qpush_valider_modif.hide()
		self.qpush_annuler.hide()

		#tableau résultat
		QtCore.QObject.connect(self.qtableWidget_resultat,QtCore.SIGNAL("cellDoubleClicked(int,int)"),self.ouvrir_explorateur)
	#	QtCore.QObject.connect(self.qtableWidget_resultat,QtCore.SIGNAL("cellClicked(int,int)"),self.RESULTAT_cell_clickee)
	#	QtCore.QObject.connect(self.qtableWidget_resultat,QtCore.SIGNAL("currentCellChanged(int,int,int,int)"),self.RESULTAT_cell_clickee)

		#q radio par défaut
		self.type_de_recherche.addItem("valident toutes")
		self.type_de_recherche.addItem("valident au moins une")

		#TABLEAU DES PARAMETRES
		self.qtableWidget_param.setColumnCount(5)
		self.qtableWidget_param.setColumnWidth(1,110)
		self.qtableWidget_param.setColumnWidth(2,50)
		self.qtableWidget_param.setColumnWidth(3,30)
		self.qtableWidget_param.setColumnWidth(4,30)


		#tableau de tri
		monheaderview = self.qtableWidget_param.horizontalHeader()
		monheaderview.setResizeMode(0, QtGui.QHeaderView.Stretch) 
		monheaderview.setResizeMode(1, QtGui.QHeaderView.Fixed) 
		monheaderview.setResizeMode(2, QtGui.QHeaderView.Stretch) 
		monheaderview.setResizeMode(3, QtGui.QHeaderView.Fixed) 
		monheaderview.setResizeMode(4, QtGui.QHeaderView.Fixed) 

		mon_header = self.qtableWidget_param.horizontalHeader()
		mon_header.hide()
		mon_header2 = self.qtableWidget_param.verticalHeader()
		mon_header2.hide()

		#ma_barre_policy_vertical = QtCore.Qt.ScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
		#form.tableWidget_resultat1.setVerticalScrollBarPolicy(ma_barre_policy_vertical)
		
		###imprimer
		#menu barre du haut
		#menu
		self.actionImprimer = QtGui.QMenu()
		self.actionImprimer.setEnabled(True)
		self.actionImprimer.setTitle(_fromUtf8("Imprimer"))
		#QtCore.QObject.connect(self.actionImprimer, QtCore.SIGNAL(_fromUtf8('triggered(QAction *)')), self.MENU_BAR_fonction_imprimer) #très malin, c'esl Qmenu et non pas le Qaction qui créé le signal!!!
		self.menubar.addMenu(self.actionImprimer)
		
		
		separateur_debug = QtGui.QAction(self.menubar)
		QtCore.QObject.connect(separateur_debug, QtCore.SIGNAL(_fromUtf8('triggered()')), self.fonction_activer_debug)
		separateur_debug.setSeparator(True)
		self.menubar.addAction(separateur_debug)
		#separateur_debug.setShortcut('Ctrl+D+E+B+U+G')
		separateur_debug.setShortcut(QtGui.QKeySequence(QtCore.Qt.CTRL + QtCore.Qt.Key_B,QtCore.Qt.CTRL + QtCore.Qt.Key_U,QtCore.Qt.CTRL + QtCore.Qt.Key_G))
		
		
		
		#sous-menu actionImprimer
		connexions  = QtGui.QAction(unicode("Tableaux de références","iso-8859-1"), self.actionImprimer)
		connexions.setEnabled(True)
		QtCore.QObject.connect(connexions, QtCore.SIGNAL(_fromUtf8('triggered()')),  self.impression_references)
		self.actionImprimer.addAction(connexions)
		
		connexions  = QtGui.QAction(unicode("Tableaux utilisateurs","iso-8859-1"), self.actionImprimer)
		connexions.setEnabled(True)
		QtCore.QObject.connect(connexions, QtCore.SIGNAL(_fromUtf8('triggered()')),  self.impression_utilisateurs)
		self.actionImprimer.addAction(connexions)
		
		connexions  = QtGui.QAction(unicode("Tableaux à l'identique","iso-8859-1"), self.actionImprimer)
		connexions.setEnabled(True)
		QtCore.QObject.connect(connexions, QtCore.SIGNAL(_fromUtf8('triggered()')),  self.impression_a_l_identique)
		self.actionImprimer.addAction(connexions)
		
	
		
	
		
		
		##parametre
		
		#menu actionParametres
		self.actionParametres = QtGui.QMenu()
		self.actionParametres.setEnabled(True)
		mon_titre = "Paramètres"
		mon_titre2 = unicode(mon_titre, "iso-8859-1")
		self.actionParametres.setTitle(mon_titre2)
		#QtCore.QObject.connect(self.actionParametres, QtCore.SIGNAL(_fromUtf8('triggered(QAction *)')), self.MENU_BAR_fonction_parametres) #très malin, c'esl Qmenu et non pas le Qaction qui créé le signal!!!
		self.menubar.addMenu(self.actionParametres)
		
		
		
		#sous-menu actionParametres	
		self.selection_config = QtGui.QMenu()
		self.selection_config.setEnabled(True)
		self.selection_config.setTitle(unicode("Configurations","iso-8859-1"))
		QtCore.QObject.connect(self.selection_config, QtCore.SIGNAL(_fromUtf8('triggered(QAction *)')), self.actions_du_sous_menu) 
		#très malin, c'esl Qmenu et non pas le Qaction qui créé le signal!!!
		self.actionParametres.addMenu(self.selection_config)
		self.SOUS_MENU_BAR_configurations()
		
		connexions  = QtGui.QAction("Connexions", self.actionParametres)
		connexions.setEnabled(True)
		QtCore.QObject.connect(connexions, QtCore.SIGNAL(_fromUtf8('triggered()')), self.fenetre_gestion_connexions)
		self.actionParametres.addAction(connexions)
		
		##point d'interrogation
		#menu action_pt_interrogation
		self.action_pt_interrogation = QtGui.QMenu()
		self.action_pt_interrogation.setEnabled(True)
		mon_titre = "?"
		mon_titre2 = unicode(mon_titre, "iso-8859-1")
		self.action_pt_interrogation.setTitle(mon_titre2)
		#QtCore.QObject.connect(self.action_pt_interrogation, QtCore.SIGNAL(_fromUtf8('triggered(QAction *)')), self.MENU_BAR_fonction_parametres) #très malin, c'esl Qmenu et non pas le Qaction qui créé le signal!!!
		self.menubar.addMenu(self.action_pt_interrogation)
		
		#sous-menu action_pt_interrogation
		connexions  = QtGui.QAction("A propos", self.action_pt_interrogation)
		connexions.setEnabled(True)
		QtCore.QObject.connect(connexions, QtCore.SIGNAL(_fromUtf8('triggered()')), self.fenetre_version)
		self.action_pt_interrogation.addAction(connexions)
		
		
		##autres
		#statusBar dans mon_form
		ma_var1 = 'Config: '
		ma_var_tot = ma_var1 + GLOBAL_config_actuelle_finale
		self.mon_Qlabel_status_bar = QtGui.QLabel()
		self.mon_Qlabel_status_bar.setObjectName("mon_status_config")
		self.mon_Qlabel_status_bar.setText(ma_var_tot)
		self.statusbar.addPermanentWidget(self.mon_Qlabel_status_bar) #removeWidget()
		
		#self.statusbar.showMessage('nom de la config')
		self.mon_Qlabel_status_bar2 = QtGui.QLabel()
		self.mon_Qlabel_status_bar2.setText(unicode("Lignes trouvées: ", "iso-8859-1"))
		self.statusbar.addPermanentWidget(self.mon_Qlabel_status_bar2)
		
		
		#self.statusbar.showMessage('nom de la config')
		self.mon_Qlabel_status_bar3 = QtGui.QLabel()
		self.mon_Qlabel_status_bar3.setText(unicode("Affaire: "))
		self.statusbar.addWidget(self.mon_Qlabel_status_bar3)
		
		#archives check box
		self.CBBX_archives_ou_affaires.hide()
		self.label_recherche_sur.hide()
		self.CBBX_archives_ou_affaires.addItem("Affaires et concours seuls")
		self.CBBX_archives_ou_affaires.setItemData(0, "Affaires et concours seuls", QtCore.Qt.ToolTipRole)
		self.CBBX_archives_ou_affaires.addItem("Affaires archivées seules")
		self.CBBX_archives_ou_affaires.setItemData(1, "Affaires archivées seules", QtCore.Qt.ToolTipRole)
		self.CBBX_archives_ou_affaires.addItem("Tout y compris archives")
		self.CBBX_archives_ou_affaires.setItemData(2, "Tout y compris archives", QtCore.Qt.ToolTipRole)
		
		#clic droit dans qtableWidget_resultat
		self.qtableWidget_resultat.setContextMenuPolicy(QtCore.Qt.ActionsContextMenu)
	
		self.action_droit_unique = QtGui.QAction(unicode('Mode sélection unique (mode par défaut)',"iso-8859-1"), self.qtableWidget_resultat)
		#exec("action10.setIcon(QtGui.QIcon(_fromUtf8('%s%s')))" % (chemin_icone, "/Circ1.png"))
		QtCore.QObject.connect(self.action_droit_unique, QtCore.SIGNAL(_fromUtf8('triggered()')), self.fonction_action_droit_unique)
		self.qtableWidget_resultat.addAction(self.action_droit_unique)
		self.action_droit_unique.setEnabled(False)
		
		self.action_droit_multiple = QtGui.QAction(unicode('Mode modification multiple',"iso-8859-1"), self.qtableWidget_resultat)
		#exec("action10.setIcon(QtGui.QIcon(_fromUtf8('%s%s')))" % (chemin_icone, "/Circ1.png"))
		QtCore.QObject.connect(self.action_droit_multiple, QtCore.SIGNAL(_fromUtf8('triggered()')), self.fonction_action_droit_multiple)
		self.qtableWidget_resultat.addAction(self.action_droit_multiple)
		self.action_droit_multiple.setEnabled(True)
		
		#INITIALISATION ET CHARGEMENT
		self.initialisation_et_chargement()
		if mode_debuggage == 'oui': print "zaza39"
	
	def fonction_activer_debug(self):
		print "bug-debug"
		global mode_debuggage
		
		if mode_debuggage == "oui":
			mode_debuggage = "non"
			titre = _fromUtf8("Mode Normal - mode debuggage")
			texte_avertissement = _fromUtf8("MODE NORMAL ACTIF")
			QtGui.QMessageBox.warning(None, titre,texte_avertissement, QtGui.QMessageBox.Ok)
		elif mode_debuggage == "non":
			mode_debuggage = "oui"
			titre = _fromUtf8("Mode Normal - mode debuggage")
			texte_avertissement = _fromUtf8("MODE DEBUGGAGE ACTIF")
			QtGui.QMessageBox.warning(None, titre,texte_avertissement, QtGui.QMessageBox.Ok)
	
	
	def fonction_action_droit_unique(self):
		global GLOBAL_modif_unique_ou_multiple
		if mode_debuggage == 'oui': print "def fonction_action_droit_unique"
		if self.qtableWidget_resultat.rowCount() > 0:
			GLOBAL_modif_unique_ou_multiple = "unique"
			self.action_droit_unique.setEnabled(False)
			self.action_droit_multiple.setEnabled(True)
			
			self.qpush_valider_nouveau.setText(QtGui.QApplication.translate("MainWindow", "Valider nouveau", None, QtGui.QApplication.UnicodeUTF8))
			
			#on reconnecte la relation tableau resultat et SCROLL de droite
			QtCore.QObject.disconnect(self.qtableWidget_resultat,QtCore.SIGNAL("cellClicked(int,int)"),self.RESULTAT_cell_clickee)
			QtCore.QObject.disconnect(self.qtableWidget_resultat,QtCore.SIGNAL("currentCellChanged(int,int,int,int)"),self.RESULTAT_cell_clickee)
			QtCore.QObject.connect(self.qtableWidget_resultat,QtCore.SIGNAL("cellClicked(int,int)"),self.RESULTAT_cell_clickee)
			QtCore.QObject.connect(self.qtableWidget_resultat,QtCore.SIGNAL("currentCellChanged(int,int,int,int)"),self.RESULTAT_cell_clickee)
			
			noir = QtGui.QColor("black")
			blanc = QtGui.QColor("white")
			gris = QtGui.QColor("gray")
			gris_clair = QtGui.QColor(173,216,230) #bleu acier
			mapalette_modif_unique = QtGui.QPalette()
			mapalette_modif_unique.setColor(QtGui.QPalette.Text, noir)
			mapalette_modif_unique.setColor(QtGui.QPalette.Base, blanc)
			
			
			for num_ligne in range(1,self.mon_grid_area.rowCount()):
				mon_widget_col_1 = self.mon_grid_area.itemAtPosition(num_ligne,1).widget()
				mon_label_col_0 = self.mon_grid_area.itemAtPosition(num_ligne,0).widget()
				
				mon_widget_col_1.setPalette(mapalette_modif_unique)
				mon_widget_col_1.setEnabled(False)
			
			#active la sélection unique
			self.qtableWidget_resultat.setSelectionMode(QtGui.QAbstractItemView.SingleSelection) #désactive la sélection multiple
			self.qtableWidget_resultat.setCurrentCell(self.qtableWidget_resultat.currentRow(),0)
			self.qtableWidget_resultat.scrollToItem(self.qtableWidget_resultat.currentItem())
			
			self.FICHE_annuler()
			
			
	def fonction_action_droit_multiple(self):
		global GLOBAL_modif_unique_ou_multiple
		if mode_debuggage == 'oui': print "def fonction_action_droit_multiple"
		if self.qtableWidget_resultat.rowCount() > 0:
			GLOBAL_modif_unique_ou_multiple = "multiple"
			self.action_droit_unique.setEnabled(True)
			self.action_droit_multiple.setEnabled(False)
			
			self.qpush_valider_nouveau.setText(QtGui.QApplication.translate("MainWindow", "Valider Modif Multiple", None, QtGui.QApplication.UnicodeUTF8))
			
			self.FICHE_nouveau() #on simule un clic sur nouveau
			
			self.qtableWidget_resultat.setEnabled(True)
			
			#le nom dans le mainwindow
			exec("MainWindow.setWindowTitle(_fromUtf8('%s_%s - %s'))" % (GLOBAL_nom_programme, GLOBAL_version_programme, "mode multiple"))
			
			#active la sélection multiple
			self.qtableWidget_resultat.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection) #active la sélection multiple
			
			
			#on déconnecte la relation tableau resultat et SCROLL de droite
			QtCore.QObject.disconnect(self.qtableWidget_resultat,QtCore.SIGNAL("cellClicked(int,int)"),self.RESULTAT_cell_clickee)
			QtCore.QObject.disconnect(self.qtableWidget_resultat,QtCore.SIGNAL("currentCellChanged(int,int,int,int)"),self.RESULTAT_cell_clickee)
			
			noir = QtGui.QColor("black")
			blanc = QtGui.QColor("white")
			gris = QtGui.QColor("gray")
			gris_clair = QtGui.QColor(173,216,230) #bleu acier
			mapalette_modif_multiple = QtGui.QPalette()
			#mapalette_modif_multiple.setColor(QtGui.QPalette.Text, blanc)
			mapalette_modif_multiple.setColor(QtGui.QPalette.Base, gris)
			
			
			for num_ligne in range(1,self.mon_grid_area.rowCount()):
				mon_widget_col_1 = self.mon_grid_area.itemAtPosition(num_ligne,1).widget()
				mon_label_col_0 = self.mon_grid_area.itemAtPosition(num_ligne,0).widget()
				
				mon_widget_col_1.setPalette(mapalette_modif_multiple)
				mon_widget_col_1.setEnabled(False)
				
			####message
			#qmessagebox
			texte_titre = "Mode modification multiple"
			msg_debut = unicode("Attention, lors de la validation, tous les champs que vous aurez dégrisés en cliquant sur les libellés des champs du tableau de droite seront modifiés sur le serveur ! ", "iso-8859-1")		
			msg_total = msg_debut
			QtGui.QApplication.restoreOverrideCursor()
			QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
			ma_boite = QtGui.QMessageBox(MainWindow)
			ma_boite.setIcon(QtGui.QMessageBox.Information)
			ma_boite.setWindowTitle(texte_titre)
			ma_boite.setInformativeText(msg_total)
			#ma_boite.addButton(_fromUtf8("Ok"), 0)
			reponse = ma_boite.exec_()
			###
			
	
	def pre_recherche_rapide(self):
		if mode_debuggage == 'oui': print "zaza rapide enter"
		if self.lineEdit_rapide.text() != "":		
			self.rechercher() # on relance le boton rechercher
		
				

	def impression_references(self):
		global mon_dialog_pre_imprim
		
		mon_dialog_pre_imprim = QtGui.QDialog(MainWindow)
		impression = Fenetre_pre_impression_references()
		impression.setupUi_reference(mon_dialog_pre_imprim)
		mon_dialog_pre_imprim.setWindowModality(QtCore.Qt.NonModal) #fenetre non modale
		mon_dialog_pre_imprim.show()
		
	def impression_utilisateurs(self):
		if mode_debuggage == 'oui': print "impression_utilisateurs"
		
		printer = QtGui.QPrinter()
		printer.setPageMargins(10,10,10,10,0) #0 pour unité millimetre
		

		document=QtGui.QTextDocument()
		dialog = QtGui.QPrintDialog(printer)
		dialog.setModal(True)
		dialog.setWindowTitle("Coucou titre" )
		

	
		
		#on crée un curseur a l'endroit du curseur actuel
		cursor = QtGui.QTextCursor(document)
		#http://www.unixgarden.com/index.php/gnu-linux-magazine/qt-4-4-textes-enrichis-et-documents-structures
		#http://pyqt.sourceforge.net/Docs/PyQt4/qtextcursor.html#MoveOperation-enum
		
		##################  TABLEAU  #########"
	
		#on crée un block pour le tableau
		cursor.beginEditBlock()
	
		#Creation du format du tableau qui sera imprimer
		tableFormat = QtGui.QTextTableFormat()
		tableFormat.setAlignment(QtCore.Qt.AlignHCenter)
		#tableFormat.setAlignment(QtCore.Qt.AlignLeft)
		tableFormat.setBackground(QtGui.QColor("#ffffff")) #blanc
		tableFormat.setCellPadding(5)
		tableFormat.setCellSpacing(0)
		#tableFormat.setWidth(2000)
		#tableFormat.setLeftMargin(10) #marge dans le browser, grrrr
		#tableFormat.setRightMargin(10) #marge dans le browser, grrrr
		
		
		mon_list_de_QTextLength = []
		mon_list_de_QTextLength.append(QtGui.QTextLength(2,11)) #type, largeur type:  0:variable ,1:fixe ,2:percentage
		mon_list_de_QTextLength.append(QtGui.QTextLength(2,11)) #type, largeur type:  0:variable ,1:fixe ,2:percentage
		mon_list_de_QTextLength.append(QtGui.QTextLength(2,11)) #type, largeur type:  0:variable ,1:fixe ,2:percentage
		mon_list_de_QTextLength.append(QtGui.QTextLength(2,11)) #type, largeur type:  0:variable ,1:fixe ,2:percentage
		mon_list_de_QTextLength.append(QtGui.QTextLength(2,11)) #type, largeur type:  0:variable ,1:fixe ,2:percentage
		mon_list_de_QTextLength.append(QtGui.QTextLength(2,11)) #type, largeur type:  0:variable ,1:fixe ,2:percentage
		mon_list_de_QTextLength.append(QtGui.QTextLength(2,11)) #type, largeur type:  0:variable ,1:fixe ,2:percentage
		mon_list_de_QTextLength.append(QtGui.QTextLength(2,11)) #type, largeur type:  0:variable ,1:fixe ,2:percentage
		mon_list_de_QTextLength.append(QtGui.QTextLength(2,11)) #type, largeur type:  0:variable ,1:fixe ,2:percentage
		tableFormat.setColumnWidthConstraints(mon_list_de_QTextLength)
		
		
		
		#tableFormat.setPageBreakPolicy(tableFormat.PageBreak_AlwaysAfter) #page break - saut de page!!!! vis à vis du tableu: on lui indique d'insérer un saut de page toujours après le tableau!!
		tableFormat.setPageBreakPolicy(tableFormat.PageBreak_Auto)
		
		
		#Creation du tableau qui sera imprimé avec le nombre de colonne 
		#et de ligne que contient le tableau mis en parametre
		#exec("ui.tableWidget%s = QtGui.QTableWidget(ui.tab%s)" % (numero_circuit, numero_circuit))
		#QTextTable * tableau = cursor.insertTable(tableau_a_imprimer->rowCount()+1, tableau_a_imprimer->columnCount(), tableFormat);
		
		
		nb_ligne = mon_form.qtableWidget_resultat.rowCount()
		
	
		if mode_debuggage == 'oui': print "nb_ligne"
		if mode_debuggage == 'oui': print type(nb_ligne)
		if mode_debuggage == 'oui': print nb_ligne
		nb_colonne = 9
		
		#tableFormat.setPageBreakPolicy(tableFormat.PageBreak_Auto)
		tableau = cursor.insertTable(1, nb_colonne, tableFormat) #ici, tableau est un QTextTable
		
	
		frame = cursor.currentFrame()
		frameFormat = frame.frameFormat()
		frameFormat.setBorder(0)
		frame.setFrameFormat(frameFormat)
	
		#Format des HEADER du tableau
		format_entete_tableau = QtGui.QTextCharFormat() 
		format_entete_tableau.setFontPointSize(13)
		mon_QFont = QtGui.QFont()
		mon_QFont.setWeight(99) # gras ou moins gras
		format_entete_tableau.setFont(mon_QFont)
		format_entete_tableau.setFontItalic(True)
		
	
		#format_entete_tableau.setFontWeight(QFont::Bold);
	
		#on ecrit les HEADERS du tableaux CIRCUIT dans le tableau a imprimer
		Header = 1
		if Header == 1:
			list_text = []
			list_text.append("Nom de l'affaire")
			list_text.append("Donneur d'ordre")
			list_text.append("Responsable donneur d'ordre")
			list_text.append("Commentaires")
			list_text.append("Missions")
			list_text.append("Contenu mission")
			list_text.append("Montant H.T. des honoraires")
			list_text.append("Prochaine échéance")
			list_text.append("Type d'échéance")
			
			for col in range(nb_colonne):	
				#http://pyqt.sourceforge.net/Docs/PyQt4/qtexttablecellformat.html#details
				cellule = tableau.cellAt(0,col) #cellule
				cellCursor = cellule.firstCursorPosition() #cellCursor est un QTextCursor

				mon_blockformat = cellCursor.blockFormat()
				mon_alignement = QtCore.Qt.AlignHCenter
				#http://pyqt.sourceforge.net/Docs/PyQt4/qt.html#AlignmentFlag-enum
				mon_blockformat.setAlignment(mon_alignement)
				cellCursor.setBlockFormat(mon_blockformat)
				cellCursor.insertText(unicode(list_text[col], "iso-8859-1"),format_entete_tableau)
	
		#impression des données CIRCUIT dans le tableau		
		cursor.insertText("\n")
		
		
		
		matrice_colonne_a_imprimer = []
		matrice_colonne_a_imprimer.append(1)
		matrice_colonne_a_imprimer.append(18)
		matrice_colonne_a_imprimer.append(21)
		matrice_colonne_a_imprimer.append(22)
		matrice_colonne_a_imprimer.append(23)
		matrice_colonne_a_imprimer.append(33)
		matrice_colonne_a_imprimer.append(24)
		matrice_colonne_a_imprimer.append(25)
		matrice_colonne_a_imprimer.append(26)
		
		for row in range(1,(nb_ligne+1)):
		
			tableau.insertRows(row,1)
			for col in range(len(matrice_colonne_a_imprimer)):
			
				#http://pyqt.sourceforge.net/Docs/PyQt4/qtexttablecellformat.html#details
				cell = tableau.cellAt(row,col) #cellule est un QTextTableCell
				#cell.setLeftPadding(0) #marche pas
				cellCursor = cell.firstCursorPosition()
				
				
				for num_header in range(mon_form.qtableWidget_resultat.columnCount()):
					if num_header == matrice_colonne_a_imprimer[col]:				
						exec("ma_cellule = mon_form.qtableWidget_resultat.item(%s,%s).data(0).toString()" % (row-1,matrice_colonne_a_imprimer[col]))
						
						#if mode_debuggage == 'oui': print "mon_widget"
						#if mode_debuggage == 'oui': print type(ma_cellule)
						#if mode_debuggage == 'oui': print unicode(ma_cellule).encode("cp850")
						mon_blockformat = cellCursor.blockFormat()
						
						if col >= 3:
							mon_alignement = QtCore.Qt.AlignHCenter
						else:
							mon_alignement = QtCore.Qt.AlignLeft
						#http://pyqt.sourceforge.net/Docs/PyQt4/qt.html#AlignmentFlag-enum
						
						mon_blockformat.setAlignment(mon_alignement)
						cellCursor.setBlockFormat(mon_blockformat)
						
						cellCursor.insertText(ma_cellule)
						#cellCursor.insertText(ma_cellule.text())
				#doudouille
				#http://stackoverflow.com/questions/5187484/how-to-center-text-in-qtexttable
				

				
		#fin de l'edition
		cursor.endEditBlock()
		cursor.movePosition(cursor.End)
	
		############################################################
		############################################################
		############################################################
				
		if dialog.exec_() == True:
			printer.setOrientation(QtGui.QPrinter.Landscape) #grosse astuce, il faut définir l'orienttaion après que la fenetre de config soit fermée, sinon, ça prend en compte le paramètre de config impirmante de base
			
			#impression de notre editor dans le QPrinter initialisé au début de la fonction		
			document.print_(printer)
			
			print "printer.copyCount()"
			printer.copyCount()
			
	def impression_a_l_identique(self):
		print "impression_a_l_identique"
		
		printer = QtGui.QPrinter()
		printer.setPageMargins(10,10,10,10,0) #0 pour unité millimetre
		

		document=QtGui.QTextDocument()
		dialog = QtGui.QPrintDialog(printer)
		dialog.setModal(True)
		dialog.setWindowTitle("Coucou titre" )
		

	
		
		#on crée un curseur a l'endroit du curseur actuel
		cursor = QtGui.QTextCursor(document)
		#http://www.unixgarden.com/index.php/gnu-linux-magazine/qt-4-4-textes-enrichis-et-documents-structures
		#http://pyqt.sourceforge.net/Docs/PyQt4/qtextcursor.html#MoveOperation-enum
		
		##################  TABLEAU  #########"
	
		#on crée un block pour le tableau
		cursor.beginEditBlock()
	
		#Creation du format du tableau qui sera imprimer
		tableFormat = QtGui.QTextTableFormat()
		tableFormat.setAlignment(QtCore.Qt.AlignHCenter)
		#tableFormat.setAlignment(QtCore.Qt.AlignLeft)
		tableFormat.setBackground(QtGui.QColor("#ffffff")) #blanc
		tableFormat.setCellPadding(5)
		tableFormat.setCellSpacing(0)
		#tableFormat.setWidth(2000)
		#tableFormat.setLeftMargin(10) #marge dans le browser, grrrr
		#tableFormat.setRightMargin(10) #marge dans le browser, grrrr
		
		
		nb_colonnes_tableau = mon_form.qtableWidget_resultat.columnCount()
		
		grand_list_list = []
		
		somme_largeur_colonnes = 0
		for col in range(nb_colonnes_tableau):
			if  mon_form.qtableWidget_resultat.isColumnHidden(col) == False: #si colonne visible
				somme_largeur_colonnes = somme_largeur_colonnes + mon_form.qtableWidget_resultat.columnWidth(col)
			
			
			
		for col in range(nb_colonnes_tableau):
			if  mon_form.qtableWidget_resultat.isColumnHidden(col) == False: #si colonne visible	
		
				piti_list = [] #en 0: logical, #en 1: visual, #en 2: la taille en brut, #en3: la taille en %, #en 4 , le texte
				
				#en 0: logical
				piti_list.append(col)
				
				#en 1: visual
				num_colVL = mon_form.qtableWidget_resultat.visualColumn(col)
				piti_list.append(num_colVL)
				
				#en 2: la taille en brut
				piti_list.append(mon_form.qtableWidget_resultat.columnWidth(col))
				
				
				#en3: la taille en %,
				piti_list.append(QtGui.QTextLength(2,int(100*mon_form.qtableWidget_resultat.columnWidth(col)/somme_largeur_colonnes))) #type, largeur type:  0:variable ,1:fixe ,2:percentage	
				
				#en 4 , le texte
				piti_list.append(mon_form.qtableWidget_resultat.horizontalHeaderItem(col).text())
				
				grand_list_list.append(piti_list)
			
		if mode_debuggage == 'oui': print ""
		if mode_debuggage == 'oui': print "grand_list_list"
		if mode_debuggage == 'oui': print grand_list_list

		grand_list_reclasse = sorted(grand_list_list, key=lambda au_pif: au_pif[1]) #on classe suivant l'élement 1
		
		if mode_debuggage == 'oui': print ""
		if mode_debuggage == 'oui': print "grand_list_reclasse"
		if mode_debuggage == 'oui': print grand_list_reclasse
		
		mon_list_de_QTextLength = []
		for elem in grand_list_reclasse:
			mon_list_de_QTextLength.append(elem[3])
		
		tableFormat.setColumnWidthConstraints(mon_list_de_QTextLength) ################ NE PAS OUBLIER

		
		#tableFormat.setPageBreakPolicy(tableFormat.PageBreak_AlwaysAfter) #page break - saut de page!!!! vis à vis du tableu: on lui indique d'insérer un saut de page toujours après le tableau!!
		tableFormat.setPageBreakPolicy(tableFormat.PageBreak_Auto)
		
		
		#Creation du tableau qui sera imprimé avec le nombre de colonne 
		#et de ligne que contient le tableau mis en parametre
		#exec("ui.tableWidget%s = QtGui.QTableWidget(ui.tab%s)" % (numero_circuit, numero_circuit))
		#QTextTable * tableau = cursor.insertTable(tableau_a_imprimer->rowCount()+1, tableau_a_imprimer->columnCount(), tableFormat);
		
		
		nb_ligne = mon_form.qtableWidget_resultat.rowCount()
		
	
		if mode_debuggage == 'oui': print "nb_ligne"
		if mode_debuggage == 'oui': print type(nb_ligne)
		if mode_debuggage == 'oui': print nb_ligne
		nb_colonne = len(grand_list_list)
		
		#tableFormat.setPageBreakPolicy(tableFormat.PageBreak_Auto)
		tableau = cursor.insertTable(1, nb_colonne, tableFormat) #ici, tableau est un QTextTable
		
	
		frame = cursor.currentFrame()
		frameFormat = frame.frameFormat()
		frameFormat.setBorder(0)
		frame.setFrameFormat(frameFormat)
	
		#Format des HEADER du tableau
		format_entete_tableau = QtGui.QTextCharFormat() 
		format_entete_tableau.setFontPointSize(13)
		mon_QFont = QtGui.QFont()
		mon_QFont.setWeight(99) # gras ou moins gras
		format_entete_tableau.setFont(mon_QFont)
		format_entete_tableau.setFontItalic(True)
		
	
		#format_entete_tableau.setFontWeight(QFont::Bold);
	
		#on ecrit les HEADERS du tableaux CIRCUIT dans le tableau a imprimer
		Header = 1
		if Header == 1:
			#list_text = []
			#for col in range(nb_colonne):
			#	list_text.append("Nom de l'affaire")
			
			col = 0
			for elem in grand_list_reclasse:	
				#http://pyqt.sourceforge.net/Docs/PyQt4/qtexttablecellformat.html#details
				cellule = tableau.cellAt(0,col) #cellule
				cellCursor = cellule.firstCursorPosition() #cellCursor est un QTextCursor

				mon_blockformat = cellCursor.blockFormat()
				mon_alignement = QtCore.Qt.AlignHCenter
				#http://pyqt.sourceforge.net/Docs/PyQt4/qt.html#AlignmentFlag-enum
				mon_blockformat.setAlignment(mon_alignement)
				cellCursor.setBlockFormat(mon_blockformat)
				cellCursor.insertText(unicode(elem[4], "iso-8859-1"),format_entete_tableau)
				col = col + 1
		#impression des données CIRCUIT dans le tableau		
		cursor.insertText("\n")
		
	
		for row in range(1,(nb_ligne+1)):
		
			tableau.insertRows(row,1)
			col = 0
			#for col in range(len(matrice_colonne_a_imprimer)):
			for elem in grand_list_reclasse: #elem:  #en 0: logical, #en 1: visual, #en 2: la taille en brut, #en3: la taille en %, #en 4 , le texte
			
				#http://pyqt.sourceforge.net/Docs/PyQt4/qtexttablecellformat.html#details
				cell = tableau.cellAt(row,col) #cellule est un QTextTableCell
				#cell.setLeftPadding(0) #marche pas
				cellCursor = cell.firstCursorPosition()
				
				
				for num_header in range(mon_form.qtableWidget_resultat.columnCount()):
					if num_header == elem[0]:				
						exec("ma_cellule = mon_form.qtableWidget_resultat.item(%s,%s).data(0).toString()" % (row-1,elem[0]))
						
						if mode_debuggage == 'oui': print "mon_widget"
						if mode_debuggage == 'oui': print type(ma_cellule)
						if mode_debuggage == 'oui': print unicode(ma_cellule).encode("cp850")
						mon_blockformat = cellCursor.blockFormat()
						
						
						mon_alignement = QtCore.Qt.AlignHCenter
						#mon_alignement = QtCore.Qt.AlignLeft
						#http://pyqt.sourceforge.net/Docs/PyQt4/qt.html#AlignmentFlag-enum
						
						mon_blockformat.setAlignment(mon_alignement)
						cellCursor.setBlockFormat(mon_blockformat)
						
						cellCursor.insertText(ma_cellule)
						#cellCursor.insertText(ma_cellule.text())
				#doudouille
				#http://stackoverflow.com/questions/5187484/how-to-center-text-in-qtexttable
				col = col + 1

				
		#fin de l'edition
		cursor.endEditBlock()
		cursor.movePosition(cursor.End)
	
		############################################################
		############################################################
		############################################################
				
		if dialog.exec_() == True:
			printer.setOrientation(QtGui.QPrinter.Landscape) #grosse astuce, il faut définir l'orienttaion après que la fenetre de config soit fermée, sinon, ça prend en compte le paramètre de config impirmante de base
			
			#impression de notre editor dans le QPrinter initialisé au début de la fonction		
			document.print_(printer)
			
			print "printer.copyCount()"
			printer.copyCount()
			
	def concat_chemin(self, type_concours_affaire_etc, nom_affaire):
		
		#if mode_debuggage == 'oui': print "double_clic"
		#if mode_debuggage == 'oui': print "type_concours_affaire_etc"
		#if mode_debuggage == 'oui': print unicode(type_concours_affaire_etc).encode("CP850")
		
		#if mode_debuggage == 'oui': print "nom_affaire"
		#if mode_debuggage == 'oui': print unicode(nom_affaire).encode("CP850")
		
		mon_setting = QtCore.QSettings("Echologos", "Basaffaire")
		reg_con_chemin_affaires = mon_setting.value('chemins/chemin_affaires').toString()
		reg_con_chemin_archives = mon_setting.value('chemins/chemin_archives').toString()
		#if mode_debuggage == 'oui': print "reg_con_chemin_affaires"
		#if mode_debuggage == 'oui': print reg_con_chemin_affaires
		
		#Avancement:
		#concours
		#étude
		#chantier
		#concours à archiver
		#concours archivé
		#affaire à archiver
		#affaire archivée
		#expertise
		#expertise à archiver
		#expertise archivée
		#&#pas_de_mdp
		
		
		if type_concours_affaire_etc == "concours": ##YES!!!! à copier pour les autres cas!
			debut_chemin = os.path.normcase(str(reg_con_chemin_affaires)) #rajoute ou enleve les slash backslash suivant MAC, linux ou windows
			debut_chemin = os.path.join(str(debut_chemin), "Concours") #concatène le chemin
			
		elif type_concours_affaire_etc == "étude":
			debut_chemin = os.path.normcase(str(reg_con_chemin_affaires))
			debut_chemin = os.path.join(str(debut_chemin), "Affaires_en_cours")
			
		elif type_concours_affaire_etc == "chantier":
			debut_chemin = os.path.normcase(str(reg_con_chemin_affaires))
			debut_chemin = os.path.join(str(debut_chemin), "Affaires_en_cours")
			
		elif type_concours_affaire_etc == "concours à archiver":
			debut_chemin = os.path.normcase(str(reg_con_chemin_affaires))
			debut_chemin = os.path.join(str(debut_chemin), "Concours")
			
		elif type_concours_affaire_etc == "concours archivé":
			debut_chemin = os.path.normcase(str(reg_con_chemin_archives))
			debut_chemin = os.path.join(str(debut_chemin), "Concours_perdus")
			
		elif type_concours_affaire_etc == "affaire à archiver":
			debut_chemin = os.path.normcase(str(reg_con_chemin_affaires))
			debut_chemin = os.path.join(str(debut_chemin), "Affaires_en_cours")
			
		elif type_concours_affaire_etc == "affaire archivée":
			debut_chemin = os.path.normcase(str(reg_con_chemin_archives))
			debut_chemin = os.path.join(str(debut_chemin), "Affaires_archivees")
			
		elif type_concours_affaire_etc == "expertise":
			debut_chemin = os.path.normcase(str(reg_con_chemin_affaires))
			debut_chemin = os.path.join(str(debut_chemin), "Affaires_en_cours")
			
		elif type_concours_affaire_etc == "expertise à archiver":
			debut_chemin = os.path.normcase(str(reg_con_chemin_affaires))
			debut_chemin = os.path.join(str(debut_chemin), "Affaires_en_cours")
			
		elif type_concours_affaire_etc == "expertise archivée":
			debut_chemin = os.path.normcase(str(reg_con_chemin_archives))
			debut_chemin = os.path.join(str(debut_chemin), "Affaires_archivees")
		
		else: #si rien n'est précisé, alors archive
			debut_chemin = os.path.normcase(str(reg_con_chemin_archives))
			debut_chemin = os.path.join(str(debut_chemin), "Affaires_archivees")
		
		if debut_chemin[-1:] == "/" or debut_chemin[-1:] == "\\":
			debut_chemin = debut_chemin[:-1] #on vire le dernier slash ou antishlash s'il y en a un
		
		
		chemin = os.path.join(str(debut_chemin), str(nom_affaire))
		
		if mode_debuggage == 'oui': print "chemin concat"
		if mode_debuggage == 'oui': print chemin
		
		return chemin
	
	def ouvrir_explorateur(self,ligne,col):
		try:
			type_concours_affaire_etc = self.qtableWidget_resultat.item(ligne,15).data(0).toString()
			nom_affaire = self.qtableWidget_resultat.item(ligne,1).data(0).toString()
			
			
			chemin = self.concat_chemin(type_concours_affaire_etc, nom_affaire)
			
			
			##############
			import subprocess
			#import sys
			#path = 'C:\\pyth\\ventilo\\help_files\\images\\'  #double pour échapper le caractère
			#path = unicode("C:\\pyth\\compilation moteur", "ISO-8859-1")  #double pour échapper le caractère

			if sys.platform == 'darwin': #mac
				#chemin = unicode("/media/echogre1/Archives/Affaires", "ISO-8859-1")  #pas sûr que ça fonctionne...
				if mode_debuggage == 'oui': print "mac"
				subprocess.check_call(['open', '--', chemin])
					
			elif sys.platform == 'linux2': #linux
				#chemin = unicode("/media/echogre1/Archives/Affaires", "ISO-8859-1")  #double pour échapper le caractère
				if mode_debuggage == 'oui': print "linux"
				subprocess.check_call(['gnome-open',chemin]) ##ça marche !!!
						
			elif sys.platform == 'windows' or 'win32' or 'win64' or 'cygwin': #pas sûr pour win64 et cygwin...
				#chemin = unicode("\\\\Sme\\echogre1\\Archives\\Affaires", "ISO-8859-1") #encodage inutile ????
				if mode_debuggage == 'oui': print "windows"
				#subprocess.check_call(['explorer', path])
				#subprocess.Popen(r'explorer /e,"C:\pyth\ventilo\help_files\images\"') # YESSSS !!!!!!le paramètre /e permet d'ouvrir avec le splitter + ne pas mettre le /select 
				subprocess.Popen(r'explorer /e,%s'%(chemin)) # YESSSS !!!!!!le paramètre /e permet d'ouvrir avec le splitter + ne pas mettre le /select 

		except:
			#qmessagebox
			if mode_debuggage == 'oui': print "nom_affaire"
			if mode_debuggage == 'oui': print nom_affaire
			texte_titre = "Config en cours !"
			msg_debut = unicode("Affaire: \n ", "iso-8859-1")
			msg_debut2 = unicode(nom_affaire, "iso-8859-1") 
			msg_debut3 = unicode("\nImpossible d'ouvrir l'explorateur. Affaire non trouvée, ou bien mauvaise concordance entre le nom de l'affaire sur la base, et dans les fichiers Echologos\n", "iso-8859-1") 
 
			
			msg_total = msg_debut + msg_debut2 + msg_debut3
			QtGui.QApplication.restoreOverrideCursor()
			QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
			ma_boite = QtGui.QMessageBox(MainWindow)
			ma_boite.setIcon(QtGui.QMessageBox.Information)
			ma_boite.setWindowTitle(texte_titre)
			ma_boite.setInformativeText(msg_total)
			ma_boite.addButton(_fromUtf8("Ok"), 0)
			reponse = ma_boite.exec_()
			
	def fenetre_gestion_connexions(self):
		if mode_debuggage == 'oui': print "def fenetre_gestion_connexions"
		ma_fenetre_connection = QtGui.QDialog(MainWindow)
		connection = Fenetre_connexion()
		connection.setupUi2(ma_fenetre_connection)
		if mode_debuggage == 'oui': print "zaza40"
		ma_fenetre_connection.show()
		
	def fenetre_version(self):
		if mode_debuggage == 'oui': print "def fenetre_gestion_connexions"
		ma_fenetre_version = QtGui.QDialog(MainWindow)
		version = Fenetre_version()
		version.setupUi2(ma_fenetre_version)
		if mode_debuggage == 'oui': print "zaza41"
		ma_fenetre_version.show()
	
	def actions_du_sous_menu(self, action):
		if mode_debuggage == 'oui': print "actions_du_sous_menu"
		if mode_debuggage == 'oui': print type(action)
		ma_config = unicode(action.text())
		if mode_debuggage == 'oui': print ma_config
		
		if action == self.param_action1: #Sauvegarder visuel
			if mode_debuggage == 'oui': print "sauvegarder le visuel"
			self.sauvegarder_le_visuel()
		elif action == self.param_action2: #Gestion des configs
				config = Fenetre_CONFIG_UTILISATEUR_SQL_ajout_modif_suppression()
				config.creation_fenetre_config("preferences_utilisateurs")
			
	def sauvegarder_le_visuel(self):
		if mode_debuggage == 'oui': print "sauvegarde du visuel pour la config en cours"
		if GLOBAL_config_actuelle_finale != "_":
			if mode_debuggage == 'oui': print ""
			if mode_debuggage == 'oui': print "GLOBAL_config_actuelle_finale"
			if mode_debuggage == 'oui': print unicode(GLOBAL_config_actuelle_finale).encode("cp850")
			###  partie matrice_colonnes_resultat debut ###
			nb_colonne_resultat = self.qtableWidget_resultat.columnCount()
			if mode_debuggage == 'oui': print "nb_colonne_resultat"
			if mode_debuggage == 'oui': print nb_colonne_resultat
			if mode_debuggage == 'oui': print type(self.qtableWidget_resultat)
			
			mon_header = self.qtableWidget_resultat.horizontalHeader()
			matrice_colonnes_resultat = []
			t=0
			for num_col in range(mon_header.count()):
				if self.qtableWidget_resultat.isColumnHidden(num_col) == False: #colonne visible
					visible = "oui"
					colonne_largeur = self.qtableWidget_resultat.columnWidth(num_col)
				else:
					visible = "non"
					colonne_largeur = 100
					# ajouter dans matrice_colonnes_resultat

					#colonne_nom = self.qtableWidget_resultat.horizontalHeaderItem(num_col).text()
					
					
				visual_index = mon_header.visualIndex(num_col)
				#BUG VISUAL
				mon_list = []
				mon_list.append(num_col)  #logicalIndex !
				mon_list.append(visual_index)  #visual_index !
				
				mon_list.append(colonne_largeur) #largeur colonne
				mon_list.append(visible) #visible 01
				matrice_colonnes_resultat.append(mon_list)
		
			if mode_debuggage == 'oui': print "matrice_colonnes_resultat"
			if mode_debuggage == 'oui': print matrice_colonnes_resultat
			###  partie matrice_colonnes_resultat fin ###
			
			
			## partie matrice_ordre_parametres_de_tri  debut ##
			#on crée matrice_ordre_parametres_de_tri comme ceci:
			#0: nb_lignes dans la colonne list_ordre_tri_0
			#1,2,3,4,5,6: le numero de ligne correspondant pour les Order by 1 à 3 et ASC DESC
			#7 num ligne toutes les conditions ou bien une des conditions
			#8 et 
			# 9 nb de lignes de TRI dans le tableau 
			#ligne 10 à 25 maxi: LIST de stockage du numéro de ligne en colonne 0, en colonne 1 et text? en colonne 2
			matrice_ordre_parametres_de_tri = []
			matrice_ordre_parametres_de_tri.append(self.ordre_de_tri_1.count()) # 0 on prend en compte la ligne vide mais cela ne gène pas si on fait pareil à l'importation
			
			#if mode_debuggage == 'oui': print "self.TRI_mon_list_de_list_de_parametres_de_tri"
			#if mode_debuggage == 'oui': print self.TRI_mon_list_de_list_de_parametres_de_tri
			
			trouve_1 = 0
			for elem in range(len(self.TRI_mon_list_de_list_de_parametres_de_tri)):
				if self.TRI_mon_list_de_list_de_parametres_de_tri[elem][6] == self.ordre_de_tri_1.currentText():
					matrice_ordre_parametres_de_tri.append(self.TRI_mon_list_de_list_de_parametres_de_tri[elem][0]) #1
					trouve_1 = 1
			if trouve_1 == 0:
				matrice_ordre_parametres_de_tri.append('') #1
			
			matrice_ordre_parametres_de_tri.append(self.asc_desc_1.currentIndex()) #2
			
			trouve_2 = 0
			for elem in range(len(self.TRI_mon_list_de_list_de_parametres_de_tri)):
				if self.TRI_mon_list_de_list_de_parametres_de_tri[elem][6] == self.ordre_de_tri_2.currentText():
					matrice_ordre_parametres_de_tri.append(self.TRI_mon_list_de_list_de_parametres_de_tri[elem][0]) #3
					trouve_2 = 1
			if trouve_2 == 0:
				matrice_ordre_parametres_de_tri.append('') #3
			
			matrice_ordre_parametres_de_tri.append(self.asc_desc_2.currentIndex()) #4
			
			trouve_3 = 0
			for elem in range(len(self.TRI_mon_list_de_list_de_parametres_de_tri)):	
				if self.TRI_mon_list_de_list_de_parametres_de_tri[elem][6] == self.ordre_de_tri_3.currentText():
					matrice_ordre_parametres_de_tri.append(self.TRI_mon_list_de_list_de_parametres_de_tri[elem][0]) #5
					trouve_3 = 1
		
			if trouve_3 == 0:
				matrice_ordre_parametres_de_tri.append('') #3
				
			matrice_ordre_parametres_de_tri.append(self.asc_desc_3.currentIndex()) #6
			
			matrice_ordre_parametres_de_tri.append(self.type_de_recherche.currentIndex()) # 7 
			matrice_ordre_parametres_de_tri.append("") # 8 vide
			matrice_ordre_parametres_de_tri.append(self.qtableWidget_param.rowCount()) # 9 Nombre de lignes
			
			for ligne_tri in range(self.qtableWidget_param.rowCount()):
				piti_list=[]
				
				for elem in range(len(self.TRI_mon_list_de_list_de_parametres_de_tri)):	
					if self.TRI_mon_list_de_list_de_parametres_de_tri[elem][6] == self.qtableWidget_param.cellWidget(ligne_tri,0).currentText():
						piti_list.append(self.TRI_mon_list_de_list_de_parametres_de_tri[elem][0]) #1
				
				piti_list.append(self.qtableWidget_param.cellWidget(ligne_tri,1).currentIndex())
				
				monQLE = QtGui.QLineEdit()
				monQDE = QtGui.QDateEdit()
				monQCB = QtGui.QComboBox()
				#piti_list.append(self.qtableWidget_param.cellWidget(ligne_tri,2).currentIndex())
				if type(monQLE) == type(self.qtableWidget_param.cellWidget(ligne_tri,2)):
					piti_list.append(unicode(self.qtableWidget_param.cellWidget(ligne_tri,2).displayText()))
				elif type(monQCB) == type(self.qtableWidget_param.cellWidget(ligne_tri,2)):
					piti_list.append(unicode(self.qtableWidget_param.cellWidget(ligne_tri,2).currentText()))
				elif type(monQDE) == type(self.qtableWidget_param.cellWidget(ligne_tri,2)):
					piti_list.append(unicode(self.qtableWidget_param.cellWidget(ligne_tri,2).date().toString(QtCore.Qt.ISODate)))
				
				matrice_ordre_parametres_de_tri.append(piti_list) # 10 à 25 maxi
			
			
			
			if mode_debuggage == 'oui': print "matrice_ordre_parametres_de_tri"
			if mode_debuggage == 'oui': print matrice_ordre_parametres_de_tri
			
			## partie matrice_ordre_parametres_de_tri  fin ##
			
			
			
			
			mon_ftp = class_FTP_ou_SFTP()
			id=mon_ftp.FTP_ou_SFTP()
			
			
			cur=id.cursor()
			nb_ligne_modifiees = cur.execute("UPDATE preferences_utilisateurs SET ordre_parametres_de_tri=%s, ordre_col_tableau_resultat=%s WHERE (nom_utilisateur=%s)", \
			(unicode(matrice_ordre_parametres_de_tri), str(matrice_colonnes_resultat), unicode(GLOBAL_config_actuelle_finale)))
			cur.close()
			
			
			
			cur=id.cursor()
			test_select = cur.execute("SELECT * FROM preferences_utilisateurs WHERE (nom_utilisateur=%s)", \
			(unicode(GLOBAL_config_actuelle_finale)))
			nombre_trouve = len(list(cur.fetchall()))
			
			
			cur.close()
			
			
			id.commit()
			id.close()
			#if mode_debuggage == 'oui': print "test_select"
			#if mode_debuggage == 'oui': print test_select
			if nombre_trouve == 0:
				texte_titre = "Attention !"
				msg_total = "Paramètres non enregistrés. Vérifiez que la config en cours existe bien ou n'a pas été renommée récemment"
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Warning)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_total)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				reponse = ma_boite.exec_()
			
			else:
				if nb_ligne_modifiees == 0:
					texte_titre = "Paramètres visuels"
					msg_total = "Paramètres visuels déjà enregistrés (tableau de tri et tableau de résultat)"
					QtGui.QApplication.restoreOverrideCursor()
					QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
					ma_boite = QtGui.QMessageBox(MainWindow)
					ma_boite.setIcon(QtGui.QMessageBox.Information)
					ma_boite.setWindowTitle(texte_titre)
					ma_boite.setInformativeText(msg_total)
					ma_boite.addButton(_fromUtf8("Ok"), 0)
					reponse = ma_boite.exec_()
				
				else:
					texte_titre = "Paramètres visuels"
					msg_total = "Paramètres visuels enregistrés pour les deux tableaux de gauche (tableau de tri et tableau de résultat)"
					QtGui.QApplication.restoreOverrideCursor()
					QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
					ma_boite = QtGui.QMessageBox(MainWindow)
					ma_boite.setIcon(QtGui.QMessageBox.Information)
					ma_boite.setWindowTitle(texte_titre)
					ma_boite.setInformativeText(msg_total)
					ma_boite.addButton(_fromUtf8("Ok"), 0)
					reponse = ma_boite.exec_()
	
		else:
			texte_titre = "Pas de config définie"
			msg_total = "Vous devez d'abord créer une config"
			QtGui.QApplication.restoreOverrideCursor()
			QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
			ma_boite = QtGui.QMessageBox(MainWindow)
			ma_boite.setIcon(QtGui.QMessageBox.Warning)
			ma_boite.setWindowTitle(texte_titre)
			ma_boite.setInformativeText(msg_total)
			ma_boite.addButton(_fromUtf8("Ok"), 0)
			reponse = ma_boite.exec_()
		
		#enregistrer le self.splitter  et le self.splitter_2 et le Qmainwindow taille position
		mon_setting = QtCore.QSettings("Echologos", "Basaffaire")
		mon_setting.setValue('visuel/splitter', mon_form.splitter.saveState())
		mon_setting.setValue('visuel/splitter_2', mon_form.splitter_2.saveState())
		mon_setting.setValue('visuel/dimension_main_window', MainWindow.saveGeometry())
		
	def SOUS_MENU_BAR_configurations(self):
		self.param_action1 = QtGui.QAction(unicode("Sauvegarder visuel","iso-8859-1"), self.selection_config)
		self.param_action2 = QtGui.QAction(unicode("Gestion des configs","iso-8859-1"), self.selection_config)
		self.selection_config.addAction(self.param_action1)
		self.selection_config.addAction(self.param_action2)
		
	#########################"
	def initialisation_et_chargement(self):
		erreur_ou_pas = self.GLOBAL_gestion_variable_et_tableaux_globaux()
		if erreur_ou_pas == "erreur1": #permet le nouveal appel de la fonction 
			self.GLOBAL_gestion_variable_et_tableaux_globaux()
		self.SCROLL_remplissage_champs()
		self.RESULTAT_preparation_tableau()
		self.TRI_ordre_des_tris()
		
		
		##self.colonnes_visibles_et_taille_dans_resultat = [[0,200],[1,50],[5,100],[22,100]]
		
		if GLOBAL_config_actuelle_finale != "_": #si une config existe
		#	self.TRI_creation_ligne_dans_tableau_parametres_de_tri()
			self.TRI_chargement_des_lignes_utilisateur() #on crée toutes les lignes enregsitrées par l'utilisateur
		else:	#pas de config, on initialise en mettant une ligne par defaut
			self.TRI_creation_ligne_dans_tableau_parametres_de_tri() #création d'une ligne
			
		try:
			mon_setting = QtCore.QSettings("Echologos", "Basaffaire")
			qbite_splitter_1 = mon_setting.value('visuel/splitter')
			qbite_splitter_2 = mon_setting.value('visuel/splitter_2')
		
			self.splitter.restoreState(qbite_splitter_1.toByteArray())
			self.splitter_2.restoreState(qbite_splitter_2.toByteArray())
		except:
			toto = 2
		if mode_debuggage == 'oui': print "zoubida5"
	def GLOBAL_gestion_variable_et_tableaux_globaux(self):
		try:
			global GLOBAL_mon_tuple_de_tuple_ORIGINAL, GLOBAL_list_table_et_commentaires_tables, GLOBAL_config_actuelle_finale
			if mode_debuggage == 'oui': print "GLOBAL_config_actuelle_finaleZZZ"
			if mode_debuggage == 'oui': print unicode(GLOBAL_config_actuelle_finale).encode("cp850")
		
			mon_ftp = class_FTP_ou_SFTP()
			id=mon_ftp.FTP_ou_SFTP()
			
			cur=id.cursor()
			#cur.execute("select * from %s order by affaire_QLE" % mysql_Nom_de_table)
			cur.execute("SELECT COLUMN_NAME, COLUMN_TYPE, IS_NULLABLE, COLUMN_KEY, COLUMN_DEFAULT, COLUMN_COMMENT FROM INFORMATION_SCHEMA.COLUMNS WHERE table_name = '%s'" % mysql_Nom_de_table)
			mon_pre_tuple_de_tuple = list(cur.fetchall())
			cur.close()
			
			
			cur2=id.cursor()
			cur2.execute("SELECT * FROM information_schema.tables WHERE TABLE_TYPE = 'BASE TABLE'")
			ma_structure_de_premier_rang = list(cur2.fetchall())
			cur2.close()
			#if mode_debuggage == 'oui': print "ma_structure_de_premier_rang"
			#if mode_debuggage == 'oui': print ma_structure_de_premier_rang
			mon_tableau2D = []
			for ma_ligne in ma_structure_de_premier_rang:
				mon_micro_tableau = []
				mon_micro_tableau.append(ma_ligne[2])
				mon_micro_tableau.append(ma_ligne[20])
				
				mon_tableau2D.append(mon_micro_tableau)
			if mode_debuggage == 'oui': print ""
			if mode_debuggage == 'oui': print "mon_tableau2D"
			if mode_debuggage == 'oui': print mon_tableau2D
			GLOBAL_list_table_et_commentaires_tables = mon_tableau2D
			
			ma_matrice = []
			for elem in mon_pre_tuple_de_tuple:
				ma_liste = []
				champ_propre_tout_seul = []
				ma_liste = elem[5].split('#&#')
				champ_propre_tout_seul = (ma_liste[0].split('#-#'))
				
				monlist_elem = list(elem)
				monlist_elem.append(champ_propre_tout_seul[0])
				
				ma_matrice.append(tuple(monlist_elem))
				
			GLOBAL_mon_tuple_de_tuple_ORIGINAL = ma_matrice
			#grâce à la fonction ci-dessus, on rajoute en dernière colonne le commentaire tout seul !
			#if mode_debuggage == 'oui': print "\nGLOBAL_mon_tuple_de_tuple_ORIGINAL avec derniere colonne commentaire"
			#if mode_debuggage == 'oui': print GLOBAL_mon_tuple_de_tuple_ORIGINAL
			
			#TRANSPOSITION DES MATRICES
			if GLOBAL_config_actuelle_finale == "_": #si aucune config n'est encore définie alors on fixe les 3 matrices idem à ORIGINAL
				self.TRI_mon_list_de_list_de_parametres_de_tri = copy.deepcopy(GLOBAL_mon_tuple_de_tuple_ORIGINAL)
				self.TRI_mon_list_de_list_de_parametres_de_tri.sort(key=lambda x: x[6])
				self.RESULTAT_mon_list_de_list_de_colonne = copy.deepcopy(GLOBAL_mon_tuple_de_tuple_ORIGINAL)
				self.SCROLL_AREA_mon_list_de_list_de_champs = copy.deepcopy(GLOBAL_mon_tuple_de_tuple_ORIGINAL)
				
			elif GLOBAL_config_actuelle_finale != "_": #dans ce cas on récupère le nom de la config et on va choper les matrices d'invertion correspondantes
				if mode_debuggage == 'oui': print "GLOBAL_config_actuelle_finaleTT"
				if mode_debuggage == 'oui': print unicode(GLOBAL_config_actuelle_finale).encode("cp850")
				
				#mon_ftp = class_FTP_ou_SFTP() \ id=mon_ftp.FTP_ou_SFTP()		
				cur2=id.cursor()
				
				#cur2.execute("select * from preferences_utilisateurs where nom_utilisateur = %s" % (repr(str(GLOBAL_config_actuelle_finale))))
				cur2.execute("select * from preferences_utilisateurs where nom_utilisateur = %s order by nom_utilisateur", (unicode(GLOBAL_config_actuelle_finale)))

				self.ordre_Tri_Resultat_Scroll = list(cur2.fetchall())
				cur2.close()
				if len(self.ordre_Tri_Resultat_Scroll) == 0:
					texte_titre = "Problème de config"
					msg_debut = "Votre config par défaut est introuvable et a été supprimée par une personne tierce, retour sur configuration initiale"
					QtGui.QApplication.restoreOverrideCursor()
					QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
					ma_boite = QtGui.QMessageBox(MainWindow)
					ma_boite.setIcon(QtGui.QMessageBox.Warning)
					ma_boite.setWindowTitle(texte_titre)
					ma_boite.setInformativeText(msg_debut)
					ma_boite.addButton(_fromUtf8("Ok"), 0)
					reponse = ma_boite.exec_()
					GLOBAL_config_actuelle_finale = "_"
					mon_setting = QtCore.QSettings("Echologos", "Basaffaire")
					mon_setting.setValue('config_par_defaut/nom_config', str(GLOBAL_config_actuelle_finale))
					
					mon_form.setupUi2(MainWindow) #rechargment complet du tableau
					if mode_debuggage == 'oui': print ""
					if mode_debuggage == 'oui': print "relance de la fonction"
					return "erreur1" # le return bloque la suite de la fonction: on sort ici
					
				if mode_debuggage == 'oui': print ""
				if mode_debuggage == 'oui': print "self.ordre_Tri_Resultat_Scroll"
				#on envoie l'invertion de matrice sur tous les champs
			
			
				#la fonction EVAL sert à transformer un string en list et revient à faire:  mon_string[1:-1].split(',')
				#tableau
				nom_utilisateur = copy.copy(GLOBAL_config_actuelle_finale)
				#utiliset copy.deepcopy() quand on veut copier des list
				#http://au-bon-laboureur.blogspot.fr/2009/03/python-et-la-copie-de-listes-attention.html
				
				if mode_debuggage == 'oui': print "nom_utilisateur"
				if mode_debuggage == 'oui': print unicode(nom_utilisateur).encode("cp850")
				if mode_debuggage == 'oui': print type(nom_utilisateur)
				###fenetre de SCROLL AREA avec tous les champs
				if self.ordre_Tri_Resultat_Scroll[0][3] is not None:
					if mode_debuggage == 'oui': print "Fonction not none 3 "	
					if mode_debuggage == 'oui': print "taille GLOBAL_mon_tuple_de_tuple_ORIGINAL"
					if mode_debuggage == 'oui': print len(GLOBAL_mon_tuple_de_tuple_ORIGINAL)
					if mode_debuggage == 'oui': print "taille eval(self.ordre_Tri_Resultat_Scroll[0][3])"
					if mode_debuggage == 'oui': print len(eval(self.ordre_Tri_Resultat_Scroll[0][3]))
					mon_invertion = Transposition_selon_ordre()
					matrice2D = mon_invertion.transpose_list_multiple(GLOBAL_mon_tuple_de_tuple_ORIGINAL,eval(self.ordre_Tri_Resultat_Scroll[0][3]),nom_utilisateur)
					self.SCROLL_AREA_mon_list_de_list_de_champs = copy.deepcopy(matrice2D[0])
					self.TRI_mon_list_de_list_de_parametres_de_tri = copy.deepcopy(matrice2D[0])
					self.TRI_mon_list_de_list_de_parametres_de_tri.sort(key=lambda x: x[6])
					#si on détecte une différence dans la taille (administrateur: ajout ou suppr de champ dans la base Mysql), alors on relance la fonction atcuelle
					if len(eval(self.ordre_Tri_Resultat_Scroll[0][3])) != len(GLOBAL_mon_tuple_de_tuple_ORIGINAL):
						if mode_debuggage == 'oui': print "nouvel appel de self.GLOBAL_gestion_variable_et_tableaux_globaux"
						return "erreur1" # le return bloque la suite de la fonction: on sort ici
				else:
					if mode_debuggage == 'oui': print "Fonction None 3 "
					self.SCROLL_AREA_mon_list_de_list_de_champs = copy.deepcopy(GLOBAL_mon_tuple_de_tuple_ORIGINAL)
					self.TRI_mon_list_de_list_de_parametres_de_tri = copy.deepcopy(GLOBAL_mon_tuple_de_tuple_ORIGINAL)
					self.TRI_mon_list_de_list_de_parametres_de_tri.sort(key=lambda x: x[6])
				
				###fenetre de RESULTAT des parametres
				if mode_debuggage == 'oui': print "self.ordre_Tri_Resultat_Scroll"
				if mode_debuggage == 'oui': print self.ordre_Tri_Resultat_Scroll[0][2]
				if self.ordre_Tri_Resultat_Scroll[0][2] is not None:
					if mode_debuggage == 'oui': print "Fonction not none 2 "
					self.RESULTAT_mon_list_de_list_de_colonne = copy.deepcopy(GLOBAL_mon_tuple_de_tuple_ORIGINAL)
					self.RESULTAT_colonnes_visibles_et_taille = copy.deepcopy(self.ordre_Tri_Resultat_Scroll[0][2])
				else:
					if mode_debuggage == 'oui': print "Fonction None 2 "
					self.RESULTAT_mon_list_de_list_de_colonne = copy.deepcopy(GLOBAL_mon_tuple_de_tuple_ORIGINAL)
				
				"""
				###fenetre de TRI des parametres: (pour info l'ordre d'apparition est géré au dessus dans ###fenetre de SCROLL AREA avec tous les champs
				if self.ordre_Tri_Resultat_Scroll[0][1] is not None:
					if mode_debuggage == 'oui': print "Fonction not none 1 "
					#BUG possible: vérifier de très très près ce qu'il se passe en cas d'utilisation du transpose_list_multiple avec les ajouts/supppr de colonne dans 
					#mon_invertion = Transposition_selon_ordre()
					
				else:
					if mode_debuggage == 'oui': print "Fonction None 1"
				"""	
			
				
				
					
				
				
			
			id.commit()
			id.close()
		
		
		except MySQLdb.OperationalError,e:
			if mode_debuggage == 'oui': print "e"
			if mode_debuggage == 'oui': print e
			texte_titre = "Erreur de connection au serveur_"
			msg_debut = "Connexion impossible:  \n Vérifier si la connection au serveur de base de données est bien établie" 
			QtGui.QApplication.restoreOverrideCursor()
			QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
			ma_boite = QtGui.QMessageBox(MainWindow)
			ma_boite.setIcon(QtGui.QMessageBox.Warning)
			ma_boite.setWindowTitle(texte_titre)
			ma_boite.setInformativeText(msg_debut)
			ma_boite.addButton(_fromUtf8("Ok"), 0)
			reponse = ma_boite.exec_()
			
	def TRI_chargement_des_lignes_utilisateur(self):
		try:
		
			if mode_debuggage == 'oui': print "self.ordre_Tri_Resultat_Scroll[0][1][9]"
			if mode_debuggage == 'oui': print self.ordre_Tri_Resultat_Scroll[0][1][9]
			tableau = list(eval(self.ordre_Tri_Resultat_Scroll[0][1]))
			if mode_debuggage == 'oui': print tableau
			if mode_debuggage == 'oui': print ""
			if mode_debuggage == 'oui': print "self.ordre_de_tri_1.count()"
			if mode_debuggage == 'oui': print self.ordre_de_tri_1.count()
			if mode_debuggage == 'oui': print "int(tableau[0])"
			if mode_debuggage == 'oui': print int(tableau[0])
			if self.ordre_de_tri_1.count() < int(tableau[0]):
				self.TRI_creation_ligne_dans_tableau_parametres_de_tri()
			
				
				texte_titre = unicode("Table modifiée", "iso-8859-1")
				msg = unicode("Des champs de table ont été supprimés, vous devez refaire toutes vos lignes de tri", "iso-8859-1")
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Warning)
				ma_boite.setInformativeText(msg)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.addButton(_fromUtf8("Fermer"), 0)
				reponse = ma_boite.exec_()
				
			
			else:
				for ligne_supp in range(self.qtableWidget_param.rowCount()):
					self.qtableWidget_param.removeRow(0)
				
				
				if self.ordre_de_tri_1.count() > int(tableau[0]) : #pas grave, des lignes on été ajoutées ou modifiées
					self.TRI_creation_ligne_dans_tableau_parametres_de_tri()
					texte_titre = unicode("Table modifiée", "iso-8859-1")
					msg = unicode("Des champs de table ont été ajoutés. Vous devez réenregistrer vos paramètres visuels et réenregistrer votre config en cours via modif/valider_modif pour que ce message ne s'affiche plus", "iso-8859-1")
					QtGui.QApplication.restoreOverrideCursor()
					QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
					ma_boite = QtGui.QMessageBox(MainWindow)
					ma_boite.setIcon(QtGui.QMessageBox.Warning)
					ma_boite.setInformativeText(msg)
					ma_boite.setWindowTitle(texte_titre)
					ma_boite.addButton(_fromUtf8("Fermer"), 0)
					reponse = ma_boite.exec_()
				
				
				if mode_debuggage == 'oui': print "hop valeur"
				
				#1
				for ligne in range(len(self.TRI_mon_list_de_list_de_parametres_de_tri)):
					if self.TRI_mon_list_de_list_de_parametres_de_tri[ligne][0] == tableau[1]:
						if mode_debuggage == 'oui': print "youpi reded"
						ligne_item = self.ordre_de_tri_1.findText(self.TRI_mon_list_de_list_de_parametres_de_tri[ligne][6])
						self.ordre_de_tri_1.setCurrentIndex(ligne_item)
				
				#3
				for ligne in range(len(self.TRI_mon_list_de_list_de_parametres_de_tri)):
					if self.TRI_mon_list_de_list_de_parametres_de_tri[ligne][0] == tableau[3]:
						if mode_debuggage == 'oui': print "youpi reded"
						ligne_item = self.ordre_de_tri_2.findText(self.TRI_mon_list_de_list_de_parametres_de_tri[ligne][6])
						self.ordre_de_tri_2.setCurrentIndex(ligne_item)
				#5
				for ligne in range(len(self.TRI_mon_list_de_list_de_parametres_de_tri)):
					if self.TRI_mon_list_de_list_de_parametres_de_tri[ligne][0] == tableau[5]:
						if mode_debuggage == 'oui': print "youpi reded"
						ligne_item = self.ordre_de_tri_3.findText(self.TRI_mon_list_de_list_de_parametres_de_tri[ligne][6])
						self.ordre_de_tri_3.setCurrentIndex(ligne_item)
				
				
				self.asc_desc_1.setCurrentIndex(int(tableau[2]))
				self.asc_desc_2.setCurrentIndex(int(tableau[4]))
				self.asc_desc_3.setCurrentIndex(int(tableau[6]))
				
				self.type_de_recherche.setCurrentIndex(int(tableau[7]))		
				
				
				monQLE = QtGui.QLineEdit()
				monQDE = QtGui.QDateEdit()
				monQCB = QtGui.QComboBox()
				for ligne_tri in range(int(tableau[9])):
					self.TRI_creation_ligne_dans_tableau_parametres_de_tri() #création d'une ligne pour remplissage + fonction simulation clic
					piti_tableau = list(tableau[10+ligne_tri])
					
					if mode_debuggage == 'oui': print "piti_tableau"
					if mode_debuggage == 'oui': print piti_tableau
					
					for ligne in range(len(self.TRI_mon_list_de_list_de_parametres_de_tri)):
						if self.TRI_mon_list_de_list_de_parametres_de_tri[ligne][0] == piti_tableau[0]:
							if mode_debuggage == 'oui': print "youpi rededsasa"
							ligne_item = self.qtableWidget_param.cellWidget(ligne_tri,0).findText(self.TRI_mon_list_de_list_de_parametres_de_tri[ligne][6])
							self.qtableWidget_param.cellWidget(ligne_tri,0).setCurrentIndex(ligne_item)
					
					#on simule un clic avec la fonction ci-dessous
					self.TRI_change_texte_col0_vers_col1_et_col2(ligne_item) #on simule un clic sur la dernièreligne, et sur un champ précis
					
					
					self.qtableWidget_param.cellWidget(ligne_tri,1).setCurrentIndex(int(piti_tableau[1]))
					
					if type(self.qtableWidget_param.cellWidget(ligne_tri,2)) ==  type(monQLE):
						self.qtableWidget_param.cellWidget(ligne_tri,2).setText(unicode(piti_tableau[2]))
					elif type(self.qtableWidget_param.cellWidget(ligne_tri,2)) ==  type(monQDE):
						self.qtableWidget_param.cellWidget(ligne_tri,2).setText(unicode(piti_tableau[2]))
					
					elif type(self.qtableWidget_param.cellWidget(ligne_tri,2)) ==  type(monQCB):
						ligne_item = self.qtableWidget_param.cellWidget(ligne_tri,2).findText(unicode(piti_tableau[2]))
						if ligne_item == -1:
							texte_titre = unicode("Table de tri", "iso-8859-1")
							exec('''msg_debut= unicode("Votre ancien choix dans le tableau de tri en ligne n°%s et colonne n°3 n'est plus possible. Il a été modifié ou supprimé par un administrateur. Vous devez le rédéfinir et réenregistrer vos paramètres visuels", "iso-8859-1")''' % (self.qtableWidget_param.rowCount()))
							msg_suite = u"\nAncien choix: " + unicode(piti_tableau[2])
							msg_total = msg_debut + msg_suite
							QtGui.QApplication.restoreOverrideCursor()
							QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
							ma_boite = QtGui.QMessageBox(MainWindow)
							ma_boite.setIcon(QtGui.QMessageBox.Warning)
							ma_boite.setInformativeText(msg_total)
							ma_boite.setWindowTitle(texte_titre)
							ma_boite.addButton(_fromUtf8("Fermer"), 0)
							reponse = ma_boite.exec_()
							self.qtableWidget_param.cellWidget(ligne_tri,2).setCurrentIndex(0)
						else:
							self.qtableWidget_param.cellWidget(ligne_tri,2).setCurrentIndex(ligne_item)
		except:
				self.TRI_creation_ligne_dans_tableau_parametres_de_tri()
	
	def TRI_change_texte_col0_vers_col1_et_col2(self, champ_selection = -1): #tres important, le paramètres INT du QcomboBox est transmis par le connect 
	#def TRI_change_texte_col0_vers_col1_et_col2(self,int): #tres important, le paramètres INT du QcomboBox est transmis par le connect 
	#en appellant la fonction sans parenthese dans le connect:
	#QtCore.QObject.connect(self.qcombo_choix_colonne0,QtCore.SIGNAL("currentIndexChanged(int)"),self.TRI_change_texte_col0_vers_col1_et_col2)
	# je ne m'en sers pas, mais c'est bon à savoir
		
		#NE PAS SE SERVIR DES NOMS MAIS UNIQUEMENT DES INDEX SINON LA SUPPRESSION DE LIGNE FAUSSE TOUT
		#on essaie de récupérer l'objet sous le pointeur de la souris
		#si ça marche pas, alors lors de la création d'une ligne, on se place à la dernière ligne, et en colonne zéro

		try:
			
			widgetActuel = QtGui.QApplication.focusWidget()
			ma_pos = widgetActuel.pos()
			mon_index = self.qtableWidget_param.indexAt(ma_pos)
			indice_ligne = mon_index.row()
			indice_colonne = mon_index.column()
			recup_text= widgetActuel.currentText() #sert à rien pour la suite
			recup_index= widgetActuel.currentIndex()
			if mode_debuggage == 'oui': print "clic manuel pris en compte"
		except:
			if mode_debuggage == 'oui': print "clic simulation dans ligne de tri"
			nb_ligne = self.qtableWidget_param.rowCount()
			indice_ligne = nb_ligne-1
			indice_colonne = 0
			#recup_text= widgetActuel.currentText()
			recup_index= 0
		
		if champ_selection != -1: #permet de passer en argument l'index du champ sélectionné par simulatin de clic
			recup_index = champ_selection
			
		if mode_debuggage == 'oui': print "indice_ligne"
		if mode_debuggage == 'oui': print indice_ligne
		if mode_debuggage == 'oui': print "indice_colonne"
		if mode_debuggage == 'oui': print indice_colonne

			
		
		voisine_de_droite = self.qtableWidget_param.cellWidget(indice_ligne,indice_colonne+1)
		type_champ = self.TRI_mon_list_de_list_de_parametres_de_tri[recup_index][0].split('#') #+ un pour sauter la clé primaire en 1ère ligne)
		if mode_debuggage == 'oui': print ""
		if mode_debuggage == 'oui': print "type_champ"
		if mode_debuggage == 'oui': print type_champ
		if mode_debuggage == 'oui': print "sdzou"
		#QLE QTE QCB QDE QLW
		self.var_contient = "contient"
		self.var_contient_pas = "ne contient pas"
		self.var_commence_par = "commence par"
		self.var_finit_par = "finit par"
		
		
		self.var_egal_a = "est égal à"
		self.var_inf_a = "est inférieur à"
		self.var_sup_a = "est supérieur à"
		self.var_est = "est"
		self.var_n_est_pas = "n'est pas"
		self.var_avant = "se trouve avant"
		self.var_apres = "se trouve après"
		
		
		if type_champ[1] == "QLE":
			if mode_debuggage == 'oui': print "QLE"
			voisine_de_droite.clear()
			voisine_de_droite.addItem(self.var_contient)
			voisine_de_droite.addItem(self.var_contient_pas)
			voisine_de_droite.addItem(self.var_commence_par)
			voisine_de_droite.addItem(self.var_finit_par)
			
			monline_edit = QtGui.QLineEdit()
			self.qtableWidget_param.setCellWidget(indice_ligne,indice_colonne+2,monline_edit)
			QtCore.QObject.connect(monline_edit,QtCore.SIGNAL('returnPressed()'),self.rechercher)
			if mode_debuggage == 'oui': print "QLE2"
			
			type_de_donnees = self.TRI_mon_list_de_list_de_parametres_de_tri[recup_index][1]
			
			if mode_debuggage == 'oui': print "type_de_donnees[:5]"
			if mode_debuggage == 'oui': print type_de_donnees[:5]
			if type_de_donnees[:3] == "int": # SI C'EST UN INT, on crée un Qline Edit avec validateur sur la colonne décalé de deux à droite
			
				monline_edit = QtGui.QLineEdit()
				QtCore.QObject.connect(monline_edit,QtCore.SIGNAL('returnPressed()'),self.rechercher)
				if mode_debuggage == 'oui': print "split_type_donnees"
				if mode_debuggage == 'oui': print split_type_donnees
				split_type_donnees = type_de_donnees.split("(")
				split_de_split = split_type_donnees[1].split(")")
				if mode_debuggage == 'oui': print "split_de_split"
				if mode_debuggage == 'oui': print split_de_split
				taille_maxi = int(split_de_split[0])
				if mode_debuggage == 'oui': print "taille_maxi"
				if mode_debuggage == 'oui': print taille_maxi
				monline_edit.setMaxLength(taille_maxi)
				monline_edit.setValidator(QtGui.QIntValidator(0, 999999999, monline_edit))
				self.qtableWidget_param.setCellWidget(indice_ligne,indice_colonne+2,monline_edit)
				voisine_de_droite.clear()
				voisine_de_droite.addItem(self.var_egal_a)
				voisine_de_droite.addItem(self.var_inf_a)
				voisine_de_droite.addItem(self.var_sup_a)
			
			elif type_de_donnees[:5] == "float": #forcément un pourcentage
					monline_edit = QtGui.QLineEdit()
					QtCore.QObject.connect(monline_edit,QtCore.SIGNAL('returnPressed()'),self.rechercher)
					min = 0.00
					max = 99.99
					no_decimals = 2
					if mode_debuggage == 'oui': print "dee"
					monline_edit.setMaxLength(len(str(max)))
					if mode_debuggage == 'oui': print "mpl"
					aValidator = MyDoubleValidator(min, max, no_decimals, monline_edit)
					if mode_debuggage == 'oui': print "mpl2"
					monline_edit.setValidator(aValidator)
					self.qtableWidget_param.setCellWidget(indice_ligne,indice_colonne+2,monline_edit)
					if mode_debuggage == 'oui': print "mpl3"
					voisine_de_droite.clear()
					voisine_de_droite.addItem(self.var_egal_a)
					voisine_de_droite.addItem(self.var_inf_a)
					voisine_de_droite.addItem(self.var_sup_a)
					if mode_debuggage == 'oui': print "mpl4"
					
		elif type_champ[1] == "QTE":
			voisine_de_droite.clear()
			voisine_de_droite.addItem(self.var_contient)
			voisine_de_droite.addItem(self.var_contient_pas)
			voisine_de_droite.addItem(self.var_commence_par)
			voisine_de_droite.addItem(self.var_finit_par)
			
			monline_edit2 = QtGui.QLineEdit()
			self.qtableWidget_param.setCellWidget(indice_ligne,indice_colonne+2,monline_edit2)
			QtCore.QObject.connect(monline_edit2,QtCore.SIGNAL('returnPressed()'),self.rechercher)
			
		elif type_champ[1] == "QCB":
			voisine_de_droite.clear()
			voisine_de_droite.addItem(self.var_contient)
			voisine_de_droite.addItem(self.var_contient_pas)
			voisine_de_droite.addItem(self.var_commence_par)
			voisine_de_droite.addItem(self.var_finit_par)
			
			try: # si on arrive à récupérer le type de champs 2, alors c'est un Qpush Button, donc connection MysqL nécessaire, 
			#sinon on récepuère les champs commentaires
				type_champ[2]
				#COmbobox avec champs en base Mysql
				#On remplit les list Widget en passant le type de table en paramètre, et on remplit la liste
				#if mode_debuggage == 'oui': print "type_champ[4]"
				#if mode_debuggage == 'oui': print type_champ[4]
				#if mode_debuggage == 'oui': print "(type_champ[5])"
				#if mode_debuggage == 'oui': print int(type_champ[5])
				 
				
				ma_liste_des_items = self.SCROLL_remplissage_des_QListWidget(type_champ[4],int(type_champ[5])) #type_champ[4]: nom de table    ------ type_champ[5] numéro de colonne dans la table
				if mode_debuggage == 'oui': print "ma_liste_des_items"
				if mode_debuggage == 'oui': print ma_liste_des_items
				moncombox = QtGui.QComboBox()
				for chaque_item1 in ma_liste_des_items:
					moncombox.addItem(chaque_item1)
				self.qtableWidget_param.setCellWidget(indice_ligne,indice_colonne+2,moncombox)
			
			
			except: #COmbobox avec champs en commentaires du champ
				maliste = self.TRI_mon_list_de_list_de_parametres_de_tri[recup_index][5].split('#&#')
				ma_liste_commentaire = maliste[0].split('#-#')
				taille_maliste = len(ma_liste_commentaire)
				moncombox = QtGui.QComboBox()
				for i in range(1,taille_maliste):
					moncombox.addItem(ma_liste_commentaire[i])
				self.qtableWidget_param.setCellWidget(indice_ligne,indice_colonne+2,moncombox)
					
		elif type_champ[1] == "QDE":
			voisine_de_droite.clear()
			voisine_de_droite.addItem(self.var_est)
			voisine_de_droite.addItem(self.var_n_est_pas)
			voisine_de_droite.addItem(self.var_avant)
			voisine_de_droite.addItem(self.var_apres)
			
			mondateedit = QtGui.QDateEdit()
			self.qtableWidget_param.setCellWidget(indice_ligne,indice_colonne+2,mondateedit)
		
		elif type_champ[1] == "QLW": #QListWidget: on la remplit en se connectant aux différentes bases
			voisine_de_droite.clear()
			voisine_de_droite.addItem(self.var_contient)
			voisine_de_droite.addItem(self.var_contient_pas)
			voisine_de_droite.addItem(self.var_commence_par)
			voisine_de_droite.addItem(self.var_finit_par)
			
			ma_liste_des_items = self.SCROLL_remplissage_des_QListWidget(type_champ[4],int(type_champ[5])) #type_champ[4]: nom de table    ------ type_champ[5] numéro de colonne dans la table
			moncombox = QtGui.QComboBox()
			for chaque_item1 in ma_liste_des_items:
				moncombox.addItem(chaque_item1)
			self.qtableWidget_param.setCellWidget(indice_ligne,indice_colonne+2,moncombox)
		
		if mode_debuggage == 'oui': print "zuzu"
		
	def TRI_creation_ligne_dans_tableau_parametres_de_tri(self):
		#NE PAS SE SERVIR DES NOMS MAIS UNIQUEMENT DES INDEX SINON LA SUPPRESSION DE LIGNE FAUSSE TOUT
		nb_ligne = self.qtableWidget_param.rowCount()
		if mode_debuggage == 'oui': print "nb_ligne_dans_tableau"
		if mode_debuggage == 'oui': print nb_ligne
		if nb_ligne <= 15:
		
			self.qtableWidget_param.insertRow(nb_ligne)
			
			#colonne0 QComboBox
			if mode_debuggage == 'oui': print "Remplissage ligne du tableau param"
			nb_total_champs = len(self.TRI_mon_list_de_list_de_parametres_de_tri)
			mon_comboBox_col_0 = QtGui.QComboBox()
			mon_comboBox_col_0.setMaxVisibleItems(nb_total_champs)
			
			#on remplit la colonne zéro
			for row in range (nb_total_champs): #on prend pas le zero qui est l'index
				
				maliste = self.TRI_mon_list_de_list_de_parametres_de_tri[row][6]
				exec('''mon_label = (u"%s")''' % (maliste))
				mon_comboBox_col_0.addItem(mon_label)
				
				
			#colonne0 QComboBox
			self.qtableWidget_param.setCellWidget(nb_ligne,0,mon_comboBox_col_0)
			QtCore.QObject.connect(mon_comboBox_col_0,QtCore.SIGNAL('currentIndexChanged(int)'),self.TRI_change_texte_col0_vers_col1_et_col2)
			
	
			#colonne1 QComboBox
			qcombo_choix_col_1_ligne = QtGui.QComboBox()
			self.qtableWidget_param.setCellWidget(nb_ligne,1,qcombo_choix_col_1_ligne)
			
			
			#colonne2 QLineEdit
			mon_qLineEdit_ligne = QtGui.QLineEdit()
			self.qtableWidget_param.setCellWidget(nb_ligne,2,mon_qLineEdit_ligne)
			
			#colonne3 qpushbutton PLUS
			bouton_plus_ligne = QtGui.QPushButton()
			bouton_plus_ligne.setText('+')
			bouton_plus_ligne.setContentsMargins(10, 10, 10, 10) # MARCHE PAS mais pas grave
			self.qtableWidget_param.setCellWidget(nb_ligne,3,bouton_plus_ligne)
			QtCore.QObject.connect(bouton_plus_ligne,QtCore.SIGNAL('clicked()'),self.TRI_creation_ligne_dans_tableau_parametres_de_tri)
			
			#colonne3 qpushbutton MOINS
			bouton_moins_ligne = QtGui.QPushButton()
			bouton_moins_ligne.setText('-')
			self.qtableWidget_param.setCellWidget(nb_ligne,4,bouton_moins_ligne)
			QtCore.QObject.connect(bouton_moins_ligne,QtCore.SIGNAL('clicked()'),self.TRI_suppression_ligne_dans_tableau_parametres_de_tri)
			
			
			
			
		else:
			mon_titre = "Attention"
			mon_avertissement = "Le nombre de critères de tri \n est limité à 15"
			QtGui.QApplication.restoreOverrideCursor()
			QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
			mabox = QMessageBox_derive()
			mabox.box_erreur(mon_titre,mon_avertissement)
		
		self.TRI_change_texte_col0_vers_col1_et_col2()	
		
	def TRI_suppression_ligne_dans_tableau_parametres_de_tri(self):
		widgetActuel = QtGui.QApplication.focusWidget() #recupère le widget sélectionné
		ma_pos = widgetActuel.pos()
		mon_index = self.qtableWidget_param.indexAt(ma_pos)
		
		
		nb_ligne = self.qtableWidget_param.rowCount()
		if nb_ligne > 1:
			self.qtableWidget_param.removeRow(mon_index.row())
	
	def TRI_ordre_des_tris(self):
		if mode_debuggage == 'oui': print "Remplissage des 3 ordres de tri"
		nb_total_champs = len(self.TRI_mon_list_de_list_de_parametres_de_tri)
		self.ordre_de_tri_1.setMaxVisibleItems(nb_total_champs)
		self.ordre_de_tri_2.setMaxVisibleItems(nb_total_champs)
		self.ordre_de_tri_3.setMaxVisibleItems(nb_total_champs)
		
		#http://www.fileformat.info/info/unicode/block/arrows/utf8test.htm
		#self.ordre_de_tri_1.addItem(unichr(int("0026", 16)))
		#self.ordre_de_tri_1.addItem(u"\u21E7")
		#on remplit la colonne zéro
		###
		exec("self.asc_desc_1.addItem(QtGui.QIcon(_fromUtf8('%s%s')), '')" % (GLOBAL_chemin_icone, "arrow_top.png"))
		exec("self.asc_desc_1.addItem(QtGui.QIcon(_fromUtf8('%s%s')), '')" % (GLOBAL_chemin_icone, "arrow_down.png"))
		exec("self.asc_desc_2.addItem(QtGui.QIcon(_fromUtf8('%s%s')), '')" % (GLOBAL_chemin_icone, "arrow_top.png"))
		exec("self.asc_desc_2.addItem(QtGui.QIcon(_fromUtf8('%s%s')), '')" % (GLOBAL_chemin_icone, "arrow_down.png"))
		exec("self.asc_desc_3.addItem(QtGui.QIcon(_fromUtf8('%s%s')), '')" % (GLOBAL_chemin_icone, "arrow_top.png"))
		exec("self.asc_desc_3.addItem(QtGui.QIcon(_fromUtf8('%s%s')), '')" % (GLOBAL_chemin_icone, "arrow_down.png"))
	
		self.ordre_de_tri_1.clear()
		self.ordre_de_tri_2.clear()
		self.ordre_de_tri_3.clear()
		
		self.ordre_de_tri_1.addItem("")
		self.ordre_de_tri_2.addItem("")
		self.ordre_de_tri_3.addItem("")
		for row in range (nb_total_champs): #on prend pas le zero qui est l'index	
			maliste = self.TRI_mon_list_de_list_de_parametres_de_tri[row][6]
			exec('''mon_label = (u"%s")''' % (maliste))
			self.ordre_de_tri_1.addItem(mon_label)
			self.ordre_de_tri_1.setItemData(row, mon_label, QtCore.Qt.ToolTipRole)
			self.ordre_de_tri_2.addItem(mon_label)
			self.ordre_de_tri_2.setItemData(row, mon_label, QtCore.Qt.ToolTipRole)
			self.ordre_de_tri_3.addItem(mon_label)
			self.ordre_de_tri_3.setItemData(row, mon_label, QtCore.Qt.ToolTipRole)
	
	def RESULTAT_preparation_tableau(self):
		#	##clic droit dans header des colonnes	
		#self.qtableWidget_resultat.setHorizontalHeader(QtGui.QHeaderView(QtCore.Qt.Horizontal,self.qtableWidget_resultat))
	
		nb_total_champs = len(self.RESULTAT_mon_list_de_list_de_colonne)

		
		
		self.mon_QHeaderView_special = QHeaderView_special(QtCore.Qt.Horizontal, self.qtableWidget_resultat)
		self.qtableWidget_resultat.setSortingEnabled(True)
		self.qtableWidget_resultat.setHorizontalHeader(self.mon_QHeaderView_special)
		QtCore.QObject.connect(self.qtableWidget_resultat.horizontalHeader(),QtCore.SIGNAL("clic_droit_header_horiz"),self.RESULTAT_menu_header_principal_de_tableau_resultat)
		
		self.qtableWidget_resultat.setColumnCount(nb_total_champs) 
		for index in range(nb_total_champs): #on prend également  le zero avec l'index de la base
			#QLE QTE QCB QDE
			maliste = self.RESULTAT_mon_list_de_list_de_colonne[index][6]
			exec('''mon_label = (u"%s")''' % (maliste))
			
			item = QtGui.QTableWidgetItem()
			item.setText(mon_label)
			item.setTextAlignment(0) #0:aligné à gauche / 1:aligné centre / 2:aligné droite
			#?if mode_debuggage == 'oui': print unicode(item.text()).encode("cp850")
			self.qtableWidget_resultat.setHorizontalHeaderItem(index, item)#rien
			self.qtableWidget_resultat.showColumn(index)
		
		
		self.qtableWidget_resultat.horizontalHeader().show()
		self.qtableWidget_resultat.setSortingEnabled(True)  #active tri sur colonne
		self.qtableWidget_resultat.resizeColumnsToContents()
		#self.qtableWidget_resultat.setAlternatingRowColors(True)
		
		#sélection de la ligne au lieu de la cellule cliquée
		titi = QtGui.QAbstractItemView.SelectRows 
		self.qtableWidget_resultat.setSelectionBehavior(titi)
		
		#empêche l'édition du tableau - éditable
		self.qtableWidget_resultat.setItemDelegate(QtGui.QItemDelegate(self.qtableWidget_resultat))
		toto = QtGui.QAbstractItemView.NoEditTriggers
		self.qtableWidget_resultat.setEditTriggers(toto)
		
		#désactive la sélection multiple
		self.qtableWidget_resultat.setSelectionMode(QtGui.QAbstractItemView.SingleSelection) #désactive la sélection multiple
		
	#	##clic droit dans header des colonnes	
	#	mon_QHeaderView_special = QHeaderView_special(QtCore.Qt.Horizontal, self.qtableWidget_resultat)
	#	mon_QHeaderView_special.setMovable(True)
	#	self.qtableWidget_resultat.setHorizontalHeader(mon_QHeaderView_special)
	#	QtCore.QObject.connect(self.qtableWidget_resultat.horizontalHeader(),QtCore.SIGNAL("clic_droit_header_horiz"),self.RESULTAT_menu_header_principal_de_tableau_resultat)
	
		
		try:
			toto = self.RESULTAT_colonnes_visibles_et_taille
			dada = 2
		except:
			dada = 8
			
		#if mode_debuggage == 'oui': print "dada"
		#if mode_debuggage == 'oui': print dada		
				
		if GLOBAL_config_actuelle_finale != "_" and dada !=8:
			if mode_debuggage == 'oui': print "config perso"
			self.colonnes_visibles_et_taille_dans_resultat = copy.deepcopy((eval(self.RESULTAT_colonnes_visibles_et_taille)))
			taille_du_list_perso = len(self.colonnes_visibles_et_taille_dans_resultat)
			if mode_debuggage == 'oui': print "taille_du_list_perso" #logicalIndex en 0, visual_index  en 1, taille en 2, visible ou pas en 3
			if mode_debuggage == 'oui': print taille_du_list_perso
			for element in range (taille_du_list_perso):			
				self.qtableWidget_resultat.setColumnWidth(self.colonnes_visibles_et_taille_dans_resultat[element][0], self.colonnes_visibles_et_taille_dans_resultat[element][2])
				self.qtableWidget_resultat.showColumn(self.colonnes_visibles_et_taille_dans_resultat[element][0])
				
			for element in range(taille_du_list_perso):
				mon_visual = self.mon_QHeaderView_special.visualIndex(int(self.colonnes_visibles_et_taille_dans_resultat[element][0]))
				self.mon_QHeaderView_special.moveSection(mon_visual, self.colonnes_visibles_et_taille_dans_resultat[element][1])
				#BUG VISUAL
				
			
			sup_ou_ajout_de_champ_de_table = "non"
			for element in range(taille_du_list_perso):
				try: 
					if self.colonnes_visibles_et_taille_dans_resultat[element][3] == "non":
						self.qtableWidget_resultat.hideColumn(self.colonnes_visibles_et_taille_dans_resultat[element][0])
					elif self.colonnes_visibles_et_taille_dans_resultat[element][3] == "oui":
						self.qtableWidget_resultat.showColumn(self.colonnes_visibles_et_taille_dans_resultat[element][0])
					
				except:
					self.qtableWidget_resultat.showColumn(self.colonnes_visibles_et_taille_dans_resultat[element][0])
					sup_ou_ajout_de_champ_de_table = "oui"
			
			if 	sup_ou_ajout_de_champ_de_table == "oui": #message d'erreur car les colonnes ne retourvent plus les index en cas de rajout modif de table
				texte_titre = "configuration mal définie"
				msg = "Vous devez sauvegarder vos paramètres visuels via /paramètres/enregistrer le visuel"
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Critical)
				ma_boite.setInformativeText(msg)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.addButton(_fromUtf8("Fermer"), 0)
				reponse = ma_boite.exec_()
		#self.mon_QHeaderView_special.()
		#QHeaderView.moveSection (self, int from, int to)
		#QHeaderView.moveSection (from ancien_visual ,  to visual_index)
		#int logicalIndex (self, int visualIndex)
		#if mode_debuggage == 'oui': print doudou
				
	def RESULTAT_cell_clickee(self,ligne,col):
		if mode_debuggage == 'oui': print ""
		if mode_debuggage == 'oui': print "ligne"
		if mode_debuggage == 'oui': print ligne
		if mode_debuggage == 'oui': print "col"
		if mode_debuggage == 'oui': print col
		
		if self.qtableWidget_resultat.currentRow() != -1:
			#self.resultat_clic_recherche
			#ref_index = self.qtableWidget_resultat.item(ligne,0).data(0).toString() pas besoin de toString(), on chope direct le data(0)
			ref_index = self.qtableWidget_resultat.item(ligne,0).data(0)
			if mode_debuggage == 'oui': print "ref_index ligne differente de un"
			if mode_debuggage == 'oui': print ref_index
			
			ligne_scroll_QLW = -1
			for elem in self.resultat_clic_recherche:
				if ref_index == elem[0]:
					if mode_debuggage == 'oui': print ""
					if mode_debuggage == 'oui': print "youpi"
					if mode_debuggage == 'oui': print elem
					
					debut_mon_nom = unicode("Affaire: ", "iso-8859-1")
					fin_mon_nom = unicode(elem[1], "iso-8859-1")
					total_mon_nom = debut_mon_nom + fin_mon_nom
					self.mon_Qlabel_status_bar3.setText(total_mon_nom)
					
					exec("MainWindow.setWindowTitle(_fromUtf8('%s_%s - %s'))" % (GLOBAL_nom_programme, GLOBAL_version_programme, total_mon_nom))
					
					
					
					#Si Nouveau-Modif-Annuler sont visibles, alors on effectue les actions ci-dessous, sinon, on ne fait rien
					
					#if self.qpush_nouveau.isVisible() == True and self.qpush_modifier.isVisible() == True and self.qpush_supprimer.isVisible() == True:
						
			
					self.ligne_cliquee_avant_modif = elem  #a utiliser pour vérifier si une modif a été effectuée entre temps
					if self.ordre_Tri_Resultat_Scroll[0][3] is not None:
						list_ordre = eval(self.ordre_Tri_Resultat_Scroll[0][3])
					else:
						list_ordre = []
						for num in range(elem): #elem contient la ligne avec les valeurs
							list_ordre.append(num)
					
					#####
					if mode_debuggage == 'oui': print "insertion de tous les blabla quand clic sur ligne"
					try:
						for num_ligne in range(1,self.mon_grid_area.rowCount()):
							mon_widget = self.mon_grid_area.itemAtPosition(num_ligne,1).widget()
							mon_libelle = self.mon_grid_area.itemAtPosition(num_ligne,0).widget().text()
							#if mode_debuggage == 'oui': print ""
							#if mode_debuggage == 'oui': print "insertion dans %s" % (mon_libelle)
							#if mode_debuggage == 'oui': print "type widget: %s" % (mon_widget)
							#if mode_debuggage == 'oui': print (elem[list_ordre[num_ligne]])
							
							#bug, mais normalement ça marche
							
							
							if type(mon_widget) == type(QComboBox_boost_SCROLL()):
								trouve_qcb = 0
								for num_cbbx in range(mon_widget.count()): #nettoyage des champs qui n'existent plus
									qfont_detecte = mon_widget.itemData(num_cbbx, QtCore.Qt.FontRole) #pas de bug, mais se poser la question pour les Qlistwidget....
									if qfont_detecte.typeName() == "QFont": 
										if mode_debuggage == 'oui': print "qfont_detecte.typeName()"
										if mode_debuggage == 'oui': print qfont_detecte.typeName()
										if mode_debuggage == 'oui': print "italique gras youpi"
										convertionok = qfont_detecte.Font
										if mode_debuggage == 'oui': print "convertionok"
										if mode_debuggage == 'oui': print qfont_detecte.toString()
										monQFont = QtGui.QFont()
										monQFont.setItalic(True) #italique
										monQFont.setBold(True) #gras
										
										pour_comparer = QtCore.QVariant(monQFont).toString()
										
										
										if qfont_detecte.toString() == pour_comparer:
											mon_widget.removeItem(num_cbbx)
									
								for num_cbbx in range(mon_widget.count()):
									if mon_widget.itemText(num_cbbx) == (elem[list_ordre[num_ligne]]):
										mon_widget.setCurrentIndex(num_cbbx)
										trouve_qcb = 1
									if (elem[list_ordre[num_ligne]]) is None: #gestion des champs "null" (ou None) dans la base mysql
										mon_widget.setCurrentIndex(num_cbbx)
										trouve_qcb = 1
										
								if trouve_qcb == 0: #BUG possible mais normalement ok #si on rencontre une ligne qui a été supprimée via les peties bases #BUG possible: vérifier le fonctionnement
									mon_widget.addItem(elem[list_ordre[num_ligne]])
									
									
									mon_widget.setCurrentIndex(mon_widget.count()-1)
									##combo.setItemData(rowIndex, QVariant(myCustomFont), Qt.FontRole)
									#mon_widget.setItemData(mon_widget.count()-1, QtCore.Qt.AlignRight, QtCore.Qt.TextAlignmentRole)
									monQFont = QtGui.QFont()
									monQFont.setItalic(True) #italique
									monQFont.setBold(True) #gras
									
									mon_widget.setItemData(mon_widget.count()-1, monQFont, QtCore.Qt.FontRole) #bug pasbug: à developper égalment pour les list view???
								
								###mode nouveau###				
								if self.qpush_valider_nouveau.isVisible() == True: 
									mon_widget.setCurrentIndex(0)

								
							elif type(mon_widget) == type(QtGui.QLineEdit()):
								#if mode_debuggage == 'oui': print "type de la donnee"
								#if mode_debuggage == 'oui': print type(elem[list_ordre[num_ligne]])
								try:
										
									if type(elem[list_ordre[num_ligne]]) is long or type(elem[list_ordre[num_ligne]]) is int or type(elem[list_ordre[num_ligne]]) is float:
										mon_widget.setText(str(elem[list_ordre[num_ligne]]))
									else:
										mon_widget.setText(elem[list_ordre[num_ligne]])
										
									if self.qpush_valider_nouveau.isVisible() == True:
										mon_widget.setText('')
								except:
									mon_widget.setText('')
															
							elif type(mon_widget) == type(QtGui.QTextEdit()):
								if type(elem[list_ordre[num_ligne]]) is long or type(elem[list_ordre[num_ligne]]) is int or type(elem[list_ordre[num_ligne]]) is float:
									mon_widget.setPlainText(str(elem[list_ordre[num_ligne]]))
								else:
									try:
										dudu = elem[list_ordre[num_ligne]]
										mon_widget.setPlainText(elem[list_ordre[num_ligne]])
									except:
										mon_widget.setPlainText('')
								
								if self.qpush_valider_nouveau.isVisible() == True:
									mon_widget.setPlainText('')
								
							elif type(mon_widget) == type(QDateEdit_boost_SCROLL()):
								try:
									mon_widget.setDate(elem[list_ordre[num_ligne]])
								except:
									monQDate = QtCore.QDate()
									zouzou = monQDate.fromString("19000101", "yyyyMMdd")
									mon_widget.setDate(zouzou)
								
								
								
								if self.qpush_valider_nouveau.isVisible() == True:
									monQDate = QtCore.QDate()
									zouzou = monQDate.fromString("19000101", "yyyyMMdd")
									mon_widget.setDate(zouzou)
								
							elif type(mon_widget) == type(QListWidget_boost_SCROLL()):
								ligne_scroll_QLW = ligne_scroll_QLW + 1
								#mon_widget.setSelectionMode(QtGui.QAbstractItemView.NoSelection)
								"""
								self.qpush_nouveau.show()
								self.qpush_modifier.show()
								self.qpush_supprimer.show()
								self.qpush_valider_nouveau.hide()
								self.qpush_valider_modif.hide()
								self.qpush_annuler.hide()
								"""
								
								exec("ma_liste_origine_QLW = copy.deepcopy(self.ma_liste_des_items_QLW_%s)" % ligne_scroll_QLW)
								mon_widget.clear()
								for item_origine in ma_liste_origine_QLW:
									mon_widget.addItem(item_origine)
								
								###mode lecture###
								if self.qpush_modifier.isVisible() == True: 
									for num_clw in range(mon_widget.count()): 
										mon_widget.setItemSelected(mon_widget.item(num_clw),False)
										mon_widget.setItemHidden(mon_widget.item(num_clw),True)
		
								###mode lecture###
								if elem[list_ordre[num_ligne]] is not None and self.qpush_modifier.isVisible() == True:	
									mon_split = elem[list_ordre[num_ligne]].split('##')
									for piti_split in mon_split:
										mon_qlistwidgetitem = QtGui.QListWidgetItem()
										mon_qlistwidgetitem.setText(piti_split)
										
										trouve_clw = 0
										for num_clw in range(mon_widget.count()): 
											if mon_qlistwidgetitem.text() == mon_widget.item(num_clw).text():
												mon_widget.setItemSelected(mon_widget.item(num_clw),True)
												mon_widget.setItemHidden(mon_widget.item(num_clw),False)
												trouve_clw = 1
									
											if (elem[list_ordre[num_ligne]]) is None or elem[list_ordre[num_ligne]] == "Null": #gestion des champs "null" (ou None) dans la base mysql
												trouve_clw = 1
												
										if trouve_clw == 0 : #BUG possible mais normalement ok #si on rencontre une ligne qui a été supprimée via les peties bases #BUG possible: vérifier le fonctionnement
											monQFont = QtGui.QFont()
											monQFont.setItalic(True) #italique
											monQFont.setBold(True) #gras
											mon_qlistwidgetitem.setFont(monQFont)
											
											mon_widget.addItem(mon_qlistwidgetitem)
											mon_widget.setItemSelected(mon_qlistwidgetitem,True)	
									mon_widget.setSelectionMode(QtGui.QAbstractItemView.NoSelection)

								###mode modif###	
								elif self.qpush_valider_modif.isVisible() == True: 
									mon_widget.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection)	
									if elem[list_ordre[num_ligne]] is None or elem[list_ordre[num_ligne]] == "Null":
										for num_clw in range(mon_widget.count()): 
											mon_widget.setItemSelected(mon_widget.item(num_clw),False)
											mon_widget.setItemHidden(mon_widget.item(num_clw),False) #visible
									else:
										mon_split = elem[list_ordre[num_ligne]].split('##')
										for piti_split in mon_split:
											mon_qlistwidgetitem = QtGui.QListWidgetItem()
											mon_qlistwidgetitem.setText(piti_split)
											
											trouve_clw = 0
											for num_clw in range(mon_widget.count()): 
												if mon_qlistwidgetitem.text() == mon_widget.item(num_clw).text():
													
													mon_widget.setItemSelected(mon_widget.item(num_clw),True)
													#mon_list_widgetQLW_pipo = mon_widget.findItems(mon_widget.item(num_clw).text(),QtCore.Qt.MatchFlags())
													#mon_widget.setItemSelected(mon_list_widgetQLW_pipo[0],True)
													trouve_clw = 1
												
												mon_widget.setItemHidden(mon_widget.item(num_clw),False) #visible
												
											if trouve_clw == 0 : #BUG possible mais normalement ok #si on rencontre une ligne qui a été supprimée via les peties bases #BUG possible: vérifier le fonctionnement
												monQFont = QtGui.QFont()
												monQFont.setItalic(True) #italique
												monQFont.setBold(True) #gras
												mon_qlistwidgetitem.setFont(monQFont)
												
												mon_widget.addItem(mon_qlistwidgetitem)
												mon_widget.setItemSelected(mon_qlistwidgetitem,True)
												#mon_widget.findItems(mon_widget.item(num_clw).text(),QtCore.Qt.MatchFlags())
									
											
										
											
												
										
											
								###mode nouveau###				
								elif self.qpush_valider_nouveau.isVisible() == True: 
									if mode_debuggage == 'oui': print "mode nouveau"
									#se servir de ça ??? SCROLL_remplissage_des_QListWidget   pas sûr...
									if elem[list_ordre[num_ligne]] is not None:
										mon_split = elem[list_ordre[num_ligne]].split('##')
										for piti_split in mon_split:
											mon_qlistwidgetitem = QtGui.QListWidgetItem()
											mon_qlistwidgetitem.setText(piti_split)
											
											trouve_clw = 0
											for num_clw in range(mon_widget.count()):
												if mode_debuggage == 'oui': print unicode(mon_qlistwidgetitem.text()).encode("CP850")
												if mode_debuggage == 'oui': print unicode(mon_widget.item(num_clw).text()).encode("CP850")
												if mon_qlistwidgetitem.text() == mon_widget.item(num_clw).text():
													mon_widget.setItemSelected(mon_widget.item(num_clw),False)
													mon_widget.setItemHidden(mon_widget.item(num_clw),False)
													trouve_clw = 1
										
												if (elem[list_ordre[num_ligne]]) is None or elem[list_ordre[num_ligne]] == "Null": #gestion des champs "null" (ou None) dans la base mysql
													trouve_clw = 1
											if mode_debuggage == 'oui': print "trouve_clw"
											if mode_debuggage == 'oui': print trouve_clw
											if trouve_clw == 0:
												#mon_widget.addItem(mon_qlistwidgetitem.text())
												mon_widget.setItemHidden(mon_widget.item(num_clw),True)
												
												mon_widget.setItemSelected(mon_qlistwidgetitem,False)
									
									
										"""
										for num_clw in range(mon_widget.count()): 
											mon_widget.setItemSelected(mon_widget.item(num_clw),False)
											mon_widget.setItemHidden(mon_widget.item(num_clw),False) #visible
										"""
									elif elem[list_ordre[num_ligne]] is None or elem[list_ordre[num_ligne]] == "Null":
										for num_clw in range(mon_widget.count()): 
											mon_widget.setItemSelected(mon_widget.item(num_clw),False)
											mon_widget.setItemHidden(mon_widget.item(num_clw),False) #visible
											
									mon_widget.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection)			
								
							else:
								if mode_debuggage == 'oui': print "il manque des choses"
						
								
					except:
						texte_titre = "erreur"
						msg = "Bug de remplissage à débugger du list area de droite, contactez l'administrateur pour une mise à jour logiciel"
						QtGui.QApplication.restoreOverrideCursor()
						QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
						ma_boite = QtGui.QMessageBox(MainWindow)
						ma_boite.setIcon(QtGui.QMessageBox.Critical)
						ma_boite.setInformativeText(msg)
						ma_boite.setWindowTitle(texte_titre)
						ma_boite.addButton(_fromUtf8("Fermer"), 0)
						reponse = ma_boite.exec_()
						
					
					
				else:
					
					toto = 2
					#if mode_debuggage == 'oui': print "pas de ligne resultat cliquee"
					
		
		else:
			if mode_debuggage == 'oui': print "RESULTAT_cell_clickee currentRow egal a -1"
			self.mon_grid_area.setEnabled(False)
	
	def RESULTAT_menu_header_principal_de_tableau_resultat(self):
		if mode_debuggage == 'oui': print "RESULTAT_menu_header_principal_de_tableau_resultat"
		self.mon_Qmenu_header = QtGui.QMenu(self.qtableWidget_resultat)
		
		for index in range(len(self.RESULTAT_mon_list_de_list_de_colonne)):
			###############
			#QLE QTE QCB QDE
			maliste = self.RESULTAT_mon_list_de_list_de_colonne[index][6]
			exec('''mon_label = (u"%s")''' % (maliste))
			
			###############
			#exec("self.action_header%d = self.mon_Qmenu_header.addAction(self.RESULTAT_mon_list_de_list_de_colonne[%d][5])" % (index, index))
			exec("self.action_header%d = self.mon_Qmenu_header.addAction(mon_label)" % (index))
			exec("self.action_header%d.setCheckable(True)" % (index))
		
			if self.qtableWidget_resultat.isColumnHidden(index) == True:
				exec("self.action_header%d.setChecked(False)" % (index))
			elif self.qtableWidget_resultat.isColumnHidden(index) == False:
				exec("self.action_header%d.setChecked(True)" % (index))
				
			#permet de transmetre un paramatre dans la fonction, très pratique!!! self=self permet de conserver le self	
			exec("QtCore.QObject.connect(self.action_header%d, QtCore.SIGNAL(_fromUtf8('triggered()')), lambda self=self, num_col=%d: self.RESULTAT_afficher_masquer_colonne(num_col))" % (index,index)) 
					
			#exec("QtCore.QObject.connect(self.action_header%d, QtCore.SIGNAL(_fromUtf8('triggered()')), self.RESULTAT_afficher_masquer_colonne)" % (index))			
			#QtCore.QObject.connect(self.action_header1, QtCore.SIGNAL(_fromUtf8('triggered()')), lambda who= 1: self.RESULTAT_afficher_masquer_colonne(who))
			#self.connect(msa_v1.button_file,SIGNAL('clicked()'), lambda who=msa_v1: self.control.choose_file(who))
			#self.connect(button3, SIGNAL("clicked()"),    lambda who="Three": self.anyButton(who))

			
			
		self.mon_Qmenu_header.exec_(QtGui.QCursor.pos())
	
	def RESULTAT_afficher_masquer_colonne(self,num_col):
	
		
		if mode_debuggage == 'oui': print "RESULTAT_afficher_masquer_colonne"
		if mode_debuggage == 'oui': print num_col
		if self.qtableWidget_resultat.isColumnHidden(num_col) == True:
			self.qtableWidget_resultat.setColumnHidden(num_col, False)
		elif self.qtableWidget_resultat.isColumnHidden(num_col) == False:
			self.qtableWidget_resultat.setColumnHidden(num_col, True)
			
	def SCROLL_clearLayout(self, layout):
		for i in reversed(range(layout.count())):
			item = layout.itemAt(i)

			if isinstance(item, QtGui.QWidgetItem):
				#if mode_debuggage == 'oui': print "widget" + str(item)
				item.widget().close()
				# or
				# item.widget().setParent(None)
			elif isinstance(item, QtGui.QSpacerItem):
				if mode_debuggage == 'oui': print "spacer " + str(item)
				# no need to do extra stuff
			else:
				#if mode_debuggage == 'oui': print "layout " + str(item)
				self.SCROLL_clearLayout(item.layout())

			# remove the item from layout
			layout.removeItem(item)
	
	def SCROLL_remplissage_champs(self):
		
		#si self.mon_grid_area existe déjà, on supprime tou les widgets contenus dedans
		
		try:
			toto = self.mon_grid_area.count() #astuce pour vérifier si l'objet existe
			self.SCROLL_clearLayout(self.mon_grid_area) #suppresion de tous les widgets
		
		except:
			titi = 2
		
		if mode_debuggage == 'oui': print ""
		if mode_debuggage == 'oui': print "ICICICI self.SCROLL_AREA_mon_list_de_list_de_champs ICICICI"
		if mode_debuggage == 'oui': print self.SCROLL_AREA_mon_list_de_list_de_champs
		#if mode_debuggage == 'oui': print "%d lignes\n" % cur.rowcount
		
		if mode_debuggage == 'oui': print "Remplissage Qscroll Area"
		nb_total_champs = len(self.SCROLL_AREA_mon_list_de_list_de_champs)
		if mode_debuggage == 'oui': print nb_total_champs
		#if mode_debuggage == 'oui': print self.self.SCROLL_AREA_mon_list_de_list_de_champs[1][0]
		
	
		
		#on remplit le tableau avec le résultat de la requete
		row_QLW = -1
		self.mon_grid_area = QtGui.QGridLayout()
		for row in range (1,nb_total_champs): #on prend pas le zero qui est l'index
			type_champ = self.SCROLL_AREA_mon_list_de_list_de_champs[row][0].split('#')
			if mode_debuggage == 'oui': print type_champ
			nom_du_champ_seul = self.SCROLL_AREA_mon_list_de_list_de_champs[row][6] #nom de champ tout seul
			
			#mon_mdp = list_commentaire[1] #"pas_de_mdp" ou bien mot de passe
			#analyse pour petit carré à droite
			
			try:
				if type_champ[2] == "QPB":
					if mode_debuggage == 'oui': print ""
					if mode_debuggage == 'oui': print "essai bouton de droite preparation debut"
					monQPush = QtGui.QPushButton()
					monQPush.setMaximumSize(QtCore.QSize(20, 20))
					monQPush.setMinimumSize(QtCore.QSize(10, 10))
					monQPush.setText("...")
					#on passe le nom de la table où on doit se connecter ainsi que le mot de passe
					list_commentaire = self.SCROLL_AREA_mon_list_de_list_de_champs[row][5].split('#&#')
					mon_mdp = list_commentaire[1]
					#QtCore.QObject.connect(monQPush,QtCore.SIGNAL("clicked()"),lambda self=self, type_champ=type_champ[2], nom_de_table=type_champ[4], mdp = commentaires_deuxieme_split[1]: self.SCROLL_petit_bouton_de_droite(type_champ,nom_de_table,mdp))						
					QtCore.QObject.connect(monQPush,QtCore.SIGNAL("clicked()"),lambda self=self, type_champ=type_champ[2], nom_de_table=type_champ[4], mdp = mon_mdp, num_row_grid = row: self.SCROLL_petit_bouton_de_droite(type_champ,nom_de_table,mdp,num_row_grid))						
					if mode_debuggage == 'oui': print "validation bouton de droite preparation fin"
				else:
					monQPush = ""
			except:
				monQPush = ""
			
			
			#if mode_debuggage == 'oui': print "\ntype_champ"
			#if mode_debuggage == 'oui': print type_champ
			#QLE QTE QCB QDE QLW
			if type_champ[1] == "QLW": #QListWidget: on la remplit en se connectant aux différentes bases
				row_QLW = row_QLW + 1
				monListWidget = QListWidget_boost_SCROLL()
				
				if type_champ[3] == "sc": #simple choix
					monListWidget.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
					monListWidget.setMaximumSize(QtCore.QSize(5000, 20))
				elif type_champ[3] == "mc": #multi choix
					monListWidget.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection)
					
				#On remplit les list Widget en passant le type de table en paramètre, et on remplit la liste
				exec("self.ma_liste_des_items_QLW_%s = self.SCROLL_remplissage_des_QListWidget(type_champ[4],int(type_champ[5]))" % row_QLW) #type_champ[4]: nom de table    ------ type_champ[5] numéro de colonne dans la table
				
				exec("ma_liste = copy.deepcopy(self.ma_liste_des_items_QLW_%s)" % row_QLW)
				for chaque_item1 in ma_liste:
					monListWidget.addItem(chaque_item1)
				
				exec('''objet = QLabel_boost(u"%s"),monListWidget,monQPush''' % ((nom_du_champ_seul)))
				QtCore.QObject.connect(objet[0],QtCore.SIGNAL("clicked()"),lambda self=self, text_label=nom_du_champ_seul: self.SCROLL_label_clique_col0(text_label))
				
				
			elif type_champ[1] == "QLE": #QLineEdit
				type_de_donnees = self.SCROLL_AREA_mon_list_de_list_de_champs[row][1] #vérif du type de donnée et rajout d'un validateur pour les champ en INT
				if mode_debuggage == 'oui': print "type_de_donnees"
				if mode_debuggage == 'oui': print type_de_donnees[:3]
				if type_de_donnees[:3] == "int":
					monline_edit = QtGui.QLineEdit()
					split_type_donnees = type_de_donnees.split("(")
					split_de_split = split_type_donnees[1].split(")")
					taille_maxi = int(split_de_split[0])
					monline_edit.setMaxLength(taille_maxi)
					monline_edit.setValidator(QtGui.QIntValidator(0, 999999999, monline_edit))
					exec('''objet = QLabel_boost(u"%s"),monline_edit,monQPush''' % ((nom_du_champ_seul)))
				
				elif type_de_donnees[:5] == "float":
					monline_edit = QtGui.QLineEdit()
					min = 0.00
					max = 99.99
					no_decimals = 2
					monline_edit.setMaxLength(len(str(max)))
					aValidator = MyDoubleValidator(min, max, no_decimals, monline_edit)
					monline_edit.setValidator(aValidator)
					#monline_edit.setValidator(QtGui.QDoubleValidator(0.00, 99.99, 2, monline_edit))
					exec('''objet = QLabel_boost(u"%s"),monline_edit,monQPush''' % ((nom_du_champ_seul)))
				else:
					monline_edit = QtGui.QLineEdit()
					split_type_donnees = type_de_donnees.split("(")
					split_de_split = split_type_donnees[1].split(")")
					taille_maxi = int(split_de_split[0])
					monline_edit.setMaxLength(taille_maxi) #taille maxi pour les champs texte
					exec('''objet = QLabel_boost(u"%s"),monline_edit,monQPush''' % ((nom_du_champ_seul)))
					
					if nom_du_champ_seul == "Affaire":
						QtCore.QObject.connect(objet[1],QtCore.SIGNAL("textChanged(const QString&)"),self.SCROLL_titre_scroll_affaire)
					
				QtCore.QObject.connect(objet[0],QtCore.SIGNAL("clicked()"),lambda self=self, text_label=nom_du_champ_seul: self.SCROLL_label_clique_col0(text_label))	
					
			
			elif type_champ[1] == "QTE": #QTextEdit
				monTextEdit = QtGui.QTextEdit()
				monTextEdit.setMaximumHeight(40)
				exec('''objet = QLabel_boost(u"%s"),monTextEdit,monQPush''' % ((nom_du_champ_seul)))
				QtCore.QObject.connect(objet[0],QtCore.SIGNAL("clicked()"),lambda self=self, text_label=nom_du_champ_seul: self.SCROLL_label_clique_col0(text_label))
				
			elif type_champ[1] == "QCB": #QComboBox: on la remplit:
			#soit avec les informations des commentaires
			#soit avec la connection en mySQL à la table correpondante lorsqu'un Qpushbutton existe à droite
				#moncombox = QtGui.QComboBox()
				moncombox = QComboBox_boost_SCROLL()
				moncombox.setEditable(False)
				try: # si on arrive à récupérer le type de champs 2, alors c'est un Qpush Button, donc connection MysqL nécessaire, 
				#sinon on récepuère les champs commentaires
					type_champ[2]
					#COmbobox avec champs en base Mysql
					#On remplit les list Widget en passant le type de table en paramètre, et on remplit la liste
					
					maliste = self.SCROLL_AREA_mon_list_de_list_de_champs[row][5].split('#&#')
					maliste2 = maliste[0].split('#-#')
				
					ma_liste_des_items = self.SCROLL_remplissage_des_QListWidget(type_champ[4],int(type_champ[5])) #type_champ[4]: nom de table    ------ type_champ[5] numéro de colonne dans la table
					for chaque_item1 in ma_liste_des_items:
						moncombox.addItem(chaque_item1)
					exec('''objet = QLabel_boost(u"%s"),moncombox,monQPush''' % (maliste2[0]))
				
				except: #COmbobox avec champs en commentaires du champ
					maliste = self.SCROLL_AREA_mon_list_de_list_de_champs[row][5].split('#&#')
					ma_liste_commentaire = maliste[0].split('#-#')
					taille_maliste = len(ma_liste_commentaire)
					
					for i in range(1,taille_maliste):
						moncombox.addItem(ma_liste_commentaire[i])
					exec('''objet = QLabel_boost(u"%s"),moncombox,monQPush''' % (nom_du_champ_seul))
				QtCore.QObject.connect(objet[0],QtCore.SIGNAL("clicked()"),lambda self=self, text_label=nom_du_champ_seul: self.SCROLL_label_clique_col0(text_label))
					
			elif type_champ[1] == "QDE": #QDateEdit
				exec('''objet = QLabel_boost(u"%s"),QDateEdit_boost_SCROLL(),monQPush''' % (nom_du_champ_seul))
				QtCore.QObject.connect(objet[0],QtCore.SIGNAL("clicked()"),lambda self=self, text_label=nom_du_champ_seul: self.SCROLL_label_clique_col0(text_label))
			else:
				mon_titre = _fromUtf8("Erreur de traitement")
				mon_avertissement = _fromUtf8("Erreur importation contacter MD")
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				mabox = QMessageBox_derive()
				mabox.box_erreur(mon_titre,mon_avertissement)

			objet[0].setAlignment(QtCore.Qt.AlignRight)
			
			self.mon_grid_area.addWidget(objet[0],row,0)
			self.mon_grid_area.addWidget(objet[1],row,1)
			#QtCore.QObject.connect(objet[0],QtCore.SIGNAL("clicked()"),self.SCROLL_label_clique_col0)
				
			try:
				self.mon_grid_area.addWidget(objet[2],row,2)
				if mode_debuggage == 'oui': print "bouton de droite insertion finale"
				self.mon_grid_area.itemAtPosition(row,0).widget().setToolTip("Gras Italique signifie champ supprimé") #survol hover hoover
			except:
				fifi =4
			
		self.verticalLayoutArea.addLayout(self.mon_grid_area)
	
		self.qscrollArea_detail.horizontalScrollBar().setInvertedAppearance(False) #change le scrollbar slider de droite à gauche !!! mais marche pas vriament....
		
	
		
		self.FICHE_annuler() #on active comme si on avait fait annuler

	def SCROLL_titre_scroll_affaire(self, text_changement):
		blabla = self.accents_transformation(text_changement)
		titre_affaire = self.accents_transformation(blabla)	
		#exec("self.groupBox_scroll.setTitle('Affaire: '%s)" % text_changement)
		self.groupBox_scroll.setTitle('Affaire:   ' + blabla)
		#self.groupBox_scroll.setAlignment(4) #centré
		#self.groupBox_scroll.setFlat(True) #enlève le contour
		
	
	def SCROLL_label_clique_col0(self,text_label):
		if GLOBAL_modif_unique_ou_multiple == "unique":		
			if mode_debuggage == 'oui': print "unique SCROLL_label_clique_col0 "
			#self.qtableWidget_resultat.horizontalHeader().keyboardSearch(text_label)
			#self.qtableWidget_resultat.horizontalHeader().keyboardSearch("Avancement")
			
			for num in range(self.qtableWidget_resultat.columnCount()):
				if text_label == self.qtableWidget_resultat.horizontalHeaderItem(num).text():
					if mode_debuggage == 'oui': print "header ok, on scroll"
					ligne_actuelle = self.qtableWidget_resultat.currentRow()
					if mode_debuggage == 'oui': print "ligne_actuelle"
					if mode_debuggage == 'oui': print ligne_actuelle
					if ligne_actuelle != -1:
						if mode_debuggage == 'oui': print "toto"
						self.qtableWidget_resultat.setCurrentCell(self.qtableWidget_resultat.currentRow(),num)
						self.qtableWidget_resultat.scrollToItem(self.qtableWidget_resultat.currentItem())
						self.RESULTAT_cell_clickee(self.qtableWidget_resultat.currentRow(), self.qtableWidget_resultat.currentColumn())
					else:
						self.qtableWidget_resultat.setCurrentCell(0,num)
						self.qtableWidget_resultat.scrollToItem(self.qtableWidget_resultat.currentItem())
		
		elif GLOBAL_modif_unique_ou_multiple == "multiple":		
			if mode_debuggage == 'oui': print "multiple SCROLL_label_clique_col0"	
			for num_ligne in range(1,self.mon_grid_area.rowCount()):
				if self.mon_grid_area.itemAtPosition(num_ligne,0).widget().text() == text_label and text_label != "Affaire":
					mon_widget_col_1 = self.mon_grid_area.itemAtPosition(num_ligne,1).widget()
					if mon_widget_col_1.isEnabled() == True:
						
						
						noir = QtGui.QColor("black")
						blanc = QtGui.QColor("white")
						gris = QtGui.QColor("gray")
						gris_clair = QtGui.QColor(173,216,230) #bleu acier
						mapalette_modif_multiple = QtGui.QPalette()
						#mapalette_modif_multiple.setColor(QtGui.QPalette.Text, blanc)
						mapalette_modif_multiple.setColor(QtGui.QPalette.Base, gris)
						mon_widget_col_1.setPalette(mapalette_modif_multiple)
						
						mon_widget_col_1.setEnabled(False)
						
					elif mon_widget_col_1.isEnabled() == False:
						noir = QtGui.QColor("black") 
						blanc = QtGui.QColor("white")
						gris = QtGui.QColor("gray")
						orange = QtGui.QColor("orange")
						gris_clair = QtGui.QColor(173,216,230) #bleu acier
						mapalette_modif_multiple = QtGui.QPalette()
						mapalette_modif_multiple.setColor(QtGui.QPalette.Text, blanc)
						mapalette_modif_multiple.setColor(QtGui.QPalette.Base, orange)
						mon_widget_col_1.setPalette(mapalette_modif_multiple)
						
						mon_widget_col_1.setEnabled(True)
					
			
	def SCROLL_affichage_selon_modif_ajout_suppr(self, mon_mode = "lecture"):
		if mode_debuggage == 'oui': print mon_mode
		#self.mon_grid_area:#qtGui.QGridLayout
		mon_QCB = QComboBox_boost_SCROLL()
		#mon_QCB = QtGui.QComboBox()
		mon_QLE = QtGui.QLineEdit()
		mon_QTE = QtGui.QTextEdit()
		mon_QDE = QDateEdit_boost_SCROLL()
		mon_QLW = QListWidget_boost_SCROLL()
		#mon_QLW = QtGui.QListWidget()
		mon_QPB = QtGui.QPushButton()
		
		
		#COULEUR
		
		noir = QtGui.QColor("black") 
		blanc = QtGui.QColor("white")
		rouge = QtGui.QColor("red")
		gris_clair = QtGui.QColor(173,216,230) #bleu acier
		violet_pale = QtGui.QColor(216,191,216) #vert
		
		mapalette_lecture = QtGui.QPalette()
		mapalette_lecture.setColor(QtGui.QPalette.Text, noir)
		mapalette_lecture.setColor(QtGui.QPalette.Base, blanc)
		
		mapalette_nouveau = QtGui.QPalette()
		mapalette_nouveau.setColor(QtGui.QPalette.Text, noir)
		mapalette_nouveau.setColor(QtGui.QPalette.Base, gris_clair)
		
		mapalette_modif = QtGui.QPalette()
		mapalette_modif.setColor(QtGui.QPalette.Text, noir)
		mapalette_modif.setColor(QtGui.QPalette.Base, violet_pale)
		
		mapalette_suppr = QtGui.QPalette()
		mapalette_suppr.setColor(QtGui.QPalette.Text, noir)
		mapalette_suppr.setColor(QtGui.QPalette.Base, rouge)
		

		nb_lignes = self.mon_grid_area.rowCount() # on recupère tous les itemsen deuicème colonne du SCROLL tableau grid
		for num_ligne in range(nb_lignes):
			for num_colonne in range(1,3):
				mon_item = self.mon_grid_area.itemAtPosition(num_ligne,num_colonne) 
				#1ère colonne: QCB, QLE, QTE, QDE, QLW
				#2ème colonne: QPB
				
				#if mode_debuggage == 'oui': print "type(mon_item)"
				#if mode_debuggage == 'oui': print type(mon_item)
				#mon_widget = mon_item.widget()
				#if mode_debuggage == 'oui': print mon_widget		
				
				if mon_item is not None:	
					mon_widget = mon_item.widget()
					#if mode_debuggage == 'oui': print mon_widget
					#if mode_debuggage == 'oui': print type(mon_widget)	
					
					if mon_mode == "lecture" or mon_mode == "annuler":	###LECTURE###		###annuler###		
						mon_widget.setPalette(mapalette_lecture)
						
						if type(mon_widget) == type(mon_QCB):
							#if mode_debuggage == 'oui': print "QCB"
							mon_widget.setEditable(True)
							mon_widget.setEnabled(False)
							
						elif type(mon_widget) == type(mon_QLE) \
						or type(mon_widget) == type(mon_QDE) \
						or type(mon_widget) == type(mon_QTE) :
							#if mode_debuggage == 'oui': print "QLE QDE QTE"
							mon_widget.setReadOnly(True)
						elif type(mon_widget) == type(mon_QPB):
							mon_widget.setEnabled(False)
						elif type(mon_widget) == type(mon_QLW):
							if mode_debuggage == 'oui': print  "qlw lecture"
							mon_widget.setEnabled(True)
						
					elif mon_mode == "nouveau":		###nouveau###	
						mon_widget.setPalette(mapalette_nouveau)
						
						if type(mon_widget) == type(mon_QCB):
							if mode_debuggage == 'oui': print "QCB"
							mon_widget.setEditable(False)
							mon_widget.setEnabled(True)
							try:	
								mon_widget.setCurrentIndex(0)
								if mode_debuggage == 'oui': print "current index a zero"
							except:
								kiki=1
								if mode_debuggage == 'oui': print "current index a zero"
							
							
						elif type(mon_widget) == type(mon_QLE) \
						or type(mon_widget) == type(mon_QTE) :
							#if mode_debuggage == 'oui': print "QLE QDE QTE"
							mon_widget.setEnabled(True)
							mon_widget.setReadOnly(False)
							mon_widget.setText("")
							
						elif type(mon_widget) == type(mon_QDE):
							monQDate = QtCore.QDate()
							zouzou = monQDate.fromString("19000101", "yyyyMMdd")
							mon_widget.setDate(zouzou)
							mon_widget.setEnabled(True)
							mon_widget.setReadOnly(False)
							#mon_widget.fromString("19000101", "yyyyMMdd")
						elif type(mon_widget) == type(mon_QLW):
							if mode_debuggage == 'oui': print "QLW QPB"
							mon_widget.setEnabled(True)
		
						elif type(mon_widget) == type(mon_QPB):
							mon_widget.setEnabled(True)
					
					elif mon_mode == "modif":		###modif###	
						mon_widget.setPalette(mapalette_modif)
						
						if type(mon_widget) == type(mon_QCB):
							#if mode_debuggage == 'oui': print "QCB"
							mon_widget.setEditable(False)
							mon_widget.setEnabled(True)
						elif type(mon_widget) == type(mon_QLE) \
						or type(mon_widget) == type(mon_QTE) :
							#if mode_debuggage == 'oui': print "QLE QDE QTE"
							mon_widget.setEnabled(True)
							mon_widget.setReadOnly(False)
						
						elif type(mon_widget) == type(mon_QDE):
							mon_widget.setEnabled(True)
							mon_widget.setReadOnly(False)
						
						elif type(mon_widget) == type(mon_QPB):
							mon_widget.setEnabled(True)
						elif type(mon_widget) == type(mon_QLW):
							if mode_debuggage == 'oui': print "QLW QPB"
							mon_widget.setEnabled(True) # on ne bloque rien, car on bloque la sélection plus loin: mon_widget.setSelectionMode(QtGui.QAbstractItemView.NoSelection)
					
					elif mon_mode == "suppression":		###suppression###		
						mon_widget.setPalette(mapalette_suppr)
						
						if type(mon_widget) == type(mon_QCB):
							if mode_debuggage == 'oui': print "QCB"
							mon_widget.setEditable(True)
							mon_widget.setEnabled(False)
							
						elif type(mon_widget) == type(mon_QLE) \
						or type(mon_widget) == type(mon_QDE) \
						or type(mon_widget) == type(mon_QTE) :
							if mode_debuggage == 'oui': print "QLE QDE QTE"
							mon_widget.setReadOnly(True)
						elif type(mon_widget) == type(mon_QLW) or type(mon_widget) == type(mon_QPB):
							if mode_debuggage == 'oui': print "QLW QPB"
							mon_widget.setEnabled(False)
					
					
		
		if mon_mode == "lecture" or mon_mode == "annuler":	###LECTURE###		###annuler###
			self.qtableWidget_resultat.setEnabled(True)
		elif mon_mode == "nouveau":		###nouveau###
			self.qtableWidget_resultat.setEnabled(False)
			#self.qtableWidget_resultat.setCurrentCell(-1,0)
		elif mon_mode == "modif":		###modif###
			self.qtableWidget_resultat.setEnabled(False)
		elif mon_mode == "suppression":		###suppression###	
			self.qtableWidget_resultat.setEnabled(False)
		
		
				
		###EXISTAIT AVANT	
		###if self.qtableWidget_resultat.rowCount() != -1 and mon_mode != "nouveau":
		if self.qtableWidget_resultat.rowCount() != -1:
			self.RESULTAT_cell_clickee(self.qtableWidget_resultat.currentRow(),self.qtableWidget_resultat.currentColumn()) #on simule un clic dans la ligne pour actualiser chque champ ! 
		if mode_debuggage == 'oui': print ""
		if mode_debuggage == 'oui': print "self.qtableWidget_resultat.currentRow()"
		if mode_debuggage == 'oui': print self.qtableWidget_resultat.currentRow()
		
		
					
	def SCROLL_petit_bouton_de_droite(self,type_champ, nom_de_table, mdp, num_row_grid):
		
		if mode_debuggage == 'oui': print "\n clic_petit_bouton_de_droite"
		if mode_debuggage == 'oui': print "type_champ_clic_petit_bouton"
		if mode_debuggage == 'oui': print type_champ
		if mode_debuggage == 'oui': print "\nmdp"
		if mode_debuggage == 'oui': print mdp
		if mode_debuggage == 'oui': print "\nnom_de_table"
		if mode_debuggage == 'oui': print nom_de_table
		
		
		
		if mdp == "pas_de_mdp":
			self.maFenetre = Fenetre_SQL_ajout_modif_suppression()
			self.maFenetre.creation_fenetre(type_champ, nom_de_table, num_row_grid)
		elif mdp == "avec_mdp":
			mon_text, ok = QtGui.QInputDialog.getText(MainWindow, "Mot de passe", "Attention, cette opération doit impérativement être effectuée lorsqu'aucune personne n'est connectée!! \n Rentrer votre mot de passe:", QtGui.QLineEdit.Normal)
			
			if mode_debuggage == 'oui': print "reponse_boite"
			if mode_debuggage == 'oui': print mon_text
			if mode_debuggage == 'oui': print ok
			#if (ok and mon_text.isEmpty()):				
			if (ok and mon_text == GLOBAL_list_table_et_commentaires_tables[0][1]):				
				self.maFenetre = Fenetre_SQL_ajout_modif_suppression()
				self.maFenetre.creation_fenetre(type_champ, nom_de_table, num_row_grid)
			elif (ok and mon_text != GLOBAL_list_table_et_commentaires_tables[0][1]):
				texte_titre = "erreur"
				msg = "Mauvais mot de passe"
				
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Critical)
				ma_boite.setInformativeText(msg)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.addButton(_fromUtf8("Fermer"), 0)
				reponse = ma_boite.exec_()
					
	def SCROLL_remplissage_des_QListWidget(self,nom_de_table,num_de_colonne_de_table):
		mon_ftp = class_FTP_ou_SFTP()
		id=mon_ftp.FTP_ou_SFTP()
		
		cur=id.cursor()
		#cur.execute("select * from %s" % nom_de_table)
		if mode_debuggage == 'oui': print "num_de_colonne_de_table"
		if mode_debuggage == 'oui': print num_de_colonne_de_table
		cur.execute("select * from %s order by %s asc" % (nom_de_table, (int(num_de_colonne_de_table)+1)))
		
		mon_list_resutat = list(cur.fetchall())
		
		mon_vrai_list = []
		for elem in mon_list_resutat:
			mon_vrai_list.append(elem[num_de_colonne_de_table])
		#if mode_debuggage == 'oui': print "mon_vrai_list"
		#if mode_debuggage == 'oui': print mon_vrai_list
		
		cur.close()
		return mon_vrai_list


	def rechercher(self, index_unique = "no_index"):
		QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
		
		QtCore.QObject.disconnect(self.qtableWidget_resultat,QtCore.SIGNAL("cellClicked(int,int)"),self.RESULTAT_cell_clickee)
		QtCore.QObject.disconnect(self.qtableWidget_resultat,QtCore.SIGNAL("currentCellChanged(int,int,int,int)"),self.RESULTAT_cell_clickee)
		
		
		
		
		if mode_debuggage == 'oui': print "lancer fonction rechercher"
		self.FICHE_annuler() #on revient en mode lecture
		
		
		text_ordre_tri_1 = self.ordre_de_tri_1.currentText()
		text_ordre_tri_2 = self.ordre_de_tri_2.currentText()
		text_ordre_tri_3 = self.ordre_de_tri_3.currentText()
		
		self.type_de_recherche.currentIndex()
		if self.type_de_recherche.currentIndex() == 0:
			condition_tri_OR_AND = " AND "
		else:
			condition_tri_OR_AND = " OR "
		
		requete = "SELECT * from `%s` WHERE (" % mysql_Nom_de_table
		
		nb_ligne = self.qtableWidget_param.rowCount()
		mon_dict = {}
		for num_ligne_tri in range(nb_ligne): #dans toutes lignes du tableau de tri
			cellule_col_0_text = self.qtableWidget_param.cellWidget(num_ligne_tri,0).currentText()
			for elem in range(len(self.TRI_mon_list_de_list_de_parametres_de_tri)):
				if cellule_col_0_text == self.TRI_mon_list_de_list_de_parametres_de_tri[elem][6]:
					text_ref_sql = self.TRI_mon_list_de_list_de_parametres_de_tri[elem][0]
			#if mode_debuggage == 'oui': print "text_ref_sql"
			#if mode_debuggage == 'oui': print unicode(text_ref_sql).encode("cp850")
			
			
			"""
			self.var_contient = "contient"
			self.var_contient_pas = "ne contient pas"
			self.var_egal_a = "est égal à"
			self.var_inf_a = "est inférieur à"
			self.var_sup_a = "est supérieur à"
			self.var_est = "est"
			self.var_n_est_pas = "n'est pas"
			self.var_avant = "se trouve avant"
			self.var_apres = "se trouve après"
			"""
			cellule_col_1_text = self.qtableWidget_param.cellWidget(num_ligne_tri,1).currentText()
			if cellule_col_1_text == self.var_contient or cellule_col_1_text == self.var_commence_par or cellule_col_1_text == self.var_finit_par:
				condition = " LIKE "
			elif cellule_col_1_text == self.var_contient_pas:
				condition = " NOT LIKE "
			elif cellule_col_1_text == self.var_egal_a:
				condition = " = "
			elif cellule_col_1_text == self.var_inf_a:
				condition = " <= "
			elif cellule_col_1_text == self.var_sup_a:
				condition = " >= "
			elif cellule_col_1_text == self.var_est:
				condition = " = "
			elif cellule_col_1_text == self.var_n_est_pas:
				condition = " != "
			elif cellule_col_1_text == self.var_avant:
				condition = " <= "
			elif cellule_col_1_text == self.var_apres:
				condition = " >= "
			
			#bug possible sur les chiffres interprétés en string: à priori tout se passe bien !!!
			
			cellule_col_2 = self.qtableWidget_param.cellWidget(num_ligne_tri,2)
			QCB = QtGui.QComboBox()
			QLE = QtGui.QLineEdit()
			QDE = QtGui.QDateEdit()
			if type(cellule_col_2) == type(QCB):
				cellule_col_2_text = cellule_col_2.currentText()
			elif type(cellule_col_2) == type(QLE):
				cellule_col_2_text = cellule_col_2.text()
			elif type(cellule_col_2) == type(QDE):
				cellule_col_2_text = cellule_col_2.date().toString(QtCore.Qt.ISODate)
			
			
			if mode_debuggage == 'oui': print "type((cellule_col_2_text))"
			if mode_debuggage == 'oui': print type((cellule_col_2_text))
			
			toto = copy.deepcopy(unicode(cellule_col_2_text))
			if mode_debuggage == 'oui': print "type(toto)"
			if mode_debuggage == 'oui': print type(toto)
			
			
			if condition == " = ": #Gestion de l'égalité en mysql: en fait on fait un arrondi
				if mode_debuggage == 'oui': print "egalite avec float"
				indice = 'dict_A%s' % (num_ligne_tri)
				requete = requete + '`' +unicode(text_ref_sql) + '`' + ' >= ' + '(%(' +str(indice)+ ')s - 0.001)' +' AND ' \
				+ '`' + unicode(text_ref_sql) + '`' + ' <= ' + '(%(' +str(indice)+ ')s + 0.001)' + condition_tri_OR_AND
				
			else:
				indice = 'dict_A%s' % (num_ligne_tri)
				requete = requete + '`' +unicode(text_ref_sql) + '`' + unicode(condition) + '%(' +str(indice)+ ')s' + condition_tri_OR_AND
			
			
			if cellule_col_1_text == self.var_contient or cellule_col_1_text == self.var_contient_pas:
				mon_dict[indice] = unicode('%') + unicode(cellule_col_2_text) + unicode('%')
			elif cellule_col_1_text == self.var_finit_par:
				mon_dict[indice] = unicode('%') + unicode(cellule_col_2_text)
			elif cellule_col_1_text == self.var_commence_par:
				mon_dict[indice] = unicode(cellule_col_2_text) + unicode('%')
			else:
				mon_dict[indice] = unicode(cellule_col_2_text)
			
		#if mode_debuggage == 'oui': print ""
		#if mode_debuggage == 'oui': print "mon_dict"
		#if mode_debuggage == 'oui': print mon_dict
			
			
		if condition_tri_OR_AND == " AND ":
			requete = requete[:-5]
		elif condition_tri_OR_AND == " OR ":
			requete = requete[:-4]
		requete = requete + ")"
		
		
		#self.ordre_de_tri_1
		#self.ordre_de_tri_2
		#self.ordre_de_tri_3
		if self.ordre_de_tri_1.currentText() != "" or self.ordre_de_tri_2.currentText() != "" or self.ordre_de_tri_3.currentText() != "":
			requete = requete + " ORDER BY "
			requete_rapide_order = " ORDER BY "
			if self.ordre_de_tri_1.currentText() != "":
				for elem in range(len(self.TRI_mon_list_de_list_de_parametres_de_tri)):
					if self.ordre_de_tri_1.currentText() == self.TRI_mon_list_de_list_de_parametres_de_tri[elem][6]:
						text_ref_ordre_de_tri_1 = self.TRI_mon_list_de_list_de_parametres_de_tri[elem][0]
				if self.asc_desc_1.currentIndex() == 0:
					asc_desc_1 = " ASC,"
				else:
					asc_desc_1 = " DESC,"
				requete = requete + '`' + unicode(text_ref_ordre_de_tri_1) + '`' + asc_desc_1
				requete_rapide_order = requete_rapide_order + '`' + unicode(text_ref_ordre_de_tri_1) + '`' + asc_desc_1
			
			if self.ordre_de_tri_2.currentText() != "":
				for elem in range(len(self.TRI_mon_list_de_list_de_parametres_de_tri)):
					if self.ordre_de_tri_2.currentText() == self.TRI_mon_list_de_list_de_parametres_de_tri[elem][6]:
						text_ref_ordre_de_tri_2 = self.TRI_mon_list_de_list_de_parametres_de_tri[elem][0]
				if self.asc_desc_2.currentIndex() == 0:
					asc_desc_2 = " ASC,"
				else:
					asc_desc_2 = " DESC,"
				requete = requete + '`' + unicode(text_ref_ordre_de_tri_2) + '`' + asc_desc_2
				requete_rapide_order = requete_rapide_order + '`' + unicode(text_ref_ordre_de_tri_2) + '`' + asc_desc_2
			
			if self.ordre_de_tri_3.currentText() != "":
				for elem in range(len(self.TRI_mon_list_de_list_de_parametres_de_tri)):
					if self.ordre_de_tri_3.currentText() == self.TRI_mon_list_de_list_de_parametres_de_tri[elem][6]:
						text_ref_ordre_de_tri_3 = self.TRI_mon_list_de_list_de_parametres_de_tri[elem][0]
				if self.asc_desc_3.currentIndex() == 0:
					asc_desc_3 = " ASC,"
				else:
					asc_desc_3 = " DESC,"
				requete_rapide_order = requete_rapide_order + '`' + unicode(text_ref_ordre_de_tri_3) + '`' + asc_desc_3
			requete = requete[:-1]
		else:
			requete = requete
			requete_rapide_order = ")"
		
		if mode_debuggage == 'oui': print "requete"
		if mode_debuggage == 'oui': print unicode(requete).encode("cp850")
		
		#if mode_debuggage == 'oui': print desfi
		
		mon_ftp = class_FTP_ou_SFTP()
		id=mon_ftp.FTP_ou_SFTP()
		cur=id.cursor()
	#	cur.execute("select * from %s" % mysql_Nom_de_table)
		if index_unique != "no_index": #recherche sur la ligne précise contenant l'index
			requete_index_unique = "SELECT * from `%s` WHERE (`index` = %s) " % (mysql_Nom_de_table,index_unique)
			cur.execute(requete_index_unique)
		else: #recherche normale ou rapide
			if self.lineEdit_rapide.text() == "": #recherche normale
				cur.execute(requete, mon_dict)
			else: #recherche rapide
				requete_rapide1 = "SELECT * from `%s` WHERE ((" % mysql_Nom_de_table
				####
				cur2=id.cursor()
				#cur.execute("select * from %s order by affaire_QLE" % mysql_Nom_de_table)
				cur2.execute("SELECT COLUMN_NAME, COLUMN_TYPE, IS_NULLABLE, COLUMN_KEY, COLUMN_DEFAULT, COLUMN_COMMENT FROM INFORMATION_SCHEMA.COLUMNS WHERE table_name = '%s'" % mysql_Nom_de_table)
				structure_table = list(cur2.fetchall())
				cur2.close()
				####
				#if mode_debuggage == 'oui': print "structure_table"
				#if mode_debuggage == 'oui': print structure_table
				mon_dict_rapide = {}
				if mode_debuggage == 'oui': print "ligne_structure"
				
				
				for num_ligne_rapide in range(len(structure_table)):
					indice = 'dict_B%s' % (num_ligne_rapide)
					mon_dict_rapide[indice] = unicode('%') + unicode(self.lineEdit_rapide.text()) + unicode('%')
				

				t=0
				for ligne_structure in structure_table:
					#mon_dict_rapide[ligne_structure[0]] = unicode('%') + unicode(self.lineEdit_rapide.text()) + unicode('%')
					requete_rapide1 = requete_rapide1 + '`' + unicode(ligne_structure[0]) + '` LIKE ' + '%(dict_B' + str(t)+ ')s OR '
					t=t+1
					#requete = requete + '`' +unicode(text_ref_sql) + '`' + ' >= ' + '(%(' +str(indice)+ ')s - 0.001)' +' AND ' 
				
				requete_rapide1 = requete_rapide1[:-4]
				
				
				if self.CBBX_archives_ou_affaires.currentIndex() == 2: #recherche sur tout y compris archives
					requete_rapide1 = requete_rapide1 + '))'
					
				elif self.CBBX_archives_ou_affaires.currentIndex() == 1: #recherche sur "affaires archivées seules"
					requete_case_coche_archive = unicode("`avancement#QCB` LIKE 'affaire archivée' OR `avancement#QCB` LIKE 'expertise archivée'", "iso-8859-1")
					requete_rapide1 = requete_rapide1 + ') AND (' + requete_case_coche_archive + '))'
					
				elif self.CBBX_archives_ou_affaires.currentIndex() == 0: #rechaerche sur concours et affaire seules
					#Avancement#-#concours#-#étude#-#chantier#-#concours à archiver#-#concours archivé#-#affaire à archiver#-#affaire archivée#-#expertise#-#expertise à archiver#-#expertise archivée#&#pas_de_mdp
					requete_case_coche_archive = unicode("`avancement#QCB` LIKE 'concours' OR `avancement#QCB` LIKE 'étude' OR `avancement#QCB` LIKE 'chantier' OR `avancement#QCB` LIKE 'expertise'", "iso-8859-1")
					requete_rapide1 = requete_rapide1 + ') AND (' + requete_case_coche_archive + '))'
				
				requete_rapide_totale = requete_rapide1 + requete_rapide_order
				requete_rapide_totale = requete_rapide_totale[:-1]
				#requete_rapide_totale = requete_rapide1
				if mode_debuggage == 'oui': print "mon_dict_rapide"
				if mode_debuggage == 'oui': print unicode(mon_dict_rapide).encode("cp850")
				if mode_debuggage == 'oui': print "requete_rapide_totale"
				if mode_debuggage == 'oui': print unicode(requete_rapide_totale).encode("cp850")
				
				cur.execute(requete_rapide_totale, mon_dict_rapide)
		
		self.resultat_clic_recherche = list(cur.fetchall())
		cur.close()
		id.commit()
		id.close()
		
		if mode_debuggage == 'oui': print "resultat"
		#if mode_debuggage == 'oui': print self.resultat_clic_recherche
		
		if mode_debuggage == 'oui': print ""
		if mode_debuggage == 'oui': print "self.RESULTAT_mon_list_de_list_de_colonne"
		#if mode_debuggage == 'oui': print self.RESULTAT_mon_list_de_list_de_colonne
		
		#interdit le tri sur entête pour le réactiver à la fin
		self.qtableWidget_resultat.setSortingEnabled(True) #interdit le tri par clic colonne
		
		
		#on nettoie d'abord le tableau s'il il existe
		for i in range(self.qtableWidget_resultat.rowCount()):
			self.qtableWidget_resultat.removeRow(0)
		
		hauteur_de_ligne = 20
		for row in self.resultat_clic_recherche:
			self.qtableWidget_resultat.insertRow(0)	
			self.qtableWidget_resultat.setRowHeight(0,hauteur_de_ligne)
			for i in range(self.qtableWidget_resultat.columnCount()):
				#if mode_debuggage == 'oui': print ""
				#if mode_debuggage == 'oui': print type (row[i])
				#if mode_debuggage == 'oui': print row[i]
				##BIDOUILLE mais pas bidouille du tout
				#Différencier setText et setData ok ça marche
				#http://www.qtcentre.org/threads/29377-QTreeWidget-setSortingEnabled
				if type(row[i]) == long or type(row[i]) == float:
					#if mode_debuggage == 'oui': print 'long-float'
					mon_item = QtGui.QTableWidgetItem()
					mon_item.setData(0,(row[i])) 
					self.qtableWidget_resultat.setItem(0, i ,mon_item)
				elif type(row[i]) == str:
					#if mode_debuggage == 'oui': print 'str'
					mon_item = QtGui.QTableWidgetItem()
					mon_item.setText((row[i]))
					self.qtableWidget_resultat.setItem(0, i ,mon_item)
				else:
					self.qtableWidget_resultat.setItem(0, i ,QtGui.QTableWidgetItem(unicode(row[i])))
				
		#self.qtableWidget_resultat.resizeRowsToContents()
		#self.qtableWidget_resultat.verticalHeader().setResizeMode(QtGui.QHeaderView.ResizeToContents) #resize à chaque fois
		self.qtableWidget_resultat.showGrid()
		
		
		#autorise le tri sur entête
#		self.qtableWidget_resultat.setSortingEnabled(True) #autorise le tri sur entête par clic colonne
		exec("blabla = 'Lignes trouvées: %s'" % (str(self.qtableWidget_resultat.rowCount())))
		self.mon_Qlabel_status_bar2.setText(unicode(blabla, "iso-8859-1"))
		
		QtCore.QObject.connect(self.qtableWidget_resultat,QtCore.SIGNAL("cellClicked(int,int)"),self.RESULTAT_cell_clickee)
		QtCore.QObject.connect(self.qtableWidget_resultat,QtCore.SIGNAL("currentCellChanged(int,int,int,int)"),self.RESULTAT_cell_clickee)
		
		QtGui.QApplication.restoreOverrideCursor()
					
	def recherche_rapide(self):
		if self.lineEdit_rapide.text() == "":
			self.qtableWidget_param.show()
			self.CBBX_archives_ou_affaires.hide()
			self.label_recherche_sur.hide()
			self.label.show()
			self.type_de_recherche.show()
			self.qpush_rechercher.setText("Recherche")
			
		else:
			self.qtableWidget_param.hide()
			self.CBBX_archives_ou_affaires.show()
			self.label_recherche_sur.show()
			self.label.hide()
			self.type_de_recherche.hide()
			self.qpush_rechercher.setText("Rech rapide")
		
		self.FICHE_annuler()
	
	def effacer(self):
		
		if mode_debuggage == 'oui': print "lancer fonction effacer"
		QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)

		"""
		mon_ftp = class_FTP_ou_SFTP()
		id=mon_ftp.FTP_ou_SFTP()
		cur=id.cursor()
		#cur.execute("select * from %s ORDER BY 1 ASC" % mysql_Nom_de_table)
		cur.execute("select * from %s" % mysql_Nom_de_table)
		self.resultat_clic_recherche = list(cur.fetchall())
		cur.close()
		id.commit()
		id.close()
		
		if mode_debuggage == 'oui': print "resultat"
		if mode_debuggage == 'oui': print self.resultat_clic_recherche
		
		if mode_debuggage == 'oui': print ""
		if mode_debuggage == 'oui': print "self.RESULTAT_mon_list_de_list_de_colonne"
		if mode_debuggage == 'oui': print self.RESULTAT_mon_list_de_list_de_colonne
		
		
		#interdit le tri sur entête pour le réactiver à la fin
		self.qtableWidget_resultat.setSortingEnabled(False) #interdit le tri par clic colonne
		
		"""
		#on nettoie d'abord le tableau s'il il existe
		for i in range(self.qtableWidget_resultat.rowCount()):
			self.qtableWidget_resultat.removeRow(0)
		
		"""
		hauteur_de_ligne = 20
		for row in self.resultat_clic_recherche:
			self.qtableWidget_resultat.insertRow(0)	
			self.qtableWidget_resultat.setRowHeight(0,hauteur_de_ligne)
			for i in range(self.qtableWidget_resultat.columnCount()):
				#if mode_debuggage == 'oui': print ""
				#if mode_debuggage == 'oui': print type (row[i])
				#if mode_debuggage == 'oui': print row[i]
				##BIDOUILLE mais pas bidouille du tout
				#Différencier setText et setData ok ça marche
				#http://www.qtcentre.org/threads/29377-QTreeWidget-setSortingEnabled
				if type(row[i]) == long or type(row[i]) == float:
					#if mode_debuggage == 'oui': print 'long-float'
					mon_item = QtGui.QTableWidgetItem()
					mon_item.setData(0,(row[i])) 
					self.qtableWidget_resultat.setItem(0, i ,mon_item)
				elif type(row[i]) == str:
					#if mode_debuggage == 'oui': print 'str'
					mon_item = QtGui.QTableWidgetItem()
					mon_item.setText((row[i]))
					self.qtableWidget_resultat.setItem(0, i ,mon_item)
				else:
					self.qtableWidget_resultat.setItem(0, i ,QtGui.QTableWidgetItem(unicode(row[i])))

		self.qtableWidget_resultat.showGrid()
		
		
		#autorise le tri sur entête
		self.qtableWidget_resultat.setSortingEnabled(True) #autorise le tri sur entête par clic colonne
		exec("blabla = 'Lignes trouvées: %s'" % (str(self.qtableWidget_resultat.rowCount())))
		self.mon_Qlabel_status_bar2.setText(unicode(blabla, "iso-8859-1"))
		"""
		
		QtGui.QApplication.restoreOverrideCursor()
				
	def FICHE_nouveau(self):
		if mode_debuggage == 'oui': print "lancer fonction nouveau"
		self.qpush_nouveau.hide()
		self.qpush_modifier.hide()
		self.qpush_supprimer.hide()
		self.qpush_valider_nouveau.show()
		self.qpush_valider_modif.hide()
		self.qpush_annuler.show()
		
		self.qpush_rechercher.setEnabled(False)
		self.qpush_effacer.setEnabled(False)
		self.lineEdit_rapide.setEnabled(False)
		
		
		self.SCROLL_affichage_selon_modif_ajout_suppr(mon_mode = "nouveau")
				
	def FICHE_modifier(self):
		if self.qtableWidget_resultat.currentRow() != -1:	
			if mode_debuggage == 'oui': print "lancer fonction modifier"
			self.qpush_nouveau.hide()
			self.qpush_modifier.hide()
			self.qpush_supprimer.hide()
			self.qpush_valider_nouveau.hide()
			self.qpush_valider_modif.show()
			self.qpush_annuler.show()
			
			self.qpush_rechercher.setEnabled(False)
			self.qpush_effacer.setEnabled(False)
			self.lineEdit_rapide.setEnabled(False)
				
			self.SCROLL_affichage_selon_modif_ajout_suppr(mon_mode = "modif")
		
		else:
			texte_titre = unicode("Sélection impossible", "iso-8859-1")
			msg = unicode("Vous devez sélectionner une ligne", "iso-8859-1")
			QtGui.QApplication.restoreOverrideCursor()
			QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
			ma_boite = QtGui.QMessageBox(MainWindow)
			ma_boite.setIcon(QtGui.QMessageBox.Warning)
			ma_boite.setInformativeText(msg)
			ma_boite.setWindowTitle(texte_titre)
			ma_boite.addButton(_fromUtf8("Fermer"), 0)
			reponse = ma_boite.exec_()

	def FICHE_supprimer(self):
		if mode_debuggage == 'oui': print "lancer fonction effacer"	
		
		self.SCROLL_affichage_selon_modif_ajout_suppr(mon_mode = "suppression")
		self.FICHE_action_supprimer()
	
	def sizedirectory(self, path): 
		size = 0 
		for root, dirs, files in os.walk(path): 
			for fic in files: 
				size += os.path.getsize(os.path.join(root, fic))
		return size

	
	def FICHE_action_supprimer(self):
		
		for num_ligne in range(1,self.mon_grid_area.rowCount()):
			toto = self.mon_grid_area.itemAtPosition(num_ligne,0).widget()
			if self.mon_grid_area.itemAtPosition(num_ligne,0).widget().text() == "Affaire":
				nom_affaire1 = self.mon_grid_area.itemAtPosition(num_ligne,1).widget().text()

			if self.mon_grid_area.itemAtPosition(num_ligne,0).widget().text() == "Avancement":
				mon_avancement = self.mon_grid_area.itemAtPosition(num_ligne,1).widget().currentText()
		
		
		#if mode_debuggage == 'oui': print sys.stdin.encoding ## cp1252 sous IDLE, cp850 sous la console Python
		#machaine = 'äâ'  ## machaine est une chaîne encodée selon l'encodage sys.stdin.encoding
		#unicode(machaine, sys.stdin.encoding)
	
	
		if nom_affaire1 != "":
			texte_titre = "Suppression fiche"
			msg_debut = "Affaire:\n " 
			msg_debut2 = unicode(msg_debut, "iso-8859-1") #ce que j'écris en texte dans mon code est en ISO-8859-1 c'est pour ça que unicode(machaine, sys.stdin.encoding) ne sert pas
			nom_affaire = unicode(nom_affaire1) # pas besoin de sys.stdin.encoding, puisque ça vient d'ailleurs
			msg_fin = "\nEtes-vous sûr de vouloir supprimer cette fiche ?"
			msg_fin2 = unicode(msg_fin, "iso-8859-1")
			msg_total = msg_debut2 + nom_affaire + msg_fin2
			QtGui.QApplication.restoreOverrideCursor()
			QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
			ma_boite = QtGui.QMessageBox(MainWindow)
			ma_boite.setIcon(QtGui.QMessageBox.Warning)
			ma_boite.setWindowTitle(texte_titre)
			ma_boite.setInformativeText(msg_total)
			ma_boite.addButton(_fromUtf8("Ok"), 0)
			ma_boite.addButton(_fromUtf8("Annuler"), 1)
			reponse = ma_boite.exec_()
			
			if mode_debuggage == 'oui': print "reponse"
			if mode_debuggage == 'oui': print reponse
			if reponse == 0:
				if mode_debuggage == 'oui': print "SQL creer fonction supprimer fiche"
				
				ligne_actuelle = self.qtableWidget_resultat.currentRow()
				ref_index = self.qtableWidget_resultat.item(ligne_actuelle,0).data(0).toString() # on récupère le texte
				if mode_debuggage == 'oui': print "ref_index"
				if mode_debuggage == 'oui': print ref_index
				
				
				mon_ftp = class_FTP_ou_SFTP()
				id=mon_ftp.FTP_ou_SFTP()
				cur=id.cursor()
				requete = ("delete from %s where (`%s`=%s)" % (mysql_Nom_de_table, self.SCROLL_AREA_mon_list_de_list_de_champs[0][0], (ref_index)))
				
				if mode_debuggage == 'oui': print requete
				cur.execute(requete)
				cur.close()
				id.commit()
				id.close()
				
				texte_titre = "Suppression fiche"
				msg_debut = "L'affaire:\n " 
				msg_debut2 = unicode(msg_debut, "iso-8859-1") #ce que j'écris en texte dans mon code est en ISO-8859-1 c'est pour ça que unicode(machaine, sys.stdin.encoding) ne sert pas
				nom_affaire = unicode(nom_affaire1) # pas besoin de sys.stdin.encoding, puisque ça vient d'ailleurs
				msg_fin = "\na été supprimée"
				msg_fin2 = unicode(msg_fin, "iso-8859-1")
				msg_total = msg_debut2 + nom_affaire + msg_fin2
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Information)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_total)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				ma_boite.addButton(_fromUtf8("Annuler"), 1)
				reponse = ma_boite.exec_()
				
				###### DEBUT REPERTOIRE ####
				effacer_chemin_repertoire = self.concat_chemin(mon_avancement, nom_affaire1)
				if mode_debuggage == 'oui': print "effacer_chemin_repertoire"
				if mode_debuggage == 'oui': print effacer_chemin_repertoire
				if os.path.isdir(effacer_chemin_repertoire) == True:
					#os.rmdir(path)
					taille = self.sizedirectory(unicode(effacer_chemin_repertoire))
					if taille == 0:
						if mode_debuggage == 'oui': print "taille nulle"
						os.rmdir(effacer_chemin_repertoire)
					elif taille != 0:
						texte_titre = "Répertoire non supprimé"
						msg_total = "Le répertoire de cette affaire n'est pas vide. Vous devez effectuer la suppresion manuellement"
						QtGui.QApplication.restoreOverrideCursor()
						QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
						ma_boite = QtGui.QMessageBox(MainWindow)
						ma_boite.setIcon(QtGui.QMessageBox.Warning)
						ma_boite.setWindowTitle(texte_titre)
						ma_boite.setInformativeText(msg_total)
						ma_boite.addButton(_fromUtf8("Ok"), 0)
						reponse = ma_boite.exec_()
					
				
				elif os.path.isdir(effacer_chemin_repertoire) == False:
					texte_titre = "Répertoire non supprimé"
					msg_total = "Le répertoire de cette affaire n'existe pas"
					QtGui.QApplication.restoreOverrideCursor()
					QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
					ma_boite = QtGui.QMessageBox(MainWindow)
					ma_boite.setIcon(QtGui.QMessageBox.Warning)
					ma_boite.setWindowTitle(texte_titre)
					ma_boite.setInformativeText(msg_total)
					ma_boite.addButton(_fromUtf8("Ok"), 0)
					reponse = ma_boite.exec_()
				###### FIN REPERTOIRE ####
				
				
						
				
				self.rechercher() # on relance le boton rechercher
				
				
			elif reponse == 1:
				if mode_debuggage == 'oui': print "annuler"
				self.SCROLL_affichage_selon_modif_ajout_suppr(mon_mode = "annuler")
		else:	
			texte_titre = "Action impossible"
			msg_total = "Le nom de l'affaire est vide"
			QtGui.QApplication.restoreOverrideCursor()
			QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
			ma_boite = QtGui.QMessageBox(MainWindow)
			ma_boite.setIcon(QtGui.QMessageBox.Critical)
			ma_boite.setWindowTitle(texte_titre)
			ma_boite.setInformativeText(msg_total)
			ma_boite.addButton(_fromUtf8("Fermer"), 0)
			reponse = ma_boite.exec_()
			
			self.SCROLL_affichage_selon_modif_ajout_suppr(mon_mode = "annuler")
			if mode_debuggage == 'oui': print "annuler"
			
	def FICHE_valider_nouveau_ou_modif(self, nouveau_ou_modif='nouveau'): #=nouveau par défaut
		QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
		
		
		if mode_debuggage == 'oui': print "def valider_nouveau"
		if GLOBAL_modif_unique_ou_multiple == "multiple":
			nouveau_ou_modif = "modif_multiple"
		
		#self.SCROLL_AREA_mon_list_de_list_de_champs c'est là où ya tout dans l'ordre qui va bien
		#methode: on crée une matrice dans laquelle on récupère tout les blabla et ensuite on sait que les champs correspondent avec l'ordre du self.SCROLL_AREA_mon_list_de_list_de_champs
		
		mon_QCB = QComboBox_boost_SCROLL()
		mon_QLE = QtGui.QLineEdit()
		mon_QTE = QtGui.QTextEdit()
		mon_QDE = QDateEdit_boost_SCROLL()
		mon_QLW = QListWidget_boost_SCROLL()
		mon_QPB = QtGui.QPushButton()
		if mode_debuggage == 'oui': print type(mon_QCB)
		if mode_debuggage == 'oui': print type(mon_QLE)
		if mode_debuggage == 'oui': print type(mon_QTE)
		if mode_debuggage == 'oui': print type(mon_QDE)
		if mode_debuggage == 'oui': print type(mon_QLW)
		
		
		if mode_debuggage == 'oui': print "tous les blabla"
		list_blabla = []
		for num_ligne in range(1,self.mon_grid_area.rowCount()):
			mon_widget = self.mon_grid_area.itemAtPosition(num_ligne,1).widget()
			
			if type(mon_widget) == type(QComboBox_boost_SCROLL()):
				blabla = mon_widget.currentText() #.setEditText (self, QString text) ?pas sûr
				if self.mon_grid_area.itemAtPosition(num_ligne,0).widget().text() == "Avancement": #REPLACE accents
					mon_avancement = blabla
			elif type(mon_widget) == type(QtGui.QLineEdit()):
				blabla = mon_widget.displayText() #setText()
				if self.mon_grid_area.itemAtPosition(num_ligne,0).widget().text() == "Affaire": #REPLACE accents
					blabla = self.accents_transformation(blabla)
					titre_affaire = self.accents_transformation(blabla)
					
			elif type(mon_widget) == type(QtGui.QTextEdit()):
				blabla = mon_widget.toPlainText()  #Use toPlainText() to get the current text. Use setPlainText() to set the text.
			elif type(mon_widget) == type(QDateEdit_boost_SCROLL()):
				blabla = mon_widget.date().toString(QtCore.Qt.ISODate) #pour que mysal reçoic en champ DATE du AAAA-MM--JJ
			elif type(mon_widget) == type(QListWidget_boost_SCROLL()):#plusieurs lignes possibles
				list_de_widget = mon_widget.selectedItems()
				mon_text = ""
				for mon_qlistwidgetitem in list_de_widget:
					mon_text = mon_text + mon_qlistwidgetitem.text() + "##"
				blabla = mon_text[:-2] #enlève led deux derniers caractères
				#blabla = list_de_widget
			else:
				if mode_debuggage == 'oui': print "erreur objet non reconnu"
				blabla = "erreur"
			
			
			if mode_debuggage == 'oui': print type(mon_widget)
			if mode_debuggage == 'oui': print type(blabla)
			if mode_debuggage == 'oui': print unicode(blabla).encode("cp850")
			if nouveau_ou_modif == "modif_multiple":
				if mon_widget.isEnabled() == True:
					list_blabla.append(blabla)
				elif  mon_widget.isEnabled() == False:
					list_blabla.append(19996142556523) #on insere un truc à la con qd le widget est disabled
			else:
				list_blabla.append(blabla)
		if mode_debuggage == 'oui': print "list_blabla"
		if mode_debuggage == 'oui': print list_blabla
		if mode_debuggage == 'oui': print ""
		
		if nouveau_ou_modif == 'modif':
			if mode_debuggage == 'oui': print "self.ligne_avant_modif select mysql"
			if mode_debuggage == 'oui': print self.ligne_avant_modif[0]
			
			if mode_debuggage == 'oui': print "TABLEAU self.ligne_cliquee_avant_modif"
			if mode_debuggage == 'oui': print self.ligne_cliquee_avant_modif
			
			if self.ligne_avant_modif[0] != self.ligne_cliquee_avant_modif:
				if mode_debuggage == 'oui': print "erreur qqun a modifié la base"
				return "modification impossible" #on sorte de la fonction avec le return !
			else:
				if mode_debuggage == 'oui': print "ok modif possible"
	
		mon_dict = {}
		for num in range(1,len(self.SCROLL_AREA_mon_list_de_list_de_champs)):
			mon_widget_col_0 = self.mon_grid_area.itemAtPosition(num,0).widget() #attention bug possible pour modif multiple
			#if mode_debuggage == 'oui': print ""
			#if mode_debuggage == 'oui': print self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]
			#if mode_debuggage == 'oui': print list_blabla[num-1]
			
			type_de_donnees = self.SCROLL_AREA_mon_list_de_list_de_champs[num][1]
			if type_de_donnees[:3] == "int":
				if mode_debuggage == 'oui': print "int"
				if list_blabla[num-1] == "":
					valeur = 0
				else: 
					valeur = int(list_blabla[num-1])
				
				if nouveau_ou_modif == "modif_multiple":
					if mon_widget_col_0.isEnabled() == True:
						mon_dict[self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]]=valeur #dictionnaire
				else:
					mon_dict[self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]]=valeur #dictionnaire
					if mode_debuggage == 'oui': print type(valeur)
				
			elif type_de_donnees[:5] == "float":
				if mode_debuggage == 'oui': print "float"
				if list_blabla[num-1] == "":
					valeur = 0.0
				else: 
					valeur = float(list_blabla[num-1])
				if nouveau_ou_modif == "modif_multiple":
					if mon_widget_col_0.isEnabled() == True:
						mon_dict[self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]]=valeur #dictionnaire
				else:
					mon_dict[self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]]=valeur #dictionnaire
					if mode_debuggage == 'oui': print type(valeur)
			else:
				if nouveau_ou_modif == "modif_multiple":
					if mon_widget_col_0.isEnabled() == True:
						mon_dict[self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]]=unicode(list_blabla[num-1]) #dictionnaire
				else:
					mon_dict[self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]]=unicode(list_blabla[num-1]) #dictionnaire
			

		if mode_debuggage == 'oui': print "mon_dict"
		if mode_debuggage == 'oui': print "len(mon_dict)"
		if mode_debuggage == 'oui': print len(mon_dict)
		if mode_debuggage == 'oui': print mon_dict
		
		if nouveau_ou_modif != "modif_multiple":
		
			####
			if mode_debuggage == 'oui': print "self.SCROLL_AREA_mon_list_de_list_de_champs"
			if mode_debuggage == 'oui': print self.SCROLL_AREA_mon_list_de_list_de_champs
			for num in range(1,len(self.SCROLL_AREA_mon_list_de_list_de_champs)):
				monsplit2 = self.SCROLL_AREA_mon_list_de_list_de_champs[num][0].split('#')
				monsplit5 = self.SCROLL_AREA_mon_list_de_list_de_champs[num][5].split('#&#')
				if mode_debuggage == 'oui': print monsplit2
				if mode_debuggage == 'oui': print monsplit5
				
				try:
					toto = monsplit2[2] # on tente de récupérer le truc
					mon_objet = "existant"
				except:
					mon_objet = "pas_existant"
					
				if mon_objet == "existant":
					if monsplit2[2]== "QPB" and monsplit5[1] == "pas_de_mdp":
						if mode_debuggage == 'oui': print ""
						if mode_debuggage == 'oui': print "detection dun QPB a droite et sans mot de passe"
						#connection à la table monsplit2[4], champ numéro monsplit2[5]
						
						requete = ("select * from %s " % (monsplit2[4]))
						
						mon_ftp = class_FTP_ou_SFTP()
						id=mon_ftp.FTP_ou_SFTP()
						cur=id.cursor()
						#if mode_debuggage == 'oui': print "requete"
						#if mode_debuggage == 'oui': print requete
						cur.execute(requete)
						tableau_resultat = list(cur.fetchall())
						cur.close()
						id.commit()
						id.close()
						
						if mode_debuggage == 'oui': print "tableau_resultat"
						if mode_debuggage == 'oui': print tableau_resultat
						
						
						trouve_oui_non = "non" 
						for num2 in range(len(tableau_resultat)):
							if mode_debuggage == 'oui': print ""
							if mode_debuggage == 'oui': print "recherche comparaison"
							#if mode_debuggage == 'oui': print mon_dict[self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]].decode("iso-8859-1")
							#if mode_debuggage == 'oui': print tableau_resultat[num2][0].decode("iso-8859-1")
							if mon_dict[self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]] == tableau_resultat[num2][0].decode("iso-8859-1"):
								if mode_debuggage == 'oui': print "element trouve donc RAS"
								trouve_oui_non = "oui"
								
						if trouve_oui_non == "non": #si on n'a pas réussi à trouver l'info dans la base associée au champ
							if mode_debuggage == 'oui': print "soit le champ a ete vraiment supprime, soit cest une modif entre temps"
							#scanner le champ en question pour trouver le champ en italique souligne
							#si c'esun vrai champ supprimé, on continue sans problème
							#si c'est une modif entre temps: message d'erreur et RETURN return "modification impossible" ????
							
							for num_elem in range(len(self.TRI_mon_list_de_list_de_parametres_de_tri)):
								try:
									self.mon_grid_area.itemAtPosition(num_elem,0).widget().text()
									suite = "oui"
								except:
									suite = "non"
								if suite == "oui":
									if mode_debuggage == 'oui': print "comparaison"
									if mode_debuggage == 'oui': print unicode(self.mon_grid_area.itemAtPosition(num_elem,0).widget().text()).encode("CP850")
									if mode_debuggage == 'oui': print unicode(self.SCROLL_AREA_mon_list_de_list_de_champs[num][6]).encode("CP850")
									
									if self.mon_grid_area.itemAtPosition(num_elem,0).widget().text() == self.SCROLL_AREA_mon_list_de_list_de_champs[num][6]:
										#on recupere le widget correspondant:
										if mode_debuggage == 'oui': print "correspondance ok"
										mon_widget = self.mon_grid_area.itemAtPosition(num_elem,1).widget()
										if mode_debuggage == 'oui': print type(mon_widget)
										if mode_debuggage == 'oui': print type(QComboBox_boost_SCROLL())
										
										if type(QComboBox_boost_SCROLL()) == type(mon_widget):
											if mode_debuggage == 'oui': print "mon_widget.itemText(num3_cbbx)"
											element_modifie_entre_temps = "oui"
											for num3_cbbx in range(mon_widget.count()):
												#if mode_debuggage == 'oui': print unicode(mon_widget.itemText(num3_cbbx)).encode("cp850")
												qfont_detecte = mon_widget.itemData(num3_cbbx, QtCore.Qt.FontRole) #pas de bug, mais se poser la question pour les Qlistwidget....
												if qfont_detecte.typeName() == "QFont": 
													#if mode_debuggage == 'oui': print qfont_detecte.typeName()
													convertionok = qfont_detecte.Font
													if mode_debuggage == 'oui': print "convertionok"
													#if mode_debuggage == 'oui': print qfont_detecte.toString()
													monQFont = QtGui.QFont()
													monQFont.setItalic(True) #italique
													monQFont.setBold(True) #gras
													
													pour_comparer = QtCore.QVariant(monQFont).toString()
													#si le text actuel du CBX est retrouvé dans la liste des item en gras italique, alors c'est bon
													if mon_widget.currentText() == mon_widget.itemText(num3_cbbx) and qfont_detecte.toString() == pour_comparer:
														element_modifie_entre_temps = "non"
											
											if element_modifie_entre_temps == "oui":
												texte_titre = unicode("Cas rarissime MySQL", "iso-8859-1")
												msg1 = unicode("Modification non effectuée\nLe champ: \n ", "iso-8859-1")
												#msg2 = unicode(self.mon_grid_area.itemAtPosition(num_elem,0).widget().text(), "iso-8859-1") #ce que j'écris en texte dans mon code est en ISO-8859-1 c'est pour ça que unicode(machaine, sys.stdin.encoding) ne sert pas
												msg2 = unicode(self.mon_grid_area.itemAtPosition(num_elem,0).widget().text()) #ce que j'écris en texte dans mon code est en ISO-8859-1 c'est pour ça que unicode(machaine, sys.stdin.encoding) ne sert pas
												msg3 = unicode("\ncontenant le texte: \n", "iso-8859-1") # pas besoin de sys.stdin.encoding, puisque ça vient d'ailleurs
												msg4 = unicode(unicode(mon_widget.currentText())) # pas besoin de sys.stdin.encoding, puisque ça vient d'ailleurs
												msg5 = unicode("\na été modifiée par une personne extérieure depuis votre denière connexion. Vous devez redémarrer l'application", "iso-8859-1")
												
												msg_total = msg1 + msg2 + msg3 + msg4 + msg5
												QtGui.QApplication.restoreOverrideCursor()
												QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
												ma_boite = QtGui.QMessageBox(MainWindow)
												ma_boite.setIcon(QtGui.QMessageBox.Information)
												ma_boite.setWindowTitle(texte_titre)
												ma_boite.setInformativeText(msg_total)
												ma_boite.addButton(_fromUtf8("Ok"), 0)
												ma_boite.addButton(_fromUtf8("Annuler"), 1)
												reponse = ma_boite.exec_()
												return "mis a jour entre temps" #le return n'est pas repris par une autre fonction
										
										elif type(QListWidget_boost_SCROLL()) == type(mon_widget):
											if mode_debuggage == 'oui': print "BUG boulot a faire pour le modification entre le temps de deux connections d'un Qlist widget avec bouton sans mot de passe"
											#mais dans cette application, ça ne doit pas pouvoir arriver...
										
										
										else:
											if mode_debuggage == 'oui': print "erreur qqun a modifié la base"
											texte_titre = "Erreur de programmation"
											msg_debut = "Erreur de programmation, ce cas n'a pas été prévu, contactez votre administrateur" 
											QtGui.QApplication.restoreOverrideCursor()
											QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
											ma_boite = QtGui.QMessageBox(MainWindow)
											ma_boite.setIcon(QtGui.QMessageBox.Warning)
											ma_boite.setWindowTitle(texte_titre)
											ma_boite.setInformativeText(msg_debut)
											ma_boite.addButton(_fromUtf8("Ok"), 0)
											reponse = ma_boite.exec_()

			
		#ICI TOTO debut_requete = ("insert into %s (%s) values " % (mysql_Nom_de_table, self.ma_structure_table[0][0]))
		compteur_champs_a_modifier = -10
		if nouveau_ou_modif == "nouveau":
			debut_requete = ("insert into %s (" % (mysql_Nom_de_table))
			suite_requete = debut_requete
			
			#liste des champs
			for num in range(1,len(self.SCROLL_AREA_mon_list_de_list_de_champs)):
				#if mode_debuggage == 'oui': print self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]
				exec("suite_requete = suite_requete + '`%s`' + ','" % (self.SCROLL_AREA_mon_list_de_list_de_champs[num][0])) #altgr+7 à cause du dièse
				
			suite_requete = suite_requete[:-1] #enlève le dernier caractère
			suite_requete = suite_requete + ") values ("
			
			#   %%% des prévaleurs
			for num in range(1,len(self.SCROLL_AREA_mon_list_de_list_de_champs)):
				#if mode_debuggage == 'oui': print self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]
				#exec("suite_requete = suite_requete + '%('+ %s +')s' + ','" % (self.SCROLL_AREA_mon_list_de_list_de_champs[num+1][0]))
				
				
				type_de_donnees = self.SCROLL_AREA_mon_list_de_list_de_champs[num][1]
				exec("suite_requete = suite_requete + '%'")
				exec("suite_requete = suite_requete + '('+ '%s' +')s' + ','" % (self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]))
				
			
			suite_requete = suite_requete[:-1]
			suite_requete = suite_requete+ ")"
			
			if mode_debuggage == 'oui': print "suite_requete"
			if mode_debuggage == 'oui': print suite_requete
		
		elif nouveau_ou_modif == "modif":
			if mode_debuggage == 'oui': print "ici la modif"
			#nb_ligne_modifiees = cur.execute("UPDATE preferences_utilisateurs SET ordre_col_tableau_resultat=%s WHERE (nom_utilisateur=%s)", \
			#(str(matrice_colonnes_resultat), unicode(GLOBAL_config_actuelle_finale)))
			######
			debut_requete = ("UPDATE %s SET " % (mysql_Nom_de_table))
			suite_requete = debut_requete
			
			#liste des champs
			if mode_debuggage == 'oui': print "len(self.SCROLL_AREA_mon_list_de_list_de_champs)"
			if mode_debuggage == 'oui': print len(self.SCROLL_AREA_mon_list_de_list_de_champs)
			
			for num in range(1,len(self.SCROLL_AREA_mon_list_de_list_de_champs)):
				#if mode_debuggage == 'oui': print self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]
				exec("suite_requete = suite_requete + '`%s`'" % (self.SCROLL_AREA_mon_list_de_list_de_champs[num][0])) #altgr+7 à cause du dièse
				exec("suite_requete = suite_requete + '=%('")
				exec("suite_requete = suite_requete + '%s' + ')s,' " % (self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]))
				
			suite_requete = suite_requete[:-1] #enlève le dernier caractère
			#suite_requete = suite_requete+ ")"
			
			ligne_actuelle = self.qtableWidget_resultat.currentRow()
			ref_index = self.qtableWidget_resultat.item(ligne_actuelle,0).data(0).toString() # on récupère le texte
			if mode_debuggage == 'oui': print "############ref_index#############"
			if mode_debuggage == 'oui': print ref_index
			if mode_debuggage == 'oui': print "ligne_actuelle"
			if mode_debuggage == 'oui': print ligne_actuelle
			if mode_debuggage == 'oui': print ""
			exec("suite_requete = suite_requete + ' WHERE (`%s`=%s)'"  % (self.SCROLL_AREA_mon_list_de_list_de_champs[0][0],str(ref_index)))
		
		elif nouveau_ou_modif == "modif_multiple":
			if mode_debuggage == 'oui': print "ici la modif_multiple"
			#nb_ligne_modifiees = cur.execute("UPDATE preferences_utilisateurs SET ordre_col_tableau_resultat=%s WHERE (nom_utilisateur=%s)", \
			#(str(matrice_colonnes_resultat), unicode(GLOBAL_config_actuelle_finale)))
			######
			debut_requete = ("UPDATE %s SET " % (mysql_Nom_de_table))
			suite_requete = debut_requete
			
			#liste des champs
			if mode_debuggage == 'oui': print "len(self.SCROLL_AREA_mon_list_de_list_de_champs)"
			if mode_debuggage == 'oui': print len(self.SCROLL_AREA_mon_list_de_list_de_champs)
			
			if mode_debuggage == 'oui': print ""
			if mode_debuggage == 'oui': print "mon_dict"
			if mode_debuggage == 'oui': print mon_dict
			
			compteur_champs_a_modifier = 0
			for num in range(1,len(self.SCROLL_AREA_mon_list_de_list_de_champs)):
				if mode_debuggage == 'oui': print "num"
				if mode_debuggage == 'oui': print num
				if mode_debuggage == 'oui': print self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]
				if mode_debuggage == 'oui': print mon_dict[self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]]
				if mon_dict[self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]] != 19996142556523 and \
				mon_dict[self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]] != "19996142556523" and \
				mon_dict[self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]] != 19996142556523.0:
					compteur_champs_a_modifier = compteur_champs_a_modifier + 1
					#if mode_debuggage == 'oui': print self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]
					exec("suite_requete = suite_requete + '`%s`'" % (self.SCROLL_AREA_mon_list_de_list_de_champs[num][0])) #altgr+7 à cause du dièse
					exec("suite_requete = suite_requete + '=%('")
					exec("suite_requete = suite_requete + '%s' + ')s,' " % (self.SCROLL_AREA_mon_list_de_list_de_champs[num][0]))
				
			suite_requete = suite_requete[:-1] #enlève le dernier caractère
			#suite_requete = suite_requete+ ")"
			
			suite_requete = suite_requete + ' WHERE ('
			
			#toutes_les_items_actuels = self.qtableWidget_resultat.selectedItems()
			toutes_les_QModelIndex_actuels = self.qtableWidget_resultat.selectionModel().selectedRows()
			for chaque_QModelIndex in toutes_les_QModelIndex_actuels:
				ref_index = self.qtableWidget_resultat.item(chaque_QModelIndex.row(),0).data(0).toString() # on récupère le texte de la référence unique
				if mode_debuggage == 'oui': print "############ref_index#############"
				if mode_debuggage == 'oui': print ref_index
				if mode_debuggage == 'oui': print ""
				exec("suite_requete = suite_requete + '`%s`=%s OR ' "  % (self.SCROLL_AREA_mon_list_de_list_de_champs[0][0],str(ref_index)))
			
			suite_requete = suite_requete[:-4] #enlève les 4 derniers caractère
			suite_requete = suite_requete + ')'

			if mode_debuggage == 'oui': print "suite_requete"
			if mode_debuggage == 'oui': print suite_requete
			######
		

		
		
		if (titre_affaire != "" or GLOBAL_modif_unique_ou_multiple == "multiple") and compteur_champs_a_modifier != 0 :
			mon_ftp = class_FTP_ou_SFTP()
			id=mon_ftp.FTP_ou_SFTP()
			cur=id.cursor()
			try: #à remettre  en place !!!
				cur.execute(suite_requete, mon_dict)
				#cur.execute(suite_requete)	
				#cur.execute("INSERT INTO base_des_affaires1 (`num_boite_archive#QLE`) VALUES ('toto')") # youpi !!!! ça passe utiliser AltGr+7
				
				cur.close()
				id.commit()
				id.close()
			
				#message erreur:
				texte_titre = "Opération sur base"
				msg_1 = unicode("L'affaire: \n", "iso-8859-1")
				msg_2 = unicode(titre_affaire)
				if nouveau_ou_modif == "nouveau":
					msg_3 = unicode("\na bien été ajoutée", "iso-8859-1")
				elif nouveau_ou_modif == "modif":
					msg_3 = unicode("\na bien été modifiée", "iso-8859-1")
						
				
				
				if nouveau_ou_modif == "modif_multiple":
					msg_total = unicode("Les affaires sélectionnées ont bien été modifiées", "iso-8859-1")
				else:
					msg_total = msg_1 + msg_2 + msg_3
				
				
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Information)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_total)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				reponse = ma_boite.exec_()
				
				
				######## GESTION DES REPERTOIRES - DEPLACEMENT ###########
				#### 05/12/2013 à priori toute la gestion des répertoires fonctionne mais c'est trop risqué et on le tentera peut être plus tard
				
				#http://python.developpez.com/faq/?page=Repertoire
				nouveau_chemin_repertoire = self.concat_chemin(mon_avancement, titre_affaire)
				
				if nouveau_ou_modif == "nouveau":
					#concat_chemin(self, type_concours_affaire_etc, nom_affaire)
					#repertoire existant, on ne fait rien!!!
					if os.path.isdir(nouveau_chemin_repertoire) == True: 
						if mode_debuggage == 'oui': print "chemin deja existant on ne cree rien"
						texte_titre = "Répertoire non créé"
						msg_total = "Le répertoire de cette affaire existe déjà, le repertoire n'a donc pas été créé"
						QtGui.QApplication.restoreOverrideCursor()
						QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
						ma_boite = QtGui.QMessageBox(MainWindow)
						ma_boite.setIcon(QtGui.QMessageBox.Warning)
						ma_boite.setWindowTitle(texte_titre)
						ma_boite.setInformativeText(msg_total)
						ma_boite.addButton(_fromUtf8("Ok"), 0)
						reponse = ma_boite.exec_()
					
					#ok, création du répertoire
					elif os.path.isdir(nouveau_chemin_repertoire) == False:
						if mode_debuggage == 'oui': print "creation du repertoire"
						if mode_debuggage == 'oui': print unicode(nouveau_chemin_repertoire).encode("CP850")
						os.mkdir(nouveau_chemin_repertoire, 0777)
					
					
				elif nouveau_ou_modif == "modif":
					if mode_debuggage == 'oui': print "ligne_actuelle tableau resultat"
					if mode_debuggage == 'oui': print ligne_actuelle
					type_concours_affaire_etc = self.qtableWidget_resultat.item(ligne_actuelle,15).data(0).toString()
					ancien_nom_affaire = self.qtableWidget_resultat.item(ligne_actuelle,1).data(0).toString()
					ancien_chemin_repertoire = self.concat_chemin(type_concours_affaire_etc, ancien_nom_affaire)
					
					if unicode(nouveau_chemin_repertoire) != unicode(ancien_chemin_repertoire):
						if os.path.isdir(nouveau_chemin_repertoire) == True:
							if mode_debuggage == 'oui': print "chemin deja existant on ne modifie rien"
							texte_titre = "Répertoire non déplacé-modifié"
							msg_total = "Le répertoire de destination de cette affaire existe déjà sur le serveur. Vous devez gérer ce répertoire manuellement"
							QtGui.QApplication.restoreOverrideCursor()
							QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
							ma_boite = QtGui.QMessageBox(MainWindow)
							ma_boite.setIcon(QtGui.QMessageBox.Warning)
							ma_boite.setWindowTitle(texte_titre)
							ma_boite.setInformativeText(msg_total)
							ma_boite.addButton(_fromUtf8("Ok"), 0)
							reponse = ma_boite.exec_()
						
						elif os.path.isdir(nouveau_chemin_repertoire) == False:
							#shutil.move(src, dst)
							if mode_debuggage == 'oui': print "creation du repertoire ancien-nouveau"
							if mode_debuggage == 'oui': print unicode(ancien_chemin_repertoire).encode("CP850")
							if mode_debuggage == 'oui': print unicode(nouveau_chemin_repertoire).encode("CP850")
							if os.path.isdir(ancien_chemin_repertoire):
								try:
									shutil.move(ancien_chemin_repertoire, nouveau_chemin_repertoire)
								except:
									if mode_debuggage == 'oui': print "erreur fichier deja ouvert dans ce repertoire"
									texte_titre = "Fichier en cours d'utilisation"
									msg_total = "Déplacement critique !! Le répertoire déplacé contenait un fichier actuellement en cours d'utilisation par un utilisateur. Cet utilisateur doit enregistrer son fichier vers le nouvel emplacement et supprimer l'ancien répertoire manuellement!"
									QtGui.QApplication.restoreOverrideCursor()
									QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
									ma_boite = QtGui.QMessageBox(MainWindow)
									ma_boite.setIcon(QtGui.QMessageBox.Warning)
									ma_boite.setWindowTitle(texte_titre)
									ma_boite.setInformativeText(msg_total)
									ma_boite.addButton(_fromUtf8("Ok"), 0)
									reponse = ma_boite.exec_()
							else:
								texte_titre = "Répertoire source inexistant"
								msg_total = "Déplacement physique du répertoire impossible: le répertoire source de cette affaire n'existe pas sur le serveur"
								QtGui.QApplication.restoreOverrideCursor()
								QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
								ma_boite = QtGui.QMessageBox(MainWindow)
								ma_boite.setIcon(QtGui.QMessageBox.Warning)
								ma_boite.setWindowTitle(texte_titre)
								ma_boite.setInformativeText(msg_total)
								ma_boite.addButton(_fromUtf8("Ok"), 0)
								reponse = ma_boite.exec_()
								
								
								
							
				
				elif nouveau_ou_modif == "modif_multiple":  ###A FAIRE MARCO !!!!!
					liste_fichiers_impossibles = []
					liste_repertoires_existants = []
					liste_fichiers_deja_ouverts = []
					####
					toutes_les_QModelIndex_actuels = self.qtableWidget_resultat.selectionModel().selectedRows()
					for chaque_QModelIndex in toutes_les_QModelIndex_actuels:
						if mode_debuggage == 'oui': print "############ref_index#############"
				
						type_concours_affaire_etc = self.qtableWidget_resultat.item(chaque_QModelIndex.row(),15).data(0).toString()
						nom_affaire = self.qtableWidget_resultat.item(chaque_QModelIndex.row(),1).data(0).toString()
						ancien_chemin_repertoire = self.concat_chemin(type_concours_affaire_etc, nom_affaire)
						nouveau_chemin_repertoire = self.concat_chemin(mon_avancement, nom_affaire)
						
						if mode_debuggage == 'oui': print "ancien_chemin_repertoire"
						if mode_debuggage == 'oui': print ancien_chemin_repertoire
						if mode_debuggage == 'oui': print "nouveau_chemin_repertoire"
						if mode_debuggage == 'oui': print nouveau_chemin_repertoire
						
					####
						if unicode(nouveau_chemin_repertoire) != unicode(ancien_chemin_repertoire):
							if os.path.isdir(nouveau_chemin_repertoire) == True:
								if mode_debuggage == 'oui': print "chemin deja existant on ne modifie rien"
								liste_repertoires_existants.append(unicode(nouveau_chemin_repertoire))
							
							elif os.path.isdir(nouveau_chemin_repertoire) == False:
								#shutil.move(src, dst)
								if mode_debuggage == 'oui': print "creation du repertoire ancien-nouveau"
								#if mode_debuggage == 'oui': print unicode(ancien_chemin_repertoire).encode("CP850")
								#if mode_debuggage == 'oui': print unicode(nouveau_chemin_repertoire).encode("CP850")
								if os.path.isdir(ancien_chemin_repertoire):
									try:
										shutil.move(ancien_chemin_repertoire, nouveau_chemin_repertoire)
									except:
										liste_fichiers_deja_ouverts.append(unicode(ancien_chemin_repertoire))
								else:
									liste_fichiers_impossibles.append(unicode(ancien_chemin_repertoire))
						
					if len(liste_repertoires_existants) > 0:
						texte_titre = "Répertoires non déplacé-modifié"
						msg_1 = unicode("Déplacement impossible: le répertoire destination des affaires ci-dessous: \n", "iso-8859-1")
						#msg_2 = unicode(ancien_chemin_repertoire)
						msg_3 = unicode("\n existe déjà sur le serveur. Vous devez gérer ces répertoires manuellement", "iso-8859-1")
						msg_total = msg_1 
						for nom_fichier in liste_repertoires_existants:
							msg_total = msg_total + unicode("\n   - ", "iso-8859-1") + nom_fichier
						msg_total = msg_total + msg_3
						
						QtGui.QApplication.restoreOverrideCursor()
						QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
						ma_boite = QtGui.QMessageBox(MainWindow)
						ma_boite.setIcon(QtGui.QMessageBox.Warning)
						ma_boite.setWindowTitle(texte_titre)
						ma_boite.setInformativeText(msg_total)
						ma_boite.addButton(_fromUtf8("Ok"), 0)
						reponse = ma_boite.exec_()
				
					
					
					
					if len(liste_fichiers_impossibles) > 0:
						texte_titre = "Répertoire source inexistant"
						msg_1 = unicode("Déplacement impossible: le répertoire source des affaires ci-dessous n'existe pas sur le serveur: \n", "iso-8859-1")
						#msg_2 = unicode(ancien_chemin_repertoire)
						msg_3 = unicode("\n \n Vous devez gérer ces répertoires manuellement", "iso-8859-1")
						msg_total = msg_1 
						for nom_fichier in liste_fichiers_impossibles:
							msg_total = msg_total + unicode("\n   - ", "iso-8859-1") + nom_fichier
						msg_total = msg_total + msg_3
						
						QtGui.QApplication.restoreOverrideCursor()
						QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
						ma_boite = QtGui.QMessageBox(MainWindow)
						ma_boite.setIcon(QtGui.QMessageBox.Warning)
						ma_boite.setWindowTitle(texte_titre)
						ma_boite.setInformativeText(msg_total)
						ma_boite.addButton(_fromUtf8("Ok"), 0)
						reponse = ma_boite.exec_()
						
					if len(liste_fichiers_deja_ouverts) > 0:
						
						texte_titre = "Fichiers en cours d'utilisation"
						msg_1 = unicode("Déplacement critique - fichiers déjà ouverts: certains fichiers dans les répertoires sources des affaires ci-dessous contenaient des fichiers en cours d'utilisation par un utilisateur: \n", "iso-8859-1")
						#msg_2 = unicode(ancien_chemin_repertoire)
						msg_3 = unicode("\n \n Cet utilisateur doit enregistrer son fichier vers le nouvel emplacement et supprimer le(les) ancien(s) répertoire(s) manuellement!", "iso-8859-1")
						msg_total = msg_1 
						for nom_fichier in liste_fichiers_deja_ouverts:
							msg_total = msg_total + unicode("\n   - ", "iso-8859-1") + nom_fichier
						msg_total = msg_total + msg_3
						
						QtGui.QApplication.restoreOverrideCursor()
						QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
						ma_boite = QtGui.QMessageBox(MainWindow)
						ma_boite.setIcon(QtGui.QMessageBox.Warning)
						ma_boite.setWindowTitle(texte_titre)
						ma_boite.setInformativeText(msg_total)
						ma_boite.addButton(_fromUtf8("Ok"), 0)
						reponse = ma_boite.exec_()
					
				
					#self.table.selectionModel().selectedRows()
				######## FIN GESTION DES REPERTOIRES FIN -  DEPLACEMENT ###########
					
					
				
				
			
				self.rechercher() # on relance le bouton rechercher
			
				
				
				################ REMISE au niveau de la bonne ligne
			
				if nouveau_ou_modif == "nouveau" or nouveau_ou_modif == "modif_multiple":
					try:
						self.RESULTAT_cell_clickee(-1,self.qtableWidget_resultat.currentColumn()) #on simule un clic dans la ligne pour actualiser chque champ ! 
					except:
						self.RESULTAT_cell_clickee(-1,0) #on simule un clic dans la ligne pour actualiser chque champ ! 
				
				elif nouveau_ou_modif == "modif":
					if titre_affaire != "":
						if mode_debuggage == 'oui': print "SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS"
						if mode_debuggage == 'oui': print titre_affaire
						mes_list_items = self.qtableWidget_resultat.findItems(titre_affaire, QtCore.Qt.MatchExactly)
						
						#if mode_debuggage == 'oui': print mes_list_items
						#for elem in mes_list_items:						
						#if mode_debuggage == 'oui': print self.qtableWidget_resultat.horizontalHeaderItem(mes_list_items[0].column()).text()
						if self.qtableWidget_resultat.horizontalHeaderItem(mes_list_items[0].column()).text() == "Affaire":
							if mode_debuggage == 'oui': print "AAAAAABVGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
						
							self.qtableWidget_resultat.setCurrentCell(mes_list_items[0].row(),0) 	
							self.RESULTAT_cell_clickee(mes_list_items[0].row(),0) #on simule un clic dans la ligne pour actualiser chque champ ! 
				
					else:
						self.qtableWidget_resultat.setCurrentCell(-1,0) 	
						self.RESULTAT_cell_clickee(-1,0) #on simule un clic dans la ligne pour actualiser chque champ ! 
						
			except MySQLdb.IntegrityError, e: 
				texte_titre = "Erreur"
				msg_debut = "Vous avez un doublon sur le champ affaire. Vérifier que cette affaire est bien unique (y compris dans les concours et archives)" 
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Warning)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_debut)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				reponse = ma_boite.exec_()
			
			except MySQLdb.OperationalError,e:
				texte_titre = "Erreur de connection au serveur"
				msg_debut = "Connexion impossible:  \n Vérifier si la connection au serveur de base de données est bien établie" 
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Warning)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_debut)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				reponse = ma_boite.exec_()
			
		else:
			if compteur_champs_a_modifier == 0 and GLOBAL_modif_unique_ou_multiple == "multiple":
				texte_titre = "Opération sur base"
				msg_total = "Modification impossible!\n Aucun descriptif de champ en orange n'a été selectionné!"
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Warning)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_total)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				reponse = ma_boite.exec_()
			else:
				texte_titre = "Opération sur base"
				msg_total = "Insertion impossible!\nVous devez renseigner le champ 'Affaire'"
				QtGui.QApplication.restoreOverrideCursor()
				QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
				ma_boite = QtGui.QMessageBox(MainWindow)
				ma_boite.setIcon(QtGui.QMessageBox.Warning)
				ma_boite.setWindowTitle(texte_titre)
				ma_boite.setInformativeText(msg_total)
				ma_boite.addButton(_fromUtf8("Ok"), 0)
				reponse = ma_boite.exec_()
		
		if nouveau_ou_modif == "modif_multiple": #on repasse en mode unique une fois les modifs effectuées
			self.fonction_action_droit_unique()
		
		self.FICHE_annuler()
		
		
		QtGui.QApplication.restoreOverrideCursor()
		
	def FICHE_valider_modif(self):
		if mode_debuggage == 'oui': print "def valider_modif"
		QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
		
		
		#méthode:
			#voir si une modif a déjà été faite par qq'un d'autre:
			#pour cela: récuperer le list existant lors de chaque clic dans tableau résultat: self.ligne_cliquee_dans_tableau
			#ensuite on fait un SELECT sur cette même ligne et on vérifie que la ligne est identique ou pas
			# si la ligne est identique: ok on peut faire la modif: UPDATE datas...
			# si la ligne est différente: message d'erreur, et pas de modif!
		
		ligne_actuelle = self.qtableWidget_resultat.currentRow()
		ref_index = self.qtableWidget_resultat.item(ligne_actuelle,0).data(0).toString() # on récupère le texte
		
		requete = ("select * from %s where `%s` = %s" % (mysql_Nom_de_table, self.SCROLL_AREA_mon_list_de_list_de_champs[0][0], (ref_index)))
		
		
		mon_ftp = class_FTP_ou_SFTP()
		id=mon_ftp.FTP_ou_SFTP()
		cur=id.cursor()
		if mode_debuggage == 'oui': print "requete"
		if mode_debuggage == 'oui': print requete
		cur.execute(requete)
		self.ligne_avant_modif = list(cur.fetchall())
		#cur.execute(suite_requete)	
		#cur.execute("INSERT INTO base_des_affaires1 (`num_boite_archive#QLE`) VALUES ('toto')") # youpi !!!! ça passe utiliser AltGr+7
		if mode_debuggage == 'oui': print "self.ligne_avant_modif"
		if mode_debuggage == 'oui': print self.ligne_avant_modif
		cur.close()
		id.commit()
		id.close()
		
		verification = self.FICHE_valider_nouveau_ou_modif('modif')
		if verification == "modification impossible":
			texte_titre = "Modification impossible"
			msg_total = unicode("Modification impossible!\nUne personne extérieure a modifié cette même affaire depuis votre dernière recherche !", "iso-8859-1")
			QtGui.QApplication.restoreOverrideCursor()
			QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
			ma_boite = QtGui.QMessageBox(MainWindow)
			ma_boite.setIcon(QtGui.QMessageBox.Warning)
			ma_boite.setWindowTitle(texte_titre)
			ma_boite.setInformativeText(msg_total)
			ma_boite.addButton(_fromUtf8("Ok"), 0)
			reponse = ma_boite.exec_()
			

			self.rechercher() # on relance le boton rechercher

			self.FICHE_annuler()
			
		
		QtGui.QApplication.restoreOverrideCursor()
	
	def FICHE_annuler(self):
		global GLOBAL_modif_unique_ou_multiple
		QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
		
		if mode_debuggage == 'oui': print "def valider_modif"
		self.qpush_nouveau.show()
		self.qpush_modifier.show()
		self.qpush_supprimer.show()
		self.qpush_valider_nouveau.hide()
		self.qpush_valider_modif.hide()
		self.qpush_annuler.hide()
		
		self.qpush_rechercher.setEnabled(True)
		self.qpush_effacer.setEnabled(True)
		self.lineEdit_rapide.setEnabled(True)
		
		self.SCROLL_affichage_selon_modif_ajout_suppr(mon_mode = "annuler")
		
		if GLOBAL_modif_unique_ou_multiple == "multiple":
			GLOBAL_modif_unique_ou_multiple = "unique"
			self.fonction_action_droit_unique()
		QtGui.QApplication.restoreOverrideCursor()
			
	def accents_transformation(self,ligne):
    #supprime les accents et tirets du texte source
      
		#ligne = unicode(ligne, 'ISO-8859-1').encode('UTF-8') #on décode la châine d'origine accentuée(ISO8859-1), puis on la passe en UTF8 
		ligne = unicode(ligne).encode('ISO-8859-1') #on décode la châine d'origine accentuée(ISO8859-1), puis on la passe en UTF8 
		ligne = ligne.replace('É', 'E')
		ligne = ligne.replace('È', 'E')
		ligne = ligne.replace('Á', 'A')
		ligne = ligne.replace('Â', 'A')
		ligne = ligne.replace('À', 'A')
		ligne = ligne.replace('Ç', 'C')
		ligne = ligne.replace('Î', 'I')
		ligne = ligne.replace('Æ', 'Ae')
		ligne = ligne.replace('æ', 'ae')
		ligne = ligne.replace('œ', 'oe')
		
		
		ligne = ligne.replace('é', 'e')
		ligne = ligne.replace('è', 'e')
		ligne = ligne.replace('ê', 'e')
		ligne = ligne.replace('ë', 'e')
		ligne = ligne.replace('à', 'a')
		ligne = ligne.replace('ã', 'a')
		ligne = ligne.replace('â', 'a')
		ligne = ligne.replace('î', 'i')
		ligne = ligne.replace('ï', 'i')
		ligne = ligne.replace('ô', 'o')
		ligne = ligne.replace('ö', 'o')
		ligne = ligne.replace('ç', 'c')
		ligne = ligne.replace('ù', 'u')
		ligne = ligne.replace('û', 'u')
		ligne = ligne.replace('ü', 'u')
		ligne = ligne.replace('\'', '_')
		ligne = ligne.replace('/', '_')
		ligne = ligne.replace("'", '_')
		ligne = ligne.replace('"', '_')
		
		ligne = ligne.replace('$', '_')
		ligne = ligne.replace('&', '_')
		ligne = ligne.replace('#', '_')
		ligne = ligne.replace('?', '_')
		ligne = ligne.replace('!', '_')
		ligne = ligne.replace('%', '_')
		ligne = ligne.replace('(', '_')
		ligne = ligne.replace(')', '_')
		ligne = ligne.replace('°', '')
		
		ligne = ligne.replace(' ', '_')
		ligne = ligne.replace('_____', '_')
		ligne = ligne.replace('____', '_')
		ligne = ligne.replace('___', '_')
		ligne = ligne.replace('__', '_')
		ligne = ligne.replace('–', '_') #super tiret bizarre
		
		
		
		ligne = ligne.replace(' - ', '_-_')
		ligne = ligne.replace(' -', '_-')
		ligne = ligne.replace('- ', '-_')
		
		ligne = ligne.replace('_-', '-')
		ligne = ligne.replace('-_', '-')
		ligne = ligne.replace('_-_', '-')
		
		ligne = ligne.replace('St-', 'St_')
		ligne = ligne.replace('Ste-', 'Ste_')
		
		
		
		#ligne = ligne.encode('ISO-8859-1')			
		ligne = ligne.encode('utf-8')			
		return ligne
			
class Transposition_selon_ordre():
	def transpose_inverse_list_multiple(self,debut_list_taille_quelconque,list_ordre_simple):
		############ debut invertion #############
		final_list_taille_quelconque = []
		for i in range(len(list_ordre_simple)):
			mon_list =[]
			final_list_taille_quelconque.append(mon_list)
		
		for i in range(len(list_ordre_simple)):
			final_list_taille_quelconque[i] = debut_list_taille_quelconque[list_ordre_simple[i]]
			
		return final_list_taille_quelconque
		############ fin invertion #############
		
	def transpose_list_multiple(self,debut_list_taille_quelconque,list_ordre_simple, var_utilisateur):
		#debut_list_taille_quelconque = [['a','Xaa','YYYaa'],['b','Xbb','YYYbb'],['c','Xcc','YYYcc'],['d','Xdd','YYYdd'],['e','Xee','YYYee'],['f','Xff','YYYff'],['g','Xgg','YYYgg']]
		#list_ordre_simple = [1,0,2,3,4,6,5]
		#list_ordre_simple = [1,0,2]
		#list_ordre_simple = [7,1,0,10,2,11,3,8,4,6,5]
		
		#if mode_debuggage == 'oui': print ""
		if mode_debuggage == 'oui': print "type(debut_list_taille_quelconque)"
		
		if mode_debuggage == 'oui': print ""
		if mode_debuggage == 'oui': print "Matrices en entree" 
		if mode_debuggage == 'oui': print "debut_list_taille_quelconque"
		if mode_debuggage == 'oui': print type(debut_list_taille_quelconque)
		if mode_debuggage == 'oui': print len(debut_list_taille_quelconque)
		if mode_debuggage == 'oui': print debut_list_taille_quelconque
		if mode_debuggage == 'oui': print "list_ordre_simple"
		if mode_debuggage == 'oui': print type(list_ordre_simple)
		if mode_debuggage == 'oui': print len(list_ordre_simple)
		if mode_debuggage == 'oui': print list_ordre_simple
		
		difference = len(debut_list_taille_quelconque) - len(list_ordre_simple)
		if difference !=0:
			#si on trouve une différence, on refabrique un nouveau list en ajoutant ou en supprimant des index
			#on le renomme avec son nom d'origine
			#on va updater la mase MYSQL pour la config en cours
			
			if mode_debuggage == 'oui': print "difference"
			if mode_debuggage == 'oui': print difference
			list_ordre_simple_modifiee = copy.deepcopy(list_ordre_simple) #on duplique le list
			if difference > 0:
				msg_debut = "Attention ! \nDes champs ont été ajoutés sur le serveur par votre administrateur. Ces champs ont été ajoutés en fin de liste sur le tableau de droite. Vous devez réorganiser vos tableaux de paramètres de tri (en haut à gauche) et tableau de résultat (ordre des colonnes) de toutes vos configs\nCe message ne réapparaitra pas lors de la prochaine ouverture du logiciel" 
				for i in range(difference):
					mon_nouveau_num = len(list_ordre_simple)+i
					list_ordre_simple_modifiee.append(mon_nouveau_num)
				
			elif difference < 0:
				msg_debut = "Attention ! \nDes champs ont été supprimés sur le serveur par votre administrateur. Vous devez réorganiser vos configs, tri et affichage via paramètres-gestion des configs\nCe message ne réapparaitra pas lors de la prochaine ouverture du logiciel " 
				type_difference = "suppr"
				for i in range(abs(difference)):
					list_ordre_simple_modifiee.remove(max(list_ordre_simple_modifiee))
					
			#on a refabriqué un nouveau List augmenté ou diminué du nombre de colonnes
			list_ordre_simple = copy.deepcopy(list_ordre_simple_modifiee)
			
			if mode_debuggage == 'oui': print "list_ordre_simple"
			if mode_debuggage == 'oui': print list_ordre_simple
			
			if difference > 0:			
				mon_ftp = class_FTP_ou_SFTP()
				id=mon_ftp.FTP_ou_SFTP()
				cur=id.cursor()
				#cur.execute("UPDATE preferences_utilisateurs SET nom_utilisateur=%s, ordre_zone_scroll_area=%s WHERE (nom_utilisateur=%s)" ,(nouveau_text, str(nouvelle_matrice_colonnes_scroll),ancien_text))
				cur.execute("UPDATE preferences_utilisateurs SET ordre_zone_scroll_area=%s WHERE (nom_utilisateur=%s)" , \
				(str(list_ordre_simple), unicode(var_utilisateur)))
				cur.close()
				id.commit()
				id.close()
			
			elif difference < 0:
				list_tableau_col_visibles = []
				for i in range(len(list_ordre_simple)):
					mon_petit_list = []
					mon_petit_list.append(i)
					mon_petit_list.append(i)
					mon_petit_list.append(100)
					list_tableau_col_visibles.append(mon_petit_list)
					
				
				mon_ftp = class_FTP_ou_SFTP()
				id=mon_ftp.FTP_ou_SFTP()
				cur=id.cursor()
				#cur.execute("UPDATE preferences_utilisateurs SET nom_utilisateur=%s, ordre_zone_scroll_area=%s WHERE (nom_utilisateur=%s)" ,(nouveau_text, str(nouvelle_matrice_colonnes_scroll),ancien_text))
				cur.execute("UPDATE preferences_utilisateurs SET ordre_col_tableau_resultat=%s, ordre_zone_scroll_area=%s WHERE (nom_utilisateur=%s)" , \
				(str(list_tableau_col_visibles),str(list_ordre_simple), unicode(var_utilisateur)))
				cur.close()
				id.commit()
				id.close()
			
			
			
			
			#message erreur:
			texte_titre = "Structure de base sur serveur modifiée"
			
			msg_total = unicode(msg_debut, "iso-8859-1") #ce que j'écris en texte dans mon code est en ISO-8859-1 c'est pour ça que unicode(machaine, sys.stdin.encoding) ne sert pas
			#msg_variable = unicode(blabla, "iso-8859-1") # pas besoin de sys.stdin.encoding, puisque ça vient d'ailleurs
			QtGui.QApplication.restoreOverrideCursor()
			QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
			ma_boite = QtGui.QMessageBox(MainWindow)
			ma_boite.setIcon(QtGui.QMessageBox.Warning)
			ma_boite.setWindowTitle(texte_titre)
			ma_boite.setInformativeText(msg_total)
			ma_boite.addButton(_fromUtf8("Ok"), 0)
			reponse = ma_boite.exec_()
				
			
			
		
		############ debut invertion #############
		final_list_taille_quelconque = []
		for i in range(len(list_ordre_simple)):
			mon_list =[]
			final_list_taille_quelconque.append(mon_list)
			
		for i in range(len(list_ordre_simple)):
			final_list_taille_quelconque[i] = debut_list_taille_quelconque[list_ordre_simple[i]]
		############ fin invertion #############
					
		
		#if mode_debuggage == 'oui': print ""	
		#if mode_debuggage == 'oui': print "debut: " + str(debut_list_taille_quelconque)
		#if mode_debuggage == 'oui': print ""
		#if mode_debuggage == 'oui': print "ordre: " + str(list_ordre_simple)
		#if mode_debuggage == 'oui': print ""
		#if mode_debuggage == 'oui': print "fin: " + str(final_list_taille_quelconque) 
		if mode_debuggage == 'oui': print ""
		return final_list_taille_quelconque,list_ordre_simple
		###############################
	
class Fenetre_connexion(Ui_Dialog_connection_Qt): #METHODE PARFAITE POUR CREER LES FENETRES !!! YES !!!! #fenetre_connexion1
	#http://snouffy.free.fr/blog-fr/index.php/post/2009/02/18/Qt,-Qt-Designer-et-Python-%3A-d%C3%A9tecter-la-fermeture-de-la-fen%C3%AAtre
	#ma_fenetre_connection = QtGui.QDialog(MainWindow) #bien préciser le parent, sinon la fenetre s'ouvre et se referme
	#connection = Fenetre_connexion()
	#connection.setupUi2(ma_fenetre_connection) #on passe une QDailog ou QMainWindow suivant ce qu'on a créé avec Qt
	#ma_fenetre_connection.show()
	def ferme_fenetre(self):
		self.dialog_connection.close() # du coup la fonction close_event détecte également la fermeture et est lancée
	def close_Event(self, event):
		if mode_debuggage == 'oui': print "je ferme les parametres connexions"	
		
		
		
	def setupUi2(self,Form):
		"""Ajoutons ce qu'il manque à la fenêtre"""
		self.dialog_connection = Form #promotion: permet de monter d'un cran la fenetre et de l'utiliser ailleurs
		self.setupUi(self.dialog_connection) #
		self.dialog_connection.closeEvent = self.close_Event
		
		self.dialog_connection.setWindowModality(QtCore.Qt.ApplicationModal) #fenetre modale: non_modal: setWindowModality(QtCore.Qt.NonModal)
		
		self.dialog_connection.setWindowTitle("Paramètres de connexion")
		
		
		exec("self.push_chemin_affaires.setIcon(QtGui.QIcon(_fromUtf8('%s%s')))" % (GLOBAL_chemin_icone, "/folder.png"))
		exec("self.push_chemin_archives.setIcon(QtGui.QIcon(_fromUtf8('%s%s')))" % (GLOBAL_chemin_icone, "/folder.png"))
		QtCore.QObject.connect(self.push_chemin_affaires,QtCore.SIGNAL("clicked()"),self.clicked_affaires)
		QtCore.QObject.connect(self.push_chemin_archives,QtCore.SIGNAL("clicked()"),self.clicked_archives)
		
		QtCore.QObject.connect(self.con_ip,QtCore.SIGNAL("cursorPositionChanged(int,int)"),self.test)
		
		QtCore.QObject.connect(self.con_buttonBox,QtCore.SIGNAL("rejected()"),self.ferme_fenetre)
		QtCore.QObject.connect(self.con_buttonBox,QtCore.SIGNAL("accepted()"),self.enregistrement_param_dans_base_registre)
		self.con_buttonBox.setStandardButtons(QtGui.QDialogButtonBox.Cancel|QtGui.QDialogButtonBox.Save)
		self.con_ip.setInputMask("000.000.000.000;_")
		self.con_port.setInputMask("0000;_")
		self.con_protocole.addItem("FTP")
		self.con_protocole.addItem("Secure_FTP")
		self.con_pass.setEchoMode(2) #password mot de passe
		
		self.chargement()
	def clicked_affaires(self):
		#mon_nom = self.ma_bdg_chemin = unicode(QtGui.QFileDialog.getSaveFileName(mon_form, _fromUtf8("Chemin des affaires"), '/pyth'))
		reponse = unicode(QtGui.QFileDialog.getExistingDirectory(MainWindow, "Chemin des affaires",self.con_chemin_affaires.text(), QtGui.QFileDialog.ShowDirsOnly))
		if reponse != "":
			self.con_chemin_affaires.setText(reponse)
		
	def clicked_archives(self):
		reponse = unicode(QtGui.QFileDialog.getExistingDirectory(MainWindow, "Chemin des archives",self.con_chemin_archives.text(), QtGui.QFileDialog.ShowDirsOnly))
		if reponse != "":
			self.con_chemin_archives.setText(reponse)
	
	def chargement(self):
		try:
			mon_setting = QtCore.QSettings("Echologos", "Basaffaire")
			reg_con_ip = (mon_setting.value('param_connexion/ip').toString())
			reg_con_port = (mon_setting.value('param_connexion/port').toString()) #nesrt à rien pour l'instant
			reg_con_protocole = (mon_setting.value('param_connexion/protocole').toString())
			reg_con_user = (mon_setting.value('param_connexion/user').toString())
			reg_con_pass = (mon_setting.value('param_connexion/pass').toString())
			reg_con_base = (mon_setting.value('param_connexion/base').toString())
			reg_con_table = (mon_setting.value('param_connexion/table').toString())
			reg_con_chemin_affaires = mon_setting.value('chemins/chemin_affaires').toString()
			reg_con_chemin_archives = mon_setting.value('chemins/chemin_archives').toString()
			
			self.con_ip.setText(reg_con_ip)
			self.con_port.setText(reg_con_port)
			num = self.con_protocole.findText(reg_con_protocole)
			self.con_protocole.setCurrentIndex(num)
			self.con_user.setText(reg_con_user)
			self.con_pass.setText(reg_con_pass)
			self.con_base.setText(reg_con_base)
			self.con_table.setText(reg_con_table)
			self.con_chemin_affaires.setText(reg_con_chemin_affaires)
			self.con_chemin_archives.setText(reg_con_chemin_archives)
			
			self.con_chemin_affaires.setToolTip("<html>Linux et mac: du type /media/echogre1/Affaires<br> Windows du type \\\\Sme\echogre1\Affaires<br><br>  -->Affaires_en_cours<br>  -->Concours</html>") #hover bulle survol
			self.con_chemin_archives.setToolTip("<html>Linux et mac: du type /media/echogre1/Archives<br> Windows du type \\\\Sme\echogre1\Archives<br><br>  Affaires<br> -->Affaires_archivees<br>  -->Concours_perdus</html>") #hover bulle survol
		except:
			fefe = 2
	
		
	def	test(self):
		if mode_debuggage == 'oui': print "youpudede"
	def enregistrement_param_dans_base_registre(self):
		if mode_debuggage == 'oui': print "enregistrement_param_dans_base_registre"
		#http://www.siteduzero.com/informatique/tutoriels/enregistrer-vos-options-avec-qsettings/creer-un-fichier-d-options
		mon_setting = QtCore.QSettings("Echologos", "Basaffaire")
		mon_setting.setValue('param_connexion/ip', unicode(self.con_ip.text()))
		mon_setting.setValue('param_connexion/port', unicode(self.con_port.text()))
		mon_setting.setValue('param_connexion/protocole', unicode(self.con_protocole.currentText()))
		mon_setting.setValue('param_connexion/user', unicode(self.con_user.text()))
		mon_setting.setValue('param_connexion/pass', unicode(self.con_pass.text()))
		mon_setting.setValue('param_connexion/base', unicode(self.con_base.text()))
		mon_setting.setValue('param_connexion/table', unicode(self.con_table.text()))
		
		mon_setting.setValue('chemins/chemin_affaires', unicode(self.con_chemin_affaires.text()))
		mon_setting.setValue('chemins/chemin_archives', unicode(self.con_chemin_archives.text()))
		
		
		self.dialog_connection.close() # du coup la fonction close_event détecte également la fermeture et est lancée
		
		texte_titre = "Paramètres de connexion"
		msg_total = unicode("Paramètres enregistrés. Vous devez rédémarrer le logiciel", "iso-8859-1")
		QtGui.QApplication.restoreOverrideCursor()
		QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
		ma_boite = QtGui.QMessageBox(MainWindow)
		ma_boite.setIcon(QtGui.QMessageBox.Warning)
		ma_boite.setWindowTitle(texte_titre)
		ma_boite.setInformativeText(msg_total)
		ma_boite.addButton(_fromUtf8("Ok"), 0)
		reponse = ma_boite.exec_()
		

class Fenetre_version(Ui_Dialog_version_Qt): #METHODE PARFAITE POUR CREER LES FENETRES !!! YES !!!! #fenetre_version1
	#http://snouffy.free.fr/blog-fr/index.php/post/2009/02/18/Qt,-Qt-Designer-et-Python-%3A-d%C3%A9tecter-la-fermeture-de-la-fen%C3%AAtre
	#ma_fenetre_connection = QtGui.QDialog(MainWindow) #bien préciser le parent, sinon la fenetre s'ouvre et se referme
	#connection = Fenetre_connexion()
	#connection.setupUi2(ma_fenetre_connection) #on passe une QDailog ou QMainWindow suivant ce qu'on a créé avec Qt
	#ma_fenetre_connection.show()
	def ferme_fenetre(self):
		self.dialog_connection.close() # du coup la fonction close_event détecte également la fermeture et est lancée
	def close_Event(self, event):
		if mode_debuggage == 'oui': print "je ferme les parametres version "	
		
		
		
	def setupUi2(self,Form):
		"""Ajoutons ce qu'il manque à la fenêtre"""
		self.dialog_version = Form #promotion: permet de monter d'un cran la fenetre et de l'utiliser ailleurs
		self.setupUi(self.dialog_version) #
		self.dialog_version.closeEvent = self.close_Event
		self.dialog_version.setWindowModality(QtCore.Qt.ApplicationModal) #fenetre modale: non_modal: setWindowModality(QtCore.Qt.NonModal)
		self.dialog_version.setWindowTitle("Paramètres de Version")
		self.version.setText(GLOBAL_nom_programme+GLOBAL_version_programme+GLOBAL_date_version)
		
		#http://www.developpez.net/forums/d847960/c-cpp/bibliotheques/qt/inserer-image-qt/
		exec("mon_image = QtGui.QPixmap('%s%s')" % (GLOBAL_chemin_icone, "/logo2_trop_grand.png"))
		mon_image.scaled(187,189, QtCore.Qt.KeepAspectRatioByExpanding, QtCore.Qt.FastTransformation)
		self.image.setPixmap(mon_image)
		self.image.setScaledContents(True)
		blabla = ""
		v100 = "Version n°1.00: particularités \n - Double clic pour ouverture directe de l'explorateur \n - Clic droit pour passage en modification multiple"
		blabla = v100
		self.notes_de_version.setPlainText(unicode(blabla, 'iso-8859-1'))
		#exec("elem.bouche_image1.setPixmap(QtGui.QPixmap('%s/DESS1.bmp'))" % (chemin_icone))
		
		
	
class class_FTP_ou_SFTP():
	def FTP_ou_SFTP(self):
		try:
			mon_setting = QtCore.QSettings("Echologos", "Basaffaire")
			reg_con_ip = (mon_setting.value('param_connexion/ip').toString())
			reg_con_port = (mon_setting.value('param_connexion/port').toString())
			reg_con_protocole = (mon_setting.value('param_connexion/protocole').toString())
			reg_con_user = (mon_setting.value('param_connexion/user').toString())
			reg_con_pass = (mon_setting.value('param_connexion/pass').toString())
			reg_con_base = (mon_setting.value('param_connexion/base').toString())
			reg_con_table = (mon_setting.value('param_connexion/table').toString())
			
			
			global mysql_Nom_de_table
			mysql_Nom_de_table = str(reg_con_table)
				
			
			if mode_debuggage == 'oui': print "reg_con_protocole"
			if mode_debuggage == 'oui': print reg_con_protocole
			
			if reg_con_protocole == "FTP":
				if mode_debuggage == 'oui': print "connexion FTP"
				#reg_con_ip = '195.144.11.16'
				#reg_con_user = 'echologos7'
				#reg_con_pass = '4jsk3b87j6333i'
				#reg_con_base = 'echologos7'
			
				#id=MySQLdb.connect(host=reg_con_ip, user=reg_con_user, passwd=reg_con_pass, db=reg_con_base)
				#mon_ftp = class_FTP_ou_SFTP() \ id=mon_ftp.FTP_ou_SFTP()
				#if mode_debuggage == 'oui': print "adresse_ip"
				#if mode_debuggage == 'oui': print reg_con_ip
				#if mode_debuggage == 'oui': print "reg_con_user"
				#if mode_debuggage == 'oui': print reg_con_user
				#if mode_debuggage == 'oui': print "reg_con_pass"
				#if mode_debuggage == 'oui': print reg_con_pass
				#if mode_debuggage == 'oui': print "reg_con_base"
				#if mode_debuggage == 'oui': print reg_con_base
				
				
				exec("id=MySQLdb.connect(host='%s', user='%s', passwd='%s', db='%s')" % (reg_con_ip,reg_con_user,reg_con_pass,reg_con_base))
				return id
				
			elif reg_con_protocole == "Secure_FTP":
				if mode_debuggage == 'oui': print "connexion secure FTP"
				exec("id=MySQLdb.connect(host='%s', user='%s', passwd='%s', db='%s')" % (reg_con_ip,reg_con_user,reg_con_pass,reg_con_base)) #bug sans bug, connection SFTP à mettre en place
				return id
			else:
				toto = 4/0 #genere erreur
		
		#except MySQLdb.OperationalError,e:
		#	texte_titre = "Erreur de connection au serveur_"
		#	msg_debut = "Connexion impossible:  \n Vérifier si la connection au serveur de base de données est bien établie \n Fermeture du logiciel" 
		#	QtGui.QApplication.restoreOverrideCursor()
		#	ma_boite = QtGui.QMessageBox(MainWindow)
		#	ma_boite.setIcon(QtGui.QMessageBox.Warning)
		#	ma_boite.setWindowTitle(texte_titre)
		#	ma_boite.setInformativeText(msg_debut)
		#	ma_boite.addButton(_fromUtf8("Ok"), 0)
		#	reponse = ma_boite.exec_()
		#	mon_form.close()
		#	sys.exit()
		
		
		except:	
			#if mode_debuggage == 'oui': print "erreur"
			#if mode_debuggage == 'oui': print e
		#elif reg_con_protocole == "":
			texte_titre = "Paramètres de connexion"
			msg_total = unicode("Ceci est votre première connexion ou bien vos paramètres de connexion ne sont pas ou mal renseignés. Vous devez les renseigner puis relancer le logiciel", "iso-8859-1")
			QtGui.QApplication.restoreOverrideCursor()
			QtGui.QApplication.restoreOverrideCursor() #appel une deuxième fois pour le désactivger totalement
			ma_boite = QtGui.QMessageBox(MainWindow)
			ma_boite.setIcon(QtGui.QMessageBox.Warning)
			ma_boite.setWindowTitle(texte_titre)
			ma_boite.setInformativeText(msg_total)
			ma_boite.addButton(_fromUtf8("Ok"), 0)
			reponse = ma_boite.exec_()
			
			
			
			ma_fenetre_connection = QtGui.QDialog(MainWindow)
			connection = Fenetre_connexion()
			connection.setupUi2(ma_fenetre_connection)
			if mode_debuggage == 'oui': print "zaza42"
			ma_fenetre_connection.exec_()


class Fenetre_pre_impression_references(Ui_Dialog_impression_references): #METHODE PARFAITE POUR CREER LES FENETRES !!! YES !!!!
	#http://snouffy.free.fr/blog-fr/index.php/post/2009/02/18/Qt,-Qt-Designer-et-Python-%3A-d%C3%A9tecter-la-fermeture-de-la-fen%C3%AAtre
	#ma_fenetre_connection = QtGui.QDialog(MainWindow) #bien préciser le parent, sinon la fenetre s'ouvre et se referme
	#connection = Fenetre_connexion()
	#connection.setupUi2(ma_fenetre_connection) #on passe une QDailog ou QMainWindow suivant ce qu'on a créé avec Qt
	#ma_fenetre_connection.show()
	def ferme_fenetre(self):
		self.Dialog_impression_references.close() # du coup la fonction close_event détecte également la fermeture et est lancée
	
	def close_Event(self, event):
		if mode_debuggage == 'oui': print "je ferme les parametres connexions"	
		
	def setupUi_reference(self,Form):
		"""Ajoutons ce qu'il manque à la fenêtre"""
		self.Dialog_impression_references = Form #promotion: permet de monter d'un cran la fenetre et de l'utiliser ailleurs
		self.setupUi(self.Dialog_impression_references) #
		self.Dialog_impression_references.closeEvent = self.close_Event
		self.Dialog_impression_references.setWindowModality(QtCore.Qt.ApplicationModal) #fenetre modale: non_modal: setWindowModality(QtCore.Qt.NonModal)
		self.Dialog_impression_references.setWindowTitle("Impression des références")
		
		#debut status bar
		#http://stackoverflow.com/questions/6135514/qt-how-to-implement-qdialog-statusbar
		monlayout = QtGui.QVBoxLayout(self.Dialog_impression_references)
		monlayout.addWidget(QtGui.QLineEdit())
		mon_status = QtGui.QStatusBar()
		monlayout.addWidget(mon_status)
		#fin status bar bug marche pas
		
		
		QtCore.QObject.connect(self.Qpush_ref_rechercher,QtCore.SIGNAL('clicked()'),self.rechercher_references)
		QtCore.QObject.connect(self.Qpush_ref_imprimer,QtCore.SIGNAL('clicked()'),self.lancer_impression)
		QtCore.QObject.connect(self.Qpush_ref_annuler,QtCore.SIGNAL('clicked()'),self.ferme_fenetre)
		QtCore.QObject.connect(self.Qpush_cheminODT,QtCore.SIGNAL('clicked()'),self.chemin_fichier_ODT_impression)
		#QtCore.QObject.connect(self.tableWidget_reference,QtCore.SIGNAL('currentCellChanged(int,int,int,int)'),self.double_clic_ligne_tableau)
		#QtCore.QObject.connect(self.tableWidget_reference,QtCore.SIGNAL('cellDoubleClicked(int,int)'),self.double_clic_ligne_tableau)
		#ASTUCE ! ####http://stackoverflow.com/questions/1332110/selecting-qcombobox-in-qtablewidget
		
		self.montant_bas.setValidator(QtGui.QIntValidator(0, 999999999, self.montant_bas))
		self.montant_haut.setValidator(QtGui.QIntValidator(0, 999999999, self.montant_haut))
		self.montant_bas.setText("0")
		self.montant_haut.setText("99999999999999")
		
		self.checkBox_fichierODT.setStatusTip("Cocher la case pour créer d'un fichier ODT contenant toutes les données") #BUG, définir le parent ????
		self.Qpush_cheminODT.setStatusTip("Définir le chemin du fichier ODT")
		
		
		self.remplissage_widgets_references()
	
	def double_clic_ligne_tableau(self, mon_QPoint):
	#def double_clic_ligne_tableau(self):
		if mode_debuggage == 'oui': print "double_clic_ligne_tableau youyouy"
		if mode_debuggage == 'oui': print mon_QPoint.x()
		if mode_debuggage == 'oui': print mon_QPoint.y()
		ligne = self.tableWidget_reference.indexAt(mon_QPoint).row()
		if mode_debuggage == 'oui': print "ligne du tableau"
		if mode_debuggage == 'oui': print ligne
		numero_index = int(self.tableWidget_reference.cellWidget(ligne,9).toPlainText())
		if mode_debuggage == 'oui': print "numero_index"
		if mode_debuggage == 'oui': print numero_index
		
		mon_form.rechercher(numero_index) #on simule une fonction recherche sur le numero de l'index
		#self.ferme_fenetre() #on ferme la fenetre d'impression
		mon_form.qtableWidget_resultat.setCurrentCell(0,0) #on simule un clic dans la première ligne du tableau pourafficher toutes les vlaeurs dans la zone de roite
		mon_form.qtableWidget_resultat.emit(QtCore.SIGNAL("cellClicked(0,0)"))
	
	def lancer_impression(self):
		if mode_debuggage == 'oui': print "impression_references"
		try:
			self.ferme_fenetre() #on ferme la fenetre d'impression
		except:
			titi = 2
		impression = Imprimer()
		impression.references_imprimer_ok()
	
	def chemin_fichier_ODT_impression(self):
		global GLOBAL_repertoire_pour_ODT
		if mode_debuggage == 'oui': print "chemin_fichier_ODT_impression"
		GLOBAL_repertoire_pour_ODT = unicode(QtGui.QFileDialog.getExistingDirectory(MainWindow, _fromUtf8("Définir le répertoire pour impression ODT:")))
		if mode_debuggage == 'oui': print "repertoire_pour_ODT"
		if mode_debuggage == 'oui': print GLOBAL_repertoire_pour_ODT
	
	def rechercher_references(self):
		if mode_debuggage == 'oui': print "rechercher_references"
	
		
		#self.montant_bas
		#self.montant_haut
		#self.QCB_agence
		#self.QCB_type_de_ref
		#self.QDateEdit_bas
		#self.QDateEdit_haut
		
		
		nom_champ_ref = "`type_de_ref#QLW#QPB#mc#table_type_de_ref#0`"
		nom_champ_agence = "`agence#QCB`"
		nom_champ_hono = "`montant_hono#QLE`"
		nom_champ_date = "`date_rec_travaux#QDE`"
		nom_champ_avancement = "`avancement#QCB`"
		
		
		mon_dictF = {}
		mon_dictF["montant_bas"] = unicode(self.montant_bas.text())
		mon_dictF["montant_haut"] = unicode(self.montant_haut.text())
		mon_dictF["QDateEdit_bas"] = unicode(self.QDateEdit_bas.date().toString(QtCore.Qt.ISODate))
		mon_dictF["QDateEdit_haut"] = unicode(self.QDateEdit_haut.date().toString(QtCore.Qt.ISODate))
		mon_dictF["avancement_A"] = unicode("étude","iso-8859-1")
		mon_dictF["avancement_B"] = unicode("chantier","iso-8859-1")
		mon_dictF["avancement_C"] = unicode("affaire archivée","iso-8859-1")
		mon_dictF["avancement_D"] = unicode("affaire à archiver","iso-8859-1")
		
		#tri sur champ avancement_A, avancement_B, avancement_C, avancement_D
		#étude
		#chantier
		#affaire archivée
		#affaire à archiver
	
		
		####DEBUT REQUETE
		requete = "SELECT * FROM `%s` WHERE ((" % (mysql_Nom_de_table)
		
		g = 0
		for elem_agence in self.QCB_agence.selectedItems():
			mon_dictF["agence_" + str(g) ] = unicode(elem_agence.text())
			requete = requete + nom_champ_agence + " LIKE " + "%(agence_" + str(g) + ")s OR "
			g = g+1
		
		requete = requete[:-4]
		requete = requete + ") AND ("
		
		g = 0
		for elem_ref in self.QCB_type_de_ref.selectedItems(): #bug sur le dernier élemnt sélectionné
			mon_dictF["ref_" + str(g) ] = unicode("%") +unicode(elem_ref.text()) + unicode("%")
			if mode_debuggage == 'oui': print "reference"
			if mode_debuggage == 'oui': print mon_dictF["ref_" + str(g) ]
			requete = requete + nom_champ_ref + " LIKE " + "%(ref_" + str(g) + ")s OR "
			g = g+1
		
		requete = requete[:-4]
		requete = requete + ") AND "
		
		requete = requete + nom_champ_hono + ' >= ' + "%(montant_bas)s" + ' AND '
		requete = requete + nom_champ_hono + ' <= ' + "%(montant_haut)s" + ' AND '
		
		
		requete = requete + "(" + nom_champ_avancement + ' LIKE ' + "%(avancement_A)s" + ' OR '
		requete = requete + nom_champ_avancement + ' LIKE ' + "%(avancement_B)s" + ' OR '
		requete = requete + nom_champ_avancement + ' LIKE ' + "%(avancement_C)s" + ' OR '
		requete = requete + nom_champ_avancement + ' LIKE ' + "%(avancement_D)s" + ') AND '
		
		requete = requete + nom_champ_date + ' >= ' + "%(QDateEdit_bas)s" + ' AND '
		requete = requete + nom_champ_date + ' <= ' + "%(QDateEdit_haut)s"
			
		requete = requete + ") ORDER BY " + nom_champ_date + " DESC, " + nom_champ_ref + " ASC"	
			
		if mode_debuggage == 'oui': print ""
		if mode_debuggage == 'oui': print "impression dico ref"
		if mode_debuggage == 'oui': print mon_dictF
		
		if mode_debuggage == 'oui': print "requete"
		if mode_debuggage == 'oui': print unicode(requete).encode("CP850")
		mon_ftp = class_FTP_ou_SFTP()
		id=mon_ftp.FTP_ou_SFTP()
		cur=id.cursor()
		cur.execute(requete, mon_dictF)
		resultat = list(cur.fetchall())
		cur.close()
		id.close()
		
		if mode_debuggage == 'oui': print "resultat"
		if mode_debuggage == 'oui': print resultat
		#inserer la concaténation des valeurs dans "tableWidget_reference"
		
		for num in range(self.tableWidget_reference.rowCount()):
			self.tableWidget_reference.removeRow(0)
		
		self.tableWidget_reference.setColumnCount(10)
		item = QtGui.QTableWidgetItem()
		item.setText("C")
		self.tableWidget_reference.setHorizontalHeaderItem(0, item)#rien
		self.tableWidget_reference.setColumnWidth(0, 20)
		
		item = QtGui.QTableWidgetItem()
		item.setText("Nature de l'opération")
		self.tableWidget_reference.setHorizontalHeaderItem(1, item)#rien
		self.tableWidget_reference.setColumnWidth(1, 190)
		
		item = QtGui.QTableWidgetItem()
		item.setText("Maître d'ouvrage")
		self.tableWidget_reference.setHorizontalHeaderItem(2, item)#rien
		self.tableWidget_reference.setColumnWidth(2, 190)
		
		item = QtGui.QTableWidgetItem()
		item.setText("Type de travaux")
		self.tableWidget_reference.setHorizontalHeaderItem(3, item)#rien
		self.tableWidget_reference.setColumnWidth(3, 150)
		
		item = QtGui.QTableWidgetItem()
		item.setText("Type de mission")
		self.tableWidget_reference.setHorizontalHeaderItem(4, item)#rien
		self.tableWidget_reference.setColumnWidth(4, 100)
		
		item = QtGui.QTableWidgetItem()
		item.setText("Co/Sous Traitant")
		self.tableWidget_reference.setHorizontalHeaderItem(5, item)#rien
		self.tableWidget_reference.setColumnWidth(5, 100)
		
		
		item = QtGui.QTableWidgetItem()
		item.setText("Importance")
		self.tableWidget_reference.setHorizontalHeaderItem(6, item)#rien
		self.tableWidget_reference.setColumnWidth(6, 100)
		
		item = QtGui.QTableWidgetItem()
		item.setText("Année")
		self.tableWidget_reference.setHorizontalHeaderItem(7, item)#rien
		self.tableWidget_reference.setColumnWidth(7, 80)
		
		item = QtGui.QTableWidgetItem()
		item.setText("Montant hono")
		self.tableWidget_reference.setHorizontalHeaderItem(8, item)#rien
		self.tableWidget_reference.setColumnWidth(8, 100)
		
		item = QtGui.QTableWidgetItem()
		item.setText("Num Index")
		self.tableWidget_reference.setHorizontalHeaderItem(9, item)#rien
		self.tableWidget_reference.setColumnWidth(9, 80)
		
		for ligne in range(len(resultat)):
			self.tableWidget_reference.insertRow(self.tableWidget_reference.rowCount())
			self.tableWidget_reference.setRowHeight(self.tableWidget_reference.rowCount()-1,70)
			
			mon_checkBox = QtGui.QCheckBox()
			mon_checkBox.setChecked(True)
			self.tableWidget_reference.setCellWidget(ligne,0,mon_checkBox)
			
			
			archi = resultat[ligne][18]
			text_nature = (resultat[ligne][2]) + " " + (resultat[ligne][3]) + " (" + (resultat[ligne][4]) + ") .Arch.: " +\
			(archi.upper()) + "." +(resultat[ligne][19]) + " " + (resultat[ligne][20]) #upper: met en majuscule (lower minuscule)
			mon_label = QTextEdit_boost()
			QtCore.QObject.connect(mon_label,QtCore.SIGNAL("mon_cellDoubleclicked(QPoint*)"),self.double_clic_ligne_tableau)
			mon_label.setText(text_nature)
			self.tableWidget_reference.setCellWidget(ligne,1,mon_label)
			
			#MOA
			mon_label = QTextEdit_boost()
			QtCore.QObject.connect(mon_label,QtCore.SIGNAL("mon_cellDoubleclicked(QPoint*)"),self.double_clic_ligne_tableau)
			text_MOA = resultat[ligne][6]
			mon_label.setText(text_MOA)
			self.tableWidget_reference.setCellWidget(ligne,2,mon_label)
			
			
			
			#type_tvx
			mon_label = QTextEdit_boost()
			QtCore.QObject.connect(mon_label,QtCore.SIGNAL("mon_cellDoubleclicked(QPoint*)"),self.double_clic_ligne_tableau)
			text_MOA = resultat[ligne][29]
			mon_label.setText(text_MOA)
			self.tableWidget_reference.setCellWidget(ligne,3,mon_label)
			
			#type_mission
			mon_label = QTextEdit_boost()
			QtCore.QObject.connect(mon_label,QtCore.SIGNAL("mon_cellDoubleclicked(QPoint*)"),self.double_clic_ligne_tableau)
			type_mission = resultat[ligne][23]
			type_mission_nettoyage = type_mission.replace('##','-')
			type_mission_nettoyage = type_mission_nettoyage.replace('A - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('B - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('C - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('D - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('E - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('F - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('G - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('H - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('I - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('J - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('K - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('L - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('M - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('N - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('O - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('P - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('Q - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('R - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('S - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('T - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('U - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('V - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('W - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('X - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('Y - ','')
			type_mission_nettoyage = type_mission_nettoyage.replace('Z - ','')
			mon_label.setText(type_mission_nettoyage)
			mon_label.setText(type_mission_nettoyage)
			self.tableWidget_reference.setCellWidget(ligne,4,mon_label)
			
			
			#co sous traitant
			mon_label = QTextEdit_boost()
			QtCore.QObject.connect(mon_label,QtCore.SIGNAL("mon_cellDoubleclicked(QPoint*)"),self.double_clic_ligne_tableau)
			text_MOA = resultat[ligne][5]
			mon_label.setText(text_MOA)
			self.tableWidget_reference.setCellWidget(ligne,5,mon_label)
			
			#Montant - importance des travaux
			mon_label = QTextEdit_boost()
			QtCore.QObject.connect(mon_label,QtCore.SIGNAL("mon_cellDoubleclicked(QPoint*)"),self.double_clic_ligne_tableau)
			Montant = resultat[ligne][9]
			surface_tvx = resultat[ligne][10]
			
			if mode_debuggage == 'oui': print "montant"
			if mode_debuggage == 'oui': print Montant
			
			if Montant <= 999:
				pre_text = QtCore.QString(str(Montant) + " k%1").arg(QtCore.QChar(8364)) #euro signe
			elif Montant > 999:
				pre_text = QtCore.QString(str(float(Montant)/1000) + " M%1").arg(QtCore.QChar(8364))#euro signe
			
			if Montant == 0.0 or Montant == "" or Montant == "0.0":
				pre_text = "-"
			
			pre_text = pre_text.replace('.',',')
			
			if surface_tvx == 0.0 or surface_tvx == "" or surface_tvx == "0.0":
				dede = 2
			else:
				pre_text = pre_text + '\n' + str(surface_tvx)
				#pre_text = QtCore.QString(pre_text + " m%1 (SHON)").arg(QtCore.QChar()) #m² carré
				pre_text = QtCore.QString(pre_text + unicode(" m² (SHON)", "iso-8859-1"))
			mon_label.setText(pre_text)
			
			#msg_3 = unicode("\na bien été ajoutée", "iso-8859-1")	
			
			self.tableWidget_reference.setCellWidget(ligne,6,mon_label)
			
			##Annee reception
			mon_label = QTextEdit_boost()
			QtCore.QObject.connect(mon_label,QtCore.SIGNAL("mon_cellDoubleclicked(QPoint*)"),self.double_clic_ligne_tableau)
			date = resultat[ligne][13]
			avancement = resultat[ligne][15]
			
			if mode_debuggage == 'oui': print "Avancement resultat[ligne][15]"
			if mode_debuggage == 'oui': print resultat[ligne][15]
			
			if resultat[ligne][15] == "étude" or resultat[ligne][15] == "chantier":
				text = "En cours"	
			elif resultat[ligne][15] == "affaire archivée" or resultat[ligne][15] == "affaire à archiver":
				text = str(date.year)
			else:
				text = "pas de DROC"
			mon_label.setText(text)
			self.tableWidget_reference.setCellWidget(ligne,7,mon_label)
				
			#Montant_hono
			mon_label = QTextEdit_boost()
			QtCore.QObject.connect(mon_label,QtCore.SIGNAL("mon_cellDoubleclicked(QPoint*)"),self.double_clic_ligne_tableau)
			Montant_hono = resultat[ligne][24]
			
			if Montant_hono == 0.0 or Montant_hono == "" or Montant_hono == "0.0" or Montant_hono == 0 or Montant_hono == "0":
				mon_label.setText("-")
			else:
				mon_label.setText(QtCore.QString(str(Montant_hono) + " %1").arg(QtCore.QChar(8364))) #euro signe
			
			#mon_label.setText(str(Montant_hono) + " " + (QtCore.QChar(8364)).toLatin1())
			#mon_label.setText(QtCore.QString("Hello, %1 world").arg(QtCore.QChar(8364))) #euro signe
			
			self.tableWidget_reference.setCellWidget(ligne,8,mon_label)
			
			#num_index
			mon_label = QTextEdit_boost()
			QtCore.QObject.connect(mon_label,QtCore.SIGNAL("mon_cellDoubleclicked(QPoint*)"),self.double_clic_ligne_tableau)
			num_index = resultat[ligne][0]
			mon_label.setText(str(num_index))
			self.tableWidget_reference.setCellWidget(ligne,9,mon_label)
	
			
		#	self.tableWidget_reference.setWordWrap(True)
		
	def remplissage_widgets_references(self):
		if mode_debuggage == 'oui': print "remplissage_widgets_references"
	
		
		
		
		mon_ftp = class_FTP_ou_SFTP()
		id=mon_ftp.FTP_ou_SFTP()
	
		
		cur2=id.cursor()
		cur2.execute("SELECT * FROM table_type_de_ref")
		resultat_type_de_ref = list(cur2.fetchall())
		cur2.close()
		id.close()
		
	
		
		if mode_debuggage == 'oui': print type(self.QCB_type_de_ref)
		
		self.QCB_type_de_ref.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection)
		self.QCB_type_de_ref.setMinimumSize(QtCore.QSize(100, 80))
		self.QCB_type_de_ref.setMaximumSize(QtCore.QSize(5000, 80))
		self.QCB_type_de_ref.clear()
		for elem in resultat_type_de_ref:
			#if mode_debuggage == 'oui': print "elem"
			#if mode_debuggage == 'oui': print elem
			self.QCB_type_de_ref.addItem(elem[0])
			
			
		#GLOBAL_mon_tuple_de_tuple_des_configs
		#if mode_debuggage == 'oui': print GLOBAL_mon_tuple_de_tuple_ORIGINAL
		for num in range(len(GLOBAL_mon_tuple_de_tuple_ORIGINAL)):
			if mode_debuggage == 'oui': print GLOBAL_mon_tuple_de_tuple_ORIGINAL[num]
			if GLOBAL_mon_tuple_de_tuple_ORIGINAL[num][0] == "agence#QCB":
				ligne_agence = GLOBAL_mon_tuple_de_tuple_ORIGINAL[num][5]
				premier_split = ligne_agence.split('#&#')
				second_split = premier_split[0].split('#-#')
		
		self.QCB_agence.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection)
		self.QCB_agence.setMinimumSize(QtCore.QSize(100, 80))
		self.QCB_agence.setMaximumSize(QtCore.QSize(5000, 80))
		self.QCB_agence.clear()
		for num_agence in range(1,len(second_split)):
			self.QCB_agence.addItem(second_split[num_agence])
		
		#date bas et haut
		date = QtCore.QDate()
		date_du_jour = date.currentDate()
		date_500_ans = QtCore.QDate()
		#date_500_ans.setDate(01,01,(date_du_jour.addYears(-500)).year())
		date_500_ans.setDate(1800,01,01)
		self.QDateEdit_haut.setDate(date_du_jour)
		self.QDateEdit_bas.setDate(date_500_ans)
			
class Imprimer():
	def references_imprimer_ok(self, repertoire_ODT = "non"):
		#self.option_impression.hide()
		#http://qt.developpez.com/doc/4.7/if mode_debuggage == 'oui': printing/
		
		printer = QtGui.QPrinter()
		printer.setPageMargins(10,10,10,10,0) #0 pour unité millimetre
		

		document=QtGui.QTextDocument()
		dialog = QtGui.QPrintDialog(printer)
		#dialog.setModal(True)
		dialog.setWindowModality(QtCore.Qt.ApplicationModal)
		dialog.setWindowTitle("Coucou titre" )
		
		mon_logo = "logo_grenoble.png" #BUG pour clermont : "logo_clermont.png"
		
		"""
		if mode_debuggage == 'oui': print "mon_dialog_pre_imprim"
		if mode_debuggage == 'oui': print mon_dialog_pre_imprim
		if mode_debuggage == 'oui': print type(mon_dialog_pre_imprim)
		if mode_debuggage == 'oui': print mon_dialog_pre_imprim.children()
		list_children = mon_dialog_pre_imprim.children()
		
		for elem in list_children:
			if mode_debuggage == 'oui': print elem.objectName()
		"""
		
		list_type_de_ref = mon_dialog_pre_imprim.findChild(QtGui.QListWidget,"QCB_type_de_ref").selectedItems()
		
		
		############################################################
		
		#on crée un curseur a l'endroit du curseur actuel
		cursor = QtGui.QTextCursor(document)
		
		###en tête ECHOLOGOS AUVERGNE ou GRENOBLE
		mon_image1 = QtGui.QTextImageFormat()
		#exec("mon_image1.setName(_fromUtf8('%s%s'))") % (chemin_icone, "/listen.png")
		exec("mon_image1.setName(_fromUtf8('%s%s'))") % (GLOBAL_chemin_icone, mon_logo)
		mon_image1.setWidth(400)
		mon_image1.setHeight(100)
		
		format0 = QtGui.QTextCharFormat()
		format0.setFontPointSize(10)
		
		format1 = QtGui.QTextCharFormat()
		format1.setFontPointSize(10)
		format1.setFontItalic(True)
		
		
		cursor.insertImage(mon_image1)
		cursor.insertText("\n")
		
		for elem in list_type_de_ref:
			mon_blockformat = cursor.blockFormat()
			mon_alignement = QtCore.Qt.AlignLeft
			mon_blockformat.setAlignment(mon_alignement)
			cursor.setBlockFormat(mon_blockformat)
			cursor.insertText(elem.text(),format1)
			cursor.insertText(" - ",format1)
		
			
		cursor.movePosition(cursor.Left, cursor.KeepAnchor, 2)  #je bouge 2 fois sans bouger l'ancre
		cursor.removeSelectedText #on effeace
		cursor.insertText("\n")
		#http://www.unixgarden.com/index.php/gnu-linux-magazine/qt-4-4-textes-enrichis-et-documents-structures
		#http://pyqt.sourceforge.net/Docs/PyQt4/qtextcursor.html#MoveOperation-enum
		
		
		mon_blockformat = cursor.blockFormat()
		mon_alignement = QtCore.Qt.AlignRight
		mon_blockformat.setAlignment(mon_alignement)
		cursor.setBlockFormat(mon_blockformat)
		cursor.insertText("D'autres références sur www.echologos.fr",format1)
		cursor.insertText("\n")
	

		#http://pyqt.sourceforge.net/Docs/PyQt4/qt.html#AlignmentFlag-enum
		mon_blockformat = cursor.blockFormat()
		mon_alignement = QtCore.Qt.AlignHCenter
		mon_blockformat.setAlignment(mon_alignement)
		cursor.setBlockFormat(mon_blockformat)
		cursor.insertText("Rôle tenu par le candidat : BET acoustique",format1)
		cursor.insertText("\n")
		
		#### FIN ENTETE ECHOLOGOS 
		
		
		##################  TABLEAU  #########"
		#retourne le nom du tab puis on numéro (on passe par l'index sinon, ça plante lorsqu'on supprime des circuits):
		

		cursor.movePosition(cursor.End)
	

		
		#on crée un block pour le tableau
		cursor.beginEditBlock()
	
		#Creation du format du tableau qui sera imprimer
		tableFormat = QtGui.QTextTableFormat()
		tableFormat.setAlignment(QtCore.Qt.AlignHCenter)
		#tableFormat.setAlignment(QtCore.Qt.AlignLeft)
		tableFormat.setBackground(QtGui.QColor("#ffffff")) #blanc
		tableFormat.setCellPadding(5)
		tableFormat.setCellSpacing(0)
		#tableFormat.setWidth(2000)
		#tableFormat.setLeftMargin(10) #marge dans le browser, grrrr
		#tableFormat.setRightMargin(10) #marge dans le browser, grrrr
		
		
		#Mise en page des colonnes du super tableau des références
		
		mon_list_de_QTextLength = []
		mon_list_de_QTextLength.append(QtGui.QTextLength(2,22)) #type, largeur type:  0:variable ,1:fixe ,2:percentage
		mon_list_de_QTextLength.append(QtGui.QTextLength(2,22)) #type, largeur type:  0:variable ,1:fixe ,2:percentage
		mon_list_de_QTextLength.append(QtGui.QTextLength(2,10)) #type, largeur type:  0:variable ,1:fixe ,2:percentage
		mon_list_de_QTextLength.append(QtGui.QTextLength(2,14)) #type, largeur type:  0:variable ,1:fixe ,2:percentage
		mon_list_de_QTextLength.append(QtGui.QTextLength(2,8)) #type, largeur type:  0:variable ,1:fixe ,2:percentage
		mon_list_de_QTextLength.append(QtGui.QTextLength(2,9)) #type, largeur type:  0:variable ,1:fixe ,2:percentage
		mon_list_de_QTextLength.append(QtGui.QTextLength(2,6)) #type, largeur type:  0:variable ,1:fixe ,2:percentage
		mon_list_de_QTextLength.append(QtGui.QTextLength(2,9)) #type, largeur type:  0:variable ,1:fixe ,2:percentage
		tableFormat.setColumnWidthConstraints(mon_list_de_QTextLength)
		
		
		
		#tableFormat.setPageBreakPolicy(tableFormat.PageBreak_AlwaysAfter) #page break - saut de page!!!! vis à vis du tableu: on lui indique d'insérer un saut de page toujours après le tableau!!
		tableFormat.setPageBreakPolicy(tableFormat.PageBreak_Auto)
		
		
		#Creation du tableau qui sera imprimé avec le nombre de colonne 
		#et de ligne que contient le tableau mis en parametre
		#exec("ui.tableWidget%s = QtGui.QTableWidget(ui.tab%s)" % (numero_circuit, numero_circuit))
		#QTextTable * tableau = cursor.insertTable(tableau_a_imprimer->rowCount()+1, tableau_a_imprimer->columnCount(), tableFormat);
		
		
		nb_ligne = mon_dialog_pre_imprim.findChild(QtGui.QTableWidget,"tableWidget_reference").rowCount()
		
	
		if mode_debuggage == 'oui': print "nb_ligne"
		if mode_debuggage == 'oui': print type(nb_ligne)
		if mode_debuggage == 'oui': print nb_ligne
		nb_colonne = 8
		
		#tableFormat.setPageBreakPolicy(tableFormat.PageBreak_Auto)
		tableau = cursor.insertTable(1, nb_colonne, tableFormat) #ici, tableau est un QTextTable
		
	
		frame = cursor.currentFrame()
		frameFormat = frame.frameFormat()
		frameFormat.setBorder(0)
		frame.setFrameFormat(frameFormat)
	
		#Format des HEADER du tableau
		format_entete_tableau = QtGui.QTextCharFormat() 
		format_entete_tableau.setFontPointSize(13)
		mon_QFont = QtGui.QFont()
		mon_QFont.setWeight(99) # gras ou moins gras
		format_entete_tableau.setFont(mon_QFont)
		format_entete_tableau.setFontItalic(True)
		
	
		#format_entete_tableau.setFontWeight(QFont::Bold);
	
		#on ecrit les HEADERS du tableaux CIRCUIT dans le tableau a imprimer
		Header = 1
		if Header == 1:
			list_text = []
			list_text.append("Nature de l'opération")
			list_text.append("Maître d'ouvrage")
			list_text.append("Type de travaux (neuf, extension, réhabilitation")
			list_text.append("Type de mission de maîtrise d'oeuvre")
			list_text.append("Co/Sous Traitant")
			list_text.append("Importance (montant H.T. des travaux et/ou surface)")
			list_text.append("Année")
			list_text.append("Montant H.T. des honoraires")
			for col in range(nb_colonne):	
				#http://pyqt.sourceforge.net/Docs/PyQt4/qtexttablecellformat.html#details
				cellule = tableau.cellAt(0,col) #cellule
				cellCursor = cellule.firstCursorPosition() #cellCursor est un QTextCursor

				mon_blockformat = cellCursor.blockFormat()
				mon_alignement = QtCore.Qt.AlignHCenter
				#http://pyqt.sourceforge.net/Docs/PyQt4/qt.html#AlignmentFlag-enum
				mon_blockformat.setAlignment(mon_alignement)
				cellCursor.setBlockFormat(mon_blockformat)
				cellCursor.insertText(unicode(list_text[col], "iso-8859-1"),format_entete_tableau)
		
		
		
		
		#impression des données CIRCUIT dans le tableau		
		cursor.insertText("\n")
		

		lignes_a_supprimer = []
		for row in range(1,(nb_ligne+1)):
		
			tableau.insertRows(row,1)
			for col in range(nb_colonne):
			
				#http://pyqt.sourceforge.net/Docs/PyQt4/qtexttablecellformat.html#details
				cell = tableau.cellAt(row,col) #cellule est un QTextTableCell
				#cell.setLeftPadding(0) #marche pas
				cellCursor = cell.firstCursorPosition()		
				exec("mon_widget = mon_dialog_pre_imprim.findChild(QtGui.QTableWidget,'tableWidget_reference').cellWidget(%s,%s)" % (row-1,col+1))
				if mode_debuggage == 'oui': print "mon_widget"
				if mode_debuggage == 'oui': print type(mon_widget)
				if mode_debuggage == 'oui': print mon_widget
				mon_blockformat = cellCursor.blockFormat()
				
				if col >= 2:
					mon_alignement = QtCore.Qt.AlignHCenter
				else:
					mon_alignement = QtCore.Qt.AlignLeft
				#http://pyqt.sourceforge.net/Docs/PyQt4/qt.html#AlignmentFlag-enum
				
				mon_blockformat.setAlignment(mon_alignement)
				cellCursor.setBlockFormat(mon_blockformat)
				
				cellCursor.insertText(mon_widget.toPlainText())
				#doudouille
				#http://stackoverflow.com/questions/5187484/how-to-center-text-in-qtexttable
				
			exec("mon_case_coche = mon_dialog_pre_imprim.findChild(QtGui.QTableWidget,'tableWidget_reference').cellWidget(%s,0)" % (row-1))
			if mode_debuggage == 'oui': print "mon_case_coche"
			if mode_debuggage == 'oui': print type(mon_case_coche)
			if mode_debuggage == 'oui': print mon_case_coche
			if mon_case_coche.isChecked() == False:
				lignes_a_supprimer.append(row)
			
			
			
		if mode_debuggage == 'oui': print "lignes_a_supprimer"	
		if mode_debuggage == 'oui': print lignes_a_supprimer	
		lignes_a_supprimer.reverse()
		for num in range(len(lignes_a_supprimer)):
			#if mode_debuggage == 'oui': print elem
			tableau.removeRows(lignes_a_supprimer[num]+1,1)	
	

				
		#fin de l'edition
		cursor.endEditBlock()
		cursor.movePosition(cursor.End)
		cursor.insertText("Ces références sont présentées suivant le modèle préconisé par la Mission Interministérielle pour la Qualité des Constructions Publiques (MIQCP).",format1)
		
		
		############################################################
		############################################################
		############################################################
		
		
		
		######## DEBUT CREATION fichier ODT ##############
		if mon_dialog_pre_imprim.findChild(QtGui.QCheckBox,'checkBox_fichierODT').isChecked() == True:			
			#impression au format ouvert ODF ODT
			chemin_complet = os.path.join(GLOBAL_repertoire_pour_ODT, unicode("tableau_des_references_MIQCP.odt")) #concatène le chemin
			if mode_debuggage == 'oui': print "chemin_complet ODT"
			if mode_debuggage == 'oui': print chemin_complet
			mon_writer = QtGui.QTextDocumentWriter(chemin_complet)
			mon_writer.setFormat("odf")
			mon_writer.write(document)
		######## FIN CREATION fichier ODT ##############
		
		
		if dialog.exec_() == True:
			printer.setOrientation(QtGui.QPrinter.Landscape) #grosse astuce, il faut définir l'orienttaion après que la fenetre de config soit fermée, sinon, ça prend en compte le paramètre de config impirmante de base
			
			#impression de notre editor dans le QPrinter initialisé au début de la fonction		
			document.print_(printer)
			
			print "printer.copyCount()"
			printer.copyCount()
			
			mon_dialog_pre_imprim.close()
		
	def references_imprimer_ok_sert_a_rien_avec_Qpainter(self):
		#http://zetcode.com/tutorials/pyqt4/drawing/
		
		
		monwidget = mon_form.qtableWidget_resultat
		printer_device = QtGui.QPrinter()
		painter = QtGui.QPainter(printer_device)
		
		#printer_device = QtGui.QPaintDevice()
		painter.begin(printer_device)
		
	 
		xscale = printer_device.pageRect().width()/(monwidget.width())
		yscale = printer_device.pageRect().height()/(monwidget.height())
		scale = min(xscale,yscale)
		
		painter.translate(printer_device.paperRect().x() + printer_device.pageRect().width()/2, printer_device.paperRect().y() + printer_device.pageRect().height()/2)
		painter.scale(scale, scale)
		#painter.translate(-width()/2, -height()/2)
		
		monwidget.render(painter)
		painter.end()
		
		
		"""
		QPainter painter;
		painter.begin(&printer);
		double xscale = printer.pageRect().width()/double(myWidget->width());
		double yscale = printer.pageRect().height()/double(myWidget->height());
		double scale = qMin(xscale, yscale);
		painter.translate(printer.paperRect().x() + printer.pageRect().width()/2,
							printer.paperRect().y() + printer.pageRect().height()/2);
		painter.scale(scale, scale);
		painter.translate(-width()/2, -height()/2);

		myWidget->render(&painter);
		"""

	#http://python.developpez.com/faq/?page=Generalites#GenExecuteFile		
from asyncore import dispatcher #module pour la classe serveur
import sys, time, socket #module pour la classe serveur
#http://venom630.free.fr/geo/tutz/programmation/python/sockets/
class Server( dispatcher ): #creation d'un mini serveur qui emp^che l'éxécution multiple: http://python.developpez.com/faq/?page=Generalites
  def __init__(self):
    dispatcher.__init__(self)
    self.create_socket( socket.AF_INET, socket.SOCK_STREAM )
    self.bind(('', 50010 ) ) #en cas de creation d'autre programme, il faut changer ce numéro de port qui est crée et existe tant que "la_base_des_programmes" fonctionne
    self.listen(1) #accepte une seule connection à la fois

try:
	Server()
	if __name__ == "__main__":
		import sys	
		#"infos systeme"
		
		chemin_fichier_courant = sys.argv[0]
		
		#fenetre principale
		app = QtGui.QApplication(sys.argv)
		MainWindow = QtGui.QMainWindow()
		
		
		mon_form = Ui_MainWindow_surclasse()    # Ton interface,
		mon_form.setupUi2(MainWindow)    # il la lance
		if mode_debuggage == 'oui': print "zaza43"
		#MainWindow.setMaximumSize(800,600)
		
		#logo
		exec("MainWindow.setWindowTitle(_fromUtf8('%s_%s'))" % (GLOBAL_nom_programme, GLOBAL_version_programme))
		exec("MainWindow.setWindowIcon(QtGui.QIcon(_fromUtf8('%s%s')))" % (GLOBAL_chemin_icone, "/logo2.png"))
		
		if mode_debuggage == 'oui': print "zaza48"
		try:
			mon_setting = QtCore.QSettings("Echologos", "Basaffaire")
			dimension_mainwindow = mon_setting.value('visuel/dimension_main_window')
			MainWindow.restoreGeometry(dimension_mainwindow.toByteArray())
		except:
			titi =2
		if mode_debuggage == 'oui': print "zaza49"
		
		if dimension_mainwindow.toByteArray() == "":
			MainWindow.setGeometry(100,100,200,200) #évite le bug de compilation sur pyinstaller casse tete marco 5h!!!
			
		MainWindow.show()         # On affiche l'interface	
			
		
		if mode_debuggage == 'oui': print "zaza50"
		
		from PyQt4.QtCore import QT_VERSION_STR
		from PyQt4.pyqtconfig import Configuration
		if mode_debuggage == 'oui': print "infos systeme"
		if mode_debuggage == 'oui': print("Qt version:", QT_VERSION_STR)
		cfg = Configuration()
		if mode_debuggage == 'oui': print("SIP version:", cfg.sip_version_str)
		if mode_debuggage == 'oui': print("PyQt version:", cfg.pyqt_version_str)
		
		if mode_debuggage == 'oui': print ("version de python:", sys.version_info)
 
		sys.exit(app.exec_())

except(e):
	if mode_debuggage == 'oui': print 'Un programme deja en service, impossible de lancer un deuxieme'
	if mode_debuggage == 'oui': print e
	sys.exit()		
	
	

#####################################         BASE MYSQL - debut     ##################################" 
"""
	Nouvelle Base 2013
    Hôte de connexion (HOST) : cl1-sql7
    Nom d'utilisateur (LOGIN) : echologos7
    Mot de passe (PASSWORD) : 4jsk3b87j6333i
    Nom de BASE : echologos7
"""
	
###Nom de table: "base_des_affaires1"
"""		
	codage en UTF8_unicode_ci
	1	index cle primaire avec auto incrément
	2	affaire#QLE	  - NE JAMAIS MODIFIER CE CHAMP									VARCHAR		QlineEdit				Affaire	
	3	intitule#QTE																TEXT		QtextEdit				Intitulé opération
	4	commune#QLE																	VARCHAR		QlineEdit				Commune affaire
	5	dpt_affaire#QCB#QPB#sc#departement											VARCHAR		QComboBox				Département affaire
	6	co_sous_trait#QCB															VARCHAR		QComboBox				Sous trait#-#Co-traitant#-#Sous-Traitant#-#Client direc
	7	maitre_ouvrage#QLE															VARCHAR		QlineEdit				Maître d'ouvrage
	8	coord_maitre_ouvrage#QTE													TEXT		QtextEdit				Coordonnées MOA
	9	montant#QLE																	INT			QlineEdit				Montant travaux
	10	surface#QLE																	VARCHAR		QlineEdit				Surface travaux
	11	adresse_chantier#QTE														TEXT		QtextEdit				Adresse chantier
	12	DROC#QDE																	DATE		QDateEdit	 ??			Date de la DROC
	13	date_rec_travaux#QDE														DATE		QDateEdit	??			Date réception tvx
	14	num_boite_archive#QLE														INT			QlineEdit				Num boite archive
	15	avancement#QCB																VARCHAR		QComboBox				Avancement#-#Concours:#-#étude#-#chantier#-#à archiver#-#archive#-#sans suite#-#concours perdu#-#expertis
	16	date_pouvoir#QDE															DATE		QDateEdit				Date d'envoi pouvoir
	17	charge_affaire#QCB#QPB#sc#table_personnel#papa								VARCHAR		QComboBox				Chargé d'affaires
	18	donneur_ordre#QCB#QPB#sc#table_archis										VARCHAR		QlineEdit				Donneur d'ordre
	19	responsable_donneur_ordre#QLE												VARCHAR		QlineEdit				Responsable DO
	20	commentaires#QTE															TEXT		Qtextedit				Commentaires
	21	mission#QLW#QPB#mc#table_type_de_mission#papa								VARCHAR		QLineEdit				Missions
	22	montant_hono#QLE															INT			QLineEdit				Montant honoraires
	23	prochaine_echeance#QDE														DATE		QDateEdit				Date future échéance
	24	type_echeance#QCB															VARCHAR		QComboBox				Type d'échéance#-#concours#-#APS#-#APD#-#PRO#-#PRO/DCE#-#DCE#-#VISA#-#EXE#-#CHANTIER#-#Rapport d'étude#-#Note acoustique#-#Note divers
	25  type_de_ref#QLW#QPB#mc#table_type_de_ref#papa								VARCHAR		QListWidget				Type de référence
	26  mesures#QLW#QPB#mc#table_type_de_mesures#papa								VARCHAR		QListWidget				Type de référence
	27	type_de_travaux#QCB															VARCHAR		QComboBox				Type de travaux:#-#concours#-#APS#-#APD#-#PRO#-#PRO/DCE#-#DCE#-#VISA#-#EXE#-#CHANTIER#-#Rapport d'étude#-#Note acoustique#-#Note divers
	
	
	# les  QLW QListWidget et les QCB peuvent être reliées à des tables Mysql: le 3ème split # représente le num de colonne à parser dans la table
	#
	# le mot de passe est est tout à la fin de la ligne des QLW
"""	
	
###Nom de table: "preferences_utilisateurs"
"""	
	codage en UTF8_unicode_ci
	1	nom_utilisateur						VARCHAR
	2	ordre_parametres_de_tri				VARCHAR
	3	ordre_col_tableau_resultat			VARCHAR
	4	ordre_zone_scroll_area				VARCHAR
	
"""
	
	#####################################         CHAMPS DE LA BASE MYSQL - fin     ##################################"