#!/usr/bin/env python
# -*- coding:UTF-8 -*-

#-------------------------------------------------------------------------------
# Name:        module1
# Purpose:
#
# Author:      MACHADO.F
#
# Created:     13/04/2012
# Copyright:   (c) MACHADO.F 2012
# Licence:     <your licence>
#-------------------------------------------------------------------------------
"""
Options standard

    activestyle         :Spécifie l'apparence de la ligne active de la liste.
    background  / bg    :Couleur de fond.
    disabledbackground  :Couleur de fond quand le widget est à l'état DISABLED.
    disabledforeground  :Couleur de premier plan affichée quand l'état
                         du widget est DISABLED.
    exportselection     :Par défaut, l'utilisateur sélectionner le texte avec
                         la souris et le texte choisi sera exporté au
                         presse-papiers.
                         Pour mettre hors service ce comportement,
                         utilisez exportselection=0.
    command             :Lance une commande lors du changement de la valeur du
                         champ de saisie.
    borderwidth / bd    :Largeur de la frontière autour de la combobox.
    cursor              :Curseur utilisé quand la souris est sur le widget.
    foreground  / fg    :Couleur du texte.
    highlightbackground :Couleur highlight quand le widget n'a pas de focus.
    highlightcolor      :Couleur highlight quand le widget a un focus.
    highlightthickness  :Intensité de la couleur de focus.
    height              :Nombre de lignes affichés dans la liste.
    insertbackground    :Couleur du curseur d'insertion.
    insertborderwidth   :
    insertofftime       :Clignotement du curseur, temps où il est éteint.
    insertontime        :Clignotement du curseur, temps où il est allumé.
    insertwidth         :Largeur du curseur. 2 pixels par défaut.
    items               :Liste de éléments.
    justify             :Emplacement du texte.
    listvariable        :StringVar connecté à la liste complète.
    matchrequired       :La valeur de saisie doit être dans la liste.
                         Si elle n'y figure pas, le premier élément de la liste
                         est sélectionné
    nodouble            :Enlève les doubles de la liste.
                         0:Ne fait rien (par défaut)
                         1:Supprime les doubles
    readonlybackground  :Couleur de fond l'état du widget est "readonly".
    relief              :Effets tridimensionnels autour de l'entrée de texte.
    selectbackground    :Couleur de fond à l'affichage du texte sélectionné.
    selectborderwidth   :Largeur de la frontière utilisé autour du texte
                         sélectionné. Par défaut un pixel.
    selectforeground    :Couleur de premier plan du texte sélectionné.
    sort                :Tri la liste suivant la valeur renseignée.
                         None       :Pas de tri (par défaut)
                         sort       :Tri croissant par ordre alphanumérique
                         reversed   :Tri décroissant par ordre alphanumérique
                         reverse    :inversion de la liste
    state               :Etat du widget (NORMAL, DISABLED).
    takefocus           :Normalement, le focus contrôle le widget;
                         fournissez la valeur 0 à cette option pour obtenir
                         l'interruption du contrôle de focus.
    textvariable        :StringVar associé à la zone de saisie.
    width               :Largeur de l'étiquette en caractères (pas pixels!).
                         La largeur est basée sur la moyenne des caractères,
                         donc quelques chaînes dans des polices de caractères.
                         proportionnelles ne peuvent pas aller à cette longueur.
    xscrollcommand      :A lier avec une scrollbar pour faire défiler le texte
                         de la boite de saisie si ce texte est trop long.

Methode

    append_             :Ajout d'un élément à la fin d'une liste.*
    change_list         :Remplace la liste par une nouvelle.*
    clear_list          :Vide la liste
    extend_             :Concatène la liste d'origine avec la liste <otherlist>.*
    get                 :Récupère la valeur du champ de saisie.
    index_to_item       :Renvoi l'élément de la liste se trouvant à la ligne(index)
    insert_             :Ajout d'un élément dans la liste à la ligne index.*
    item_to_index       :Renvoi l'<index> (ligne), de la liste, correspondant
                         à <item>
    remove_             :Supprime un élément de la liste
    set                 :Modifie le champ de saisie avec la valeur renseignée.
    size                :Renvoi le nombre d'élément de la liste

    * Les méthodes de suppression de double et de tri sont aussi appelé.
      Vérifier les options nodouble et sort.
"""
from tkinter import *
from time import *
#import tkinter.messagebox as tkMessageBox

class Combobox(Frame):
    """Champ de saisie associé à une liste déroulante"""
    def __init__(self, master=None, command = '', height=10, items=[],
                    matchrequired=0, nodouble = 0, sort=None, width=20, **Arg
                    ):
        """Construit un Widget Combobox avec master comme parent

            Option Standard

                    activestyle, background  / bg,
                    disabledbackground, disabledforeground,
                    exportselection, borderwidth / bd, command,
                    cursor, foreground  / fg, highlightbackground,
                    highlightcolor, highlightthickness, height,
                    insertbackground, insertborderwidth,
                    insertofftime, insertontime, insertwidth,
                    items, justify, listvariable, matchrequired,
                    nodouble, readonlybackground, relief,
                    selectbackground, selectborderwidth,
                    selectforeground, sort, state, takefocus,
                    textvariable, width, xscrollcommand

            Methode

                    append_, change_list, clear_list, extend_,
                    get, index_to_item, insert_, item_to_index,
                    remove_, set, size
        """
        self.Arg=Arg  # Dictionnaire des options de configuration de la Combobox
        self.command=command
        self.height = height
        self.index = -1
        self.items = items
        self.master = master
        self.matchrequired = matchrequired
        self.nodouble = nodouble
        self.sort = sort
        self.sVar = StringVar()
        self.width = width
        self.widget_option = {}
        self.widget_option['button'] = ('bg', 'background', 'cursor', 'fg',
                    'foreground', 'highlightbackground', 'highlightcolor',
                    'highlightthickness', 'relief',
                    )
        self.widget_option['entry'] = ('bg', 'background', 'cursor',
                    'disabledbackground', 'disabledforeground',
                    'exportselection','fg', 'foreground', 'highlightbackground',
                    'highlightcolor', 'highlightthickness', 'insertbackground',
                    'insertborderwidth', 'insertofftime', 'insertontime',
                    'insertwidth', 'justify', 'readonlybackground', 'relief',
                    'selectbackground', 'selectborderwidth', 'selectforeground',
                    'state', 'takefocus', 'textvariable', 'width',
                    'xscrollcommand',
                    )
        self.widget_option['frame'] = ('bd', 'borderwidth', 'cursor',
                    'height', 'highlightbackground',
                    'highlightcolor', 'highlightthickness', 'padx', 'pady',
                    'relief', 'takefocus', 'width',
                    )
        self.widget_option['listbox'] = ('activestyle', 'bg', 'background',
                    'cursor', 'exportselection', 'fg', 'foreground', 'height',
                    'highlightbackground', 'highlightcolor',
                    'highlightthickness', 'listvariable', 'relief',
                    'selectbackground', 'selectborderwidth', 'selectforeground',
                    'width',
                    )
        self.widget_option['scrollbar'] = ('bg', 'background', 'cursor',
                    'highlightbackground', 'highlightcolor',
                    'highlightthickness', 'relief',
                    )
        self.widget_option['toplevel'] = ('bg', 'background', 'cursor',
                    'highlightbackground', 'highlightcolor',
                    'highlightthickness', 'relief',
                    )

        # <Frame>---------------------------------------------------------------
        Frame.__init__(self, master, self.__widget_arg__('frame', self.Arg))

        if type(self.items) != list:
            if type(self.items) == tuple:
                self.items = list(self.items)
            else:
                self.items=['Liste incorrecte']

        self.bind('<FocusOut>', self.__match_required__)
        self.__nodouble_in_list__()
        self.__sort_list__()
        self.__initialize__()

    def test(self, event):
        print(event.widget)


    # Initialise la partie graphique
    def __initialize__(self):
        """Fonction interne"""

        # Actualise <Entry> en fonction de <self.index>
        def __actu_entry__():
            """Fonction interne"""
            if len(self.items)!= 0:
                indexmax=len(self.items) - 1
                if self.index >= indexmax:
                    self.index = indexmax
                if self.index <= 0:
                    self.index= 0
                self.set(self.index_to_item(self.index))
                self.__command__()
            else: self.index = -1

        # Autocomplétion lors de la saisie de texte
        def __auto_completion__(event):
            """Fonction interne"""
            if event.keysym not in ['BackSpace', 'Delete', 'Down', 'Up']:
                index = -1
                for item in self.items:
                    index += 1
                    if self.sVar.get() in item[:(len(self.sVar.get()))]:
                        self.sVar.set(item)
                        self.entry.select_range(INSERT,END)
                        self.index = index
                        self.__command__()
                        break
                    else:
                        self.__command__()


        # Action de la touche bas du clavier.
        # fait défiler les items de la liste vers le bas
        def __keypress_down__(event=None):
            """Fonction interne"""
            self.index = self.index + 1
            __actu_entry__()

        # Action de la touche haut du clavier.
        # fait défiler les items de la liste vers le haut
        def __keypress_up__(event=None):
            """Fonction interne"""
            self.index = self.index - 1
            __actu_entry__()

        # Déplacement de la molette de souris quand le focus est sur <Entry>
        # Action de la molette de la souris. Défilement des items de la liste.
        def __mouse_wheel__(event):
            """Fonction interne"""
            self.index = self.index + int(-event.delta/120)
            __actu_entry__()
        # <Entry>---------------------------------------------------------------
        self.entry=Entry(self, self.__widget_arg__('entry', self.Arg),
                         borderwidth=0, font='Arial, 8', textvariable=self.sVar,
                         width = self.width)
        self.entry.grid(row=0, column=0)
        self.entry.bind('<Down>',__keypress_down__)          # touche bas
        self.entry.bind('<KeyRelease>',__auto_completion__)
        self.entry.bind('<MouseWheel>',__mouse_wheel__)      # Molette de souris
        self.entry.bind('<Up>',__keypress_up__)              # touche haut
        # <Button>--------------------------------------------------------------
        self.sVarbutton=StringVar()
        self.sVarbutton.set('▼')
        self.button=Button(self, self.__widget_arg__('button', self.Arg),
                            background='white', disabledforeground='black',
                            borderwidth=0, command=self.__open_list__,
                            font='Arial, 7', height=1, takefocus=0,
                            textvariable=self.sVarbutton)
        self.button.grid(row=0, column=1)

    # lance la commande associé à la combobox en récupérant le contenu de <Entry>
    def __command__(self):
        """Fonction interne"""
        try: self.command(self.sVar.get())
        except: pass

    # Créer la <Toplevel> contenant la <Listbox>
    def __create_toplevel__(self):
        """Fonction interne"""
        # Rend l'utilisation du <bouton-1> au <Button>
        def active_button(event_add=None):
            self.button.config(state=NORMAL)
            self.sVarbutton.set('▼')

        # Ferme la liste
        def close_list(event=None):
            """Fonction interne"""
            self.toplevel.destroy()
            self.after(1, active_button)

        # Déplacement de la souris dans <Listbox>
        def move_mouse(event):
            """Fonction interne"""
            self.listbox.selection_clear(0,END)
            self.listbox.activate(self.listbox.nearest(event.y))
            self.listbox.selection_set(self.listbox.nearest(event.y))

        # Sélection d'une item dans <Listbox>
        def select_item(event=None):
            """Fonction interne"""
            if int(self.listbox.size()):            # <Listbox> non vide
                index=self.listbox.curselection()   # renvoie un tuple d'index
                ind0 =int(index[0])                 # on ne garde que le premier
                self.index=ind0
                item=self.listbox.get(ind0)
                # <Entry>: Actualisation suivant l'item choisi dans la <Listbox>
                self.sVar.set(item)
                # <Entry>: Prend le focus
                self.entry.focus_set()
                # <Entry>: Déplace le curseur au début
                self.entry.icursor(0)
                # <Entry>: Sélectionne le mot
                self.entry.select_range(0,END)
                # <Toplevel>: Destruction
            close_list()
            self.__command__()

        # <Toplevel>------------------------------------------------------------
        self.toplevel=Toplevel(self,
                                self.__widget_arg__('toplevel', self.Arg),
                                #height=self.height,
                                )
        #<Toplevel>: Supprime le contour de fenetre
        self.toplevel.overrideredirect(1)
        #<Toplevel>: Geometrie
        x=self.entry.winfo_rootx()             # Coordonnees reelles de
        y=self.entry.winfo_rooty()             # <Entry>
        xTop, yTop=x-2, y + 18
        self.toplevel.geometry("+{}+{}".format(xTop, yTop))
        # <Toplevel> tjs en 1er plan
        self.toplevel.transient()
        # <Toplevel>: Perte du focus, la <Toplevel> se ferme
        self.toplevel.bind('<FocusOut>', close_list)
        self.button.config(state=DISABLED)

        # <Listbox>-------------------------------------------------------------
        self.listbox=Listbox(self.toplevel,
                                self.__widget_arg__('listbox', self.Arg),
                                width = self.width+2, height=self.height,
                                )
        self.listbox.pack(side=LEFT)
        # <ListBox>: Remplissage
        for it in self.items:
            self.listbox.insert(END, it)
        # <Listbox>: prend le focus
        self.listbox.focus()
        # <Listbox>: Action
        self.listbox.bind('<Button-1>', select_item)
        self.listbox.bind('<Motion>', move_mouse)
        # <listbox>: Sélection de l'item = <Entry>
        index = self.item_to_index(self.sVar.get())
        if self.index_to_item(self.index) == self.sVar.get():
            if self.index != index:
                index=self.index
        else:
            index=0
        # <listbox>: Positionne le cuseur sur la valeur de <Entry>
        self.listbox.activate(index)
        self.listbox.selection_set(index)
        self.listbox.see(index)

        # <Scrollbar>-----------------------------------------------------------
        if len(self.items) > self.height:
            # <Scrollbar>: Association avec <Listbox>
            self.scrollbar=Scrollbar(self.toplevel,
                                self.__widget_arg__('scrollbar', self.Arg),
                                 borderwidth=0,
                                 command=self.listbox.yview, width=15,
                                )
            # <scrollbar>: Implantation
            self.scrollbar.pack(expand =YES, fill =Y)
            # <Listbox>: Association avec <scrollbar>
            self.listbox.config(yscrollcommand=self.scrollbar.set)
            self.listbox.config(width=self.width)

    # Vérifie que la valeur saisie est dans la liste
    def __match_required__(self, event=None):
        """Fonction interne"""
        if self.matchrequired:
            listboxId = 0
            try:
                # Si la <Listbox> prend le focus on ne vérifie pas
                if self.nametowidget(self.focus_get()) == self.nametowidget(self.listbox):
                    listboxId = 1
            except:
                pass
            if not listboxId:
                if not self.sVar.get() in self.items:
                    if self.index == -1:
                        self.sVar.set(self.items[0])
                        self.index=0
                    else:
                        self.sVar.set(self.items[self.index])

    # Suppression des doubles dans la liste
    def __nodouble_in_list__(self):
        """Fonction interne"""
        if self.nodouble:
            index0=0
            while index0 < len(self.items)-1:
                index1 = len(self.items)-1
                while index1 != index0:
                    if self.items[index0] == self.items[index1]:
                        del(self.items[index1])
                    index1 -= 1
                index0 += 1

    # Ouvre la liste
    def __open_list__(self, event=None):
        """Fonction interne"""
        self.__create_toplevel__()
        self.sVarbutton.set('▲')

    # Tri la liste suivant l'option
    def __sort_list__(self):
        """Fonction interne"""
        if self.sort == 'sort': self.items.sort()
        elif self.sort == 'reversed': self.items.sort(reverse=True)
        elif self.sort == 'reverse': self.items.reverse()

    # Retourne la liste des options d'un widget
    def __widget_arg__(self, name, arg = {}):
        """Fonction interne"""
        dic_arg={}
        for option in arg:
            if option in self.widget_option[name]:
                dic_arg[option]=arg[option]
        return dic_arg

    #
    def append_(self, string=''):
        """Ajout d'un élément à la fin d'une liste.
           Les méthodes de suppression de double et de tri sont
           aussi appelé.
           Vérifier les options nodouble et sort."""
        self.items.append(string)
        self.__nodouble_in_list__()
        self.__sort_list__()

    #
    def change_list(self, newlist=()):
        """Remplace la liste par une nouvelle"""
        self.items=newlist
        self.__nodouble_in_list__()
        self.__sort_list__()

    #
    def clear_list(self):
        """Vide la liste"""
        self.items = []

    #
    def extend_(self, otherlist=[]):
        """Concatène la liste d'origine avec la liste <otherlist>.
           Les méthodes de suppression de double et de tri sont
           aussi appelé.
           Vérifier les options nodouble et sort."""
        self.items.extend(otherlist)
        self.__nodouble_in_list__()
        self.__sort_list__()

    #
    def get(self):
        """Récupère la valeur du champ de saisie"""
        return self.sVar.get()

    #
    def index_to_item(self, index=0):
        """Renvoi l'élément de la liste se trouvant à la ligne(index)"""
        try: return self.items[index]
        except: pass

    #
    def insert_(self, index = END, string = ''):
        """Ajout d'un élément dans la liste à la ligne index.
           Les méthodes de suppression de double et de tri sont
           aussi appelé.
           Vérifier les options nodouble et sort."""
        if index == END: index = len(self.items)
        self.items.insert(index, string)
        self.__nodouble_in_list__
        self.__sort_list__

    #
    def item_to_index(self, string=''):
        """Renvoi la ligne (index) dans la liste du premier élément
           correspondant trouvé"""
        try: self.items.index[string]
        except: index = -1
        return index

    #
    def remove_(self, string=''):
        """Supprime un élément de la liste"""
        try: self.items.remove(string)
        except: pass

    #
    def set(self, string = ''):
        """Modifie le champ de saisie avec la valeur renseignée"""
        self.sVar.set(string)
        # <Entry>: Déplace le curseur au début
        self.entry.icursor(0)
        self.entry.selection_range(0, END)

    #
    def size(self):
        """Renvoi le nombre d'élément de la liste"""
        return len(self.items)


mylist=('Pommes', 'Poires', 'Abricot', 'Ananas', 'Raisin','Orange',
        'Clémentine', 'Cerise', 'Mandarine', 'Peche', 'Poires', 'Abricot', )
nlist='autre'
listempty=['saucisse', 'merguez']

def main():
    def label_value():
        label.config(text=combobox.index_to_item(0) )
        combobox.extend_(['rien', 'autre'])


    window=Tk()
    frame=Frame(window)
    frame.grid()
    combobox=Combobox(frame, activestyle='dotbox', borderwidth=2, insertborderwidth=10, troughcolor='#357',
                    items= mylist, relief=GROOVE, font='Arial, 8',height=5,
                     width=25, matchrequired=1, sort='reverse')
    combobox1=Combobox(frame, activestyle='dotbox',  borderwidth=2, items=listempty,
                         matchrequired=1, width=25)
    button=Button(frame, text='test', command=label_value)
    label=Label(frame)
    button.grid(row=0,column=0)
    label.grid(row=0,column=1)
    combobox.grid(row=1,column=0)
    combobox1.grid(row=2,column=0)
    window.mainloop()

if __name__ == '__main__':
    main()