AAC

#!usr/bin/python

"""HOPE

Developed on the Kavi kit.

STATUS  : Working

FEATURES: Font and background with all the widgets included

COMMENTS: Frame has appeared with bgcolor and font settings

          * Level1 - Alphabet triple buttons Added

          * Level2 - Alapabet buttons and Back button are Added

            Level3 - Text boxes  are added

                   - MORE and BACK buttons Added

                   - DONE and ERASE buttons are Added

            LevelF - Addition of the text Box used to read out the sentence

          * Timer is intiated

          * Methods included : 1] on_timer() # defines the focus action

                               2] on_close () # defines exit action

          * Scaning of the alphabet Triples is done

          * When a button in level one is clicked the values in the aplhabet

            buttons in level 2 change

          * Scanings of LEVEL2 buttons[Alphabet,back,done and erase] is done.

          * Actions performed when level2 buttons are clicked is defined

          * Erase - erases the text in the read out textbox and returns to level three

          * Undo - Clears the text in spell mode and word mode textboxes

                   and returns to level one

          * Back - Returns focus to level one

          * #    - Copies the spell mode text to the readout box and goes to

                   levelone after focussing done and erase buttons

            Spell mode function

            Spellmode andWord mode logic Added

            Templete mode is added

          * Done action is added

          * Automatic Button Resize

          * Skips scanning blank textboxes

          * Text to Speech

                -espeak is used[Note:Windows users need to install espeak and copy the espeak

                 exe to system32 folder

                -Male and Female Voices are available and are set in the launch_box

"""

##Import Necessary Modules

try:

    import wx

    import time

    import subprocess

    import pickle

    import sched

    import os

    import platform

    from operator import itemgetter

except ImportError:

    raise ImportError,"Please check whether all necessary modules are installed"

#*******************************************************************************#

## Main class Definition

class Class_Frame(wx.Frame):

    global SPEED,BG_COLOR,path,GENDER,wav_path

    path = "../Hope/"

    wav_path = "../Voices/"

    scan_L1 = -1

    scan_L2 = -1

    scan_L3 = -1

    Level = 1

    clr = ""

    label_prt = ''

    BG_COLOR = '#C0C0C0'

    btn_color = '#f0f8ff'#wx.WHITE

    focus_color = '#fffacd'#(255,192,203)

    sm_color = (173,234,234)#blue

    sm1_color = (250,128,114)#salmon

    sm_word = ''#spell mode

    sm_prev = ''

    word_prev = ''

    word = ''

    refresh_word = ''

    temp =0

    n = 1 #word mode

    wm_flag = 0

    done = 1

    erase = 0

    loop = 0

    no_of_wm_txtbx = 4

    Lvl = {"Level_1":1,"Level_2":2,"Level_3":3}

    temp_button = ["TEMP","UNDO","EXIT"]

    Alp_tri_dict =  {0:"ABC",1:"DEF",2:"GHI",3:"JKL",4:"MNO",5:"PQR",6:"STU",7:"VWX",8:"YZ#",9:"123"}

    speed_dict = {1:1000,2:1500,3:2000}

    gender_dict = {1:'Female',2:'Male'}

    config_file = open("../launch/configuration.pkl", 'rb')

    config_settin = pickle.load(config_file)

    config_file.close()

    SPEED = speed_dict[config_settin['SPEED']]

    GENDER = gender_dict[config_settin['GENDER']]

    def __init__(self, parent, id, title): #initalisation method

        #frame method with frame parameters passed

        wx.Frame.__init__(self, parent, id, title, size=(1024, 600))

        self.panel = wx.Panel(self, -1) # creates frame panel

        self.panel.SetBackgroundColour(BG_COLOR)   #Panel Backgnd color

        #font = wx.SystemSettings_GetFont(wx.SYS_SYSTEM_FONT)

        font = wx.Font(16, wx.ROMAN, wx.NORMAL, wx.BOLD)

        font.SetPointSize(18)   # font size settings

        if platform.machine()=='armv7l':

          #  subprocess.call(['./gpio.sh','133','low'])

                os.system("sudo i2cset -y 2 0x4d 0x45 >/dev/null")

                os.system("sudo i2cset -y 2 0x4d 0x65 >/dev/null")

                os.system("sudo i2cset -y 2 0x4d 0x89 >/dev/null")

################################################################################

                #"""     WIDGETS INCLUSION       """#

################################################################################

###   Main BOX - Vbox     ###

        vbox = wx.BoxSizer(wx.VERTICAL)#boxsizer for placement of widgets

        vbox.Add((-1, 10))#spacing

############################    LEVEL ONE    ##################################

        Level1 = wx.BoxSizer(wx.HORIZONTAL)#panel for buttons of alphabet triples

        gs1 = wx.GridSizer(1, len(self.Alp_tri_dict), 1, 1)  #gridsizer for the alphabet triple buttons

        self.b = []

        for j in xrange(len(self.Alp_tri_dict)): #loop to add the buttons to the grid and to set the font

            self.b.append(wx.Button(self.panel,-1, self.Alp_tri_dict[j],size=(15,75)))#button creation

            gs1.Add(self.b[j], 0, wx.EXPAND)

            self.b[j].SetFont(font)

            self.b[j].SetBackgroundColour(self.btn_color)

            self.b[j].Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)

        Level1.Add(gs1, 1,wx.EXPAND ) # Add the grid to level one

        vbox.Add(Level1, 0,wx.TOP|wx.ALIGN_CENTER|wx.EXPAND , 10) # Add level one to the panel

########################        LEVEL TWO       ###############################

        vbox.Add((-1, 20))

        Level2 = wx.BoxSizer(wx.HORIZONTAL)#Boxsizer for buttons of alphabets , text boxes ,More,back,DONE,Erase

###  Alphabet buttons and Back Button inclusion

        Alpt = wx.BoxSizer(wx.VERTICAL) #Vertical sizer for the alphabet buttons

        self.b11 = wx.Button(self.panel, -1,'Back',size=(100,50))#BUTTON CREATION

        self.b12 = wx.Button(self.panel, -1, 'A')

        self.b13 = wx.Button(self.panel, -1, 'B')

        self.b14 = wx.Button(self.panel, -1, 'C')

        self.alp = [self.b11,self.b12,self.b13,self.b14]    #button list

        Alpt_gs = wx.GridSizer(4, 1, 3, 3)  #Alphabet button grid

        #Alpt_gs.AddSpacer(2)

        for j in xrange(4): #loop to add the buttons to the grid and to set the font

            Alpt_gs.Add(self.alp[j], 0, wx.EXPAND)

            self.alp[j].SetFont(font)

            self.alp[j].SetBackgroundColour(self.btn_color) # colour settings

            self.alp[j].Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)

        Alpt.Add(Alpt_gs, 1, wx.LEFT)   #Add alphabet grid to box

        Level2.Add(Alpt, 1, wx.EXPAND)  #Add alphabet box to the Level2 boxsizer

###  Text Boxes buttons inclusion

        text_col = wx.BoxSizer(wx.VERTICAL) # Vertical sizer for text boxes

        self.txt_bx1 = wx.TextCtrl(self.panel, -1,size=(600,15),style = wx.TE_LEFT) #text box for spell mode

        self.txt_bx1.SetBackgroundColour(self.sm_color)#SET colour of the spell mode text box

        text_col.Add(self.txt_bx1, 1,wx.ALIGN_CENTER|wx.LEFT|wx.RIGHT) #Add spell text box to textbox sizer

        #self.txt_bx2.SetSize((200,200))

        text_col.AddSpacer(5)#for spacing between text boxes

        self.txt_bx2 = wx.TextCtrl(self.panel, -1,size=(600,15),style=wx.TE_LEFT) #text box for word mode

        text_col.Add(self.txt_bx2, 1,wx.ALIGN_CENTER|wx.LEFT|wx.RIGHT ) #Add word text box to textbox sizer

        text_col.AddSpacer(5)#for spacing between text boxes

        self.txt_bx3 = wx.TextCtrl(self.panel, -1,size=(600,15),style = wx.TE_LEFT)

        text_col.Add(self.txt_bx3, 1,wx.ALIGN_CENTER|wx.LEFT|wx.RIGHT )

        text_col.AddSpacer(5)#for spacing between text boxes

        self.txt_bx4 = wx.TextCtrl(self.panel, -1,size=(600,15),style = wx.TE_LEFT)

        text_col.Add(self.txt_bx4, 1,wx.ALIGN_CENTER|wx.LEFT|wx.RIGHT)

        text_col.AddSpacer(5)#for spacing between text boxes

        self.txt_bx5 = wx.TextCtrl(self.panel, -1,size=(600,15))

        text_col.Add(self.txt_bx5, 1,wx.ALIGN_CENTER|wx.LEFT|wx.RIGHT)

       #text_col.AddSpacer(5)#for spacing between text boxes

        self.txt_bx1.SetFont(font)

        self.txt_bx2.SetFont(font)

        self.txt_bx3.SetFont(font)

        self.txt_bx4.SetFont(font)

        self.txt_bx5.SetFont(font)

### INCLUSION of MORE and ERASE buttons

        More_bck= wx.BoxSizer(wx.HORIZONTAL) #sizer to add more and back buttons

        More_bck_gs = wx.GridSizer(1, 2, 1, 1)  #grid to add the buttons

        #MORE and BACK button Creation

        self.b15 = wx.Button(self.panel, -1, 'MORE',size=(120,40))

        self.b16 = wx.Button(self.panel, -1, 'BACK',size=(120,40))

        More_bck_gs.AddMany( [(self.b15, 0, wx.EXPAND),

            (self.b16, 0,wx.EXPAND )])  #Addition of button to the grid

        #Font and color settings of the buttons

        self.b15.SetFont(font)

        self.b16.SetFont(font)

        self.b15.SetBackgroundColour(self.btn_color)

        self.b16.SetBackgroundColour(self.btn_color)

        self.b15.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)

        self.b16.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)

        More_bck.Add(More_bck_gs, 1,wx.CENTER| wx.TOP) # Add the grid to the sizerwx.LEFT | wx.RIGHT|

        text_col.AddSpacer(5)

        text_col.Add(More_bck, 1,wx.EXPAND |wx.ALIGN_CENTER)    #Add the more_bck sizer to the text_col sizer

        Level2.Add(text_col, 1, wx.CENTER|wx.EXPAND) #Add text_col sizer to the level2 sizer

### INCLUSION of DONE and ERASE buttons

        Done_Ers = wx.BoxSizer(wx.VERTICAL) #sizer to add DONE and ERASE buttons

        Done_Ers_gs = wx.GridSizer(2, 1, 1, 1)  #Grid to add the buttons

        # Creation of DONE and ERASE buttons

        self.b17 = wx.Button(self.panel, -1, 'DONE',size=(100,40)) #

        self.b18 = wx.Button(self.panel, -1, 'ERASE',size=(100,40))

        Done_Ers_gs.AddSpacer(10)

        # Addition of DONE and ERASE buttons to Done_Ers Grid

        Done_Ers_gs.AddMany( [(self.b17, 0,wx.EXPAND),#wx.ALIGN_CENTER_VERTICAL

            (self.b18, 0, wx.EXPAND)])#, wx.EXPAND

        Done_Ers_gs.AddSpacer(20)

        #Font settings of DONE and ERASE buttons

        self.b17.SetFont(font)

        self.b18.SetFont(font)

        self.b17.SetBackgroundColour(self.btn_color)

        self.b18.SetBackgroundColour(self.btn_color)

        self.b17.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)

        self.b18.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)

        #Addition of Done_Ers Grid to Done_Ers Sizer

        Done_Ers.Add(Done_Ers_gs, 1, wx.ALIGN_RIGHT | wx.RIGHT)

        #Addition of Done_Ers Sizer to Level2 sizer

        Level2.Add(Done_Ers, 1,wx.EXPAND)

        vbox.Add(Level2, 1, wx.LEFT | wx.RIGHT | wx.EXPAND, 10) #Add level2 boxsizer to main box

######################   LEVELF READOUT TEXT BOX     ###########################

###INCLUSION of the Readout Textbox

        vbox.Add((-1, 30))#spacing bottom

        LevelF = wx.BoxSizer(wx.HORIZONTAL) # boxer to include the text box

        self.senttxt_bx = wx.TextCtrl(self.panel, -1) #Text Box Creation

        self.senttxt_bx.SetFont(font)

        LevelF.Add(self.senttxt_bx, 1,wx.EXPAND | wx.LEFT | wx.RIGHT  )#Addition of the text box to the sizer

        vbox.Add(LevelF, 0, wx.ALIGN_CENTER | wx.EXPAND | wx.LEFT | wx.RIGHT, 10)#Add the sizer to the Main box

        vbox.Add((-1, 10))  #spacing

#################      FOR PROPER DISPLAY OF WIDGETS       #############

        self.panel.SetSizer(vbox)   # to display the elements in the frame

        # Bind the button click to the action that is to happenwx.EVT_LEFT_DOWN|

        self.panel.Bind(wx.EVT_LEFT_DOWN, self.action)

        self.Bind(wx.EVT_BUTTON, self.action)

        self.alp = [self.b11,self.b12,self.b13,self.b14,self.b17,self.b18]

        self.txt = [self.txt_bx1,self.txt_bx2,self.txt_bx3,self.txt_bx4,self.txt_bx5,self.b15,self.b16]

        for loop in range(0,self.no_of_wm_txtbx+1):

            self.txt[loop].Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)

                #"""     TIMER INCLUSION        """#

        TIMER_ID = 100  # pick a number to set timer id

        wx.EVT_TIMER(self.panel, TIMER_ID, self.on_timer)  # call the on_timer function

        self.timer = wx.Timer(self.panel, TIMER_ID)  # message will be sent to the panel

        self.timer.Start(SPEED)  # x100 milliseconds

                #"""     DISPLAY THE FRAME       """#

        self.Centre()   ##frame opened at the center of the screen

        self.Show(True) ##Displays the screen

#******************************************************************************#

###Method to stop the timer and exit HOPE###

    def on_close(self,event):

        self.timer.Stop()

        frame.Destroy()

    def OnKeyDown(self, event):

        keycode = event.GetKeyCode()

        #print keycode

        #if keycode == wx.WXK_SPACE or keycode == 65 or keycode == 66:

        self.action(event)

    def exit_hope(self):

        self.timer.Stop()

        self.Destroy()

#******************************************************************************#

### Method to set the focus automatically using timer

    def on_timer(self,event):

        if self.Level == self.Lvl["Level_1"]:

            # Reset the erase button colour special case!!After a word is selected.

            self.alp[self.scan_L2].SetBackgroundColour(self.btn_color)

            self.b[self.scan_L1].SetBackgroundColour(self.btn_color) # Reset the button colour

            self.scan_L1 = (self.scan_L1 + 1) % len(self.Alp_tri_dict)

            self.b[self.scan_L1].SetBackgroundColour(self.focus_color)# Coloured Highlight of the focused button

            self.b[self.scan_L1].SetFocus() # to set focus on the alphabet triples

            sound = self.b[self.scan_L1].GetLabel()

            if sound == 'YZ#':

                self.read_aloud("Y Z space")

            elif sound == '123':

                self.read_aloud("Template")

            elif sound == 'DEF':

                self.read_aloud("D E F")

            elif sound == 'GHI':

                self.read_aloud("G H I")

            elif sound == 'MNO':

                self.read_aloud("M N O")

            elif sound == 'STU':

                self.read_aloud("S T U")

            else :

                self.read_aloud(sound)

        elif self.Level == self.Lvl["Level_2"]:#focus the individual alphabets

            self.alp[self.scan_L2].SetBackgroundColour(self.btn_color)# Reset the button colour

            self.scan_L2 = (self.scan_L2 + 1) % 6

            self.alp[self.scan_L2].SetBackgroundColour(self.focus_color)# Coloured Highlight of the focused button

            self.alp[self.scan_L2].SetFocus()# to set focus on the alphabet

            if  (self.scan_L2 ==5)&(self.label_prt == '#'):

                    self.label_prt = ''

                    #Goback to level one

                    self.Level = self.Lvl["Level_1"]

                    #Start scaning the button one of level one

                    self.scan_L1 = -1

            if  (self.scan_L2 ==5)&(self.label_prt != '#'):

                    self.Level = self.Lvl["Level_2"]

                    self.scan_L2 = -1

            if  (self.scan_L2 ==0)&(self.wm_flag == 1):

                    self.wm_flag = 0 #reset Flag

                    self.Clr_txt_bx()

            sound = self.alp[self.scan_L2].GetLabel()

            if sound == 'TEMP':

                self.read_aloud("Template")

            elif sound == '#':

                self.read_aloud("Space")

            else :

                 self.read_aloud(sound)

        elif self.Level == self.Lvl["Level_3"]:#focus on the textboxes ,more and back buttons

            self.erase = 0

            #reset Erase button color

            self.alp[self.scan_L2].SetBackgroundColour(self.btn_color)

            if self.scan_L3 == 0:  # Spell mode text box default color is set to blue

                 color = self.sm_color

            else :

                 color = self.btn_color

            self.txt[self.scan_L3].SetBackgroundColour(color)# Reset the button colour

            if self.scan_L3 ==4:

                self.txt[self.scan_L3].SetValue(self.refresh_word)

            self.scan_L3 = (self.scan_L3 + 1)%len(self.txt)

            if (self.temp==1)&(self.scan_L3==0):

                self.txt[self.scan_L3].SetBackgroundColour(self.sm_color)# Reset the button

                self.scan_L3 = (self.scan_L3 + 1)%len(self.txt)

            if self.scan_L3<=4:

                sound = self.txt[self.scan_L3].GetValue()

                self.refresh_word = sound

            else:

                sound = self.txt[self.scan_L3].GetLabel()

            refresh = 1

            while sound == '': # condition to skip empty text boxes

                self.refresh_word = self.txt[self.scan_L3-1].GetValue()

                if refresh == 1 and self.scan_L3>1:

                        self.txt[self.scan_L3-1].SetValue(self.refresh_word)

                        refresh = 0

                self.scan_L3 = (self.scan_L3 + 1)%len(self.txt)

                if self.scan_L3<=4:

                        sound = self.txt[self.scan_L3].GetValue()

                else:

                        sound = self.txt[self.scan_L3].GetLabel()

            self.txt[self.scan_L3].SetBackgroundColour(self.focus_color)# Coloured Highlight of the focused button

            self.txt[self.scan_L3].SetFocus()# to set focus on the alphabet

            self.read_aloud(sound)

    def read_aloud(self,sound):

        resume_time = self.timer.GetInterval()

        self.timer.Stop()

        #subprocess.call(['./playit.sh',GENDER,sound ])

        if os.path.isfile(wav_path+GENDER+'/'+sound+'.wav'):

            if platform.machine()=='armv7l':

                play_temp = wav_path+GENDER+'/'+sound+'.wav'

                subprocess.call(['aplay',play_temp])

            else:

                play = wx.Sound(wav_path+GENDER+'/'+sound+'.wav')

                play.Play()

        else :

                fname = wav_path+GENDER+"/input.txt"

                myfile = open(fname, "w")

                myfile.write(sound)

                myfile.close()

                fpath =sound+".wav"

                if GENDER == "Male":

                        os.chdir('../Voices/Male/')

                        subprocess.call(['espeak','-f','input.txt', '-ven+m3','-w',fpath ])

                else:

                        os.chdir('../Voices/Female/')

                        subprocess.call(['espeak','-f','input.txt', '-ven+f3','-w',fpath ])

                if platform.machine()=='armv7l':

                     subprocess.call(['aplay',fpath])

                else:

                     play = wx.Sound(fpath)

                     play.Play()

                os.chdir('../')

                os.chdir('../launch')

        self.timer.Start(resume_time)

    def Clr_txt_bx(self):

        self.sm_word = self.clr

        self.refresh_word=self.clr

        # Clear the Spell mode & Word mode text box

        for j in xrange(self.no_of_wm_txtbx+1):

            self.txt[j].SetValue(self.clr)

#******************************************************************************#

    def action(self,event):

##        print "Action Level:",self.Level

        if self.Level == self.Lvl["Level_1"]: # IF level one assign alphabet values to buttons in level two

            self.Level = self.Lvl["Level_2"] # A click will take the focus to level two

            self.temp = 0

            if (self.b[self.scan_L1] == self.b[-1]): # Check for last button to set as Templete/Undo button

                self.label1 = self.temp_button

            else:

                # Get The ALPLABET TRIPLES and split them to individual alphabets

                self.label1 = self.b[self.scan_L1].GetLabel()

            # Set the individual alphabets to the buttons in level2

            self.b12.SetLabel(self.label1[0])

            self.b13.SetLabel(self.label1[1])

            self.b14.SetLabel(self.label1[2])

            #Reset the clicked button Colour

            self.b[self.scan_L1].SetBackgroundColour(self.btn_color)

            self.scan_L2 = -1

        elif self.Level == self.Lvl["Level_2"]: # IF level Two

            #self.erase =1

            # Get the label value of the selected button

            self.label = self.alp[self.scan_L2].GetLabel()

            if (self.label1!= self.temp_button)&(len(self.sm_word)==0):

                File = path+self.label1 + ".txt"

                self.Fname = open(File,'r')

                self.file_list = self.Fname.readlines()

                self.Fname.close()

            if (self.label1 == self.temp_button):

                self.Fname = open(path+'temp.txt','r')

                self.file_list = self.Fname.readlines()

                self.Fname.close()

            if (self.label == 'Back'):

                self.temp = 0

                self.Level = self.Lvl["Level_1"] #Goback to level one

                #Start scaning the button one of level one

                self.scan_L1=self.scan_L1 -3

            elif (self.label == '#'): # copy the spell mode text to the readout text box

                self.spell = self.txt_bx1.GetValue()

                self.word_prev = self.word # used to erase the last added word

                self.word +=self.spell #append the new word to the sentence

                self.word += ' '# add space

                self.senttxt_bx.SetValue(self.word)

                self.Clr_txt_bx()

                self.label_prt = '#'

                self.temp = 0

                # Reset color highlight of the # button

                self.alp[self.scan_L2].SetBackgroundColour(self.btn_color)

            elif (self.label == 'UNDO'):

                self.Clr_txt_bx()

                # Reset color highlight of the undo button

                self.alp[self.scan_L2].SetBackgroundColour(self.btn_color)

                # Goback to level one

                self.Level = self.Lvl["Level_1"]

                # Start scaning the button one of level one

                self.scan_L1 = -1

            elif (self.label == 'TEMP'):

                self.word_list = self.file_list

                self.wlist=[]

                self.word_list = []

                for i in range(0,len(self.file_list)):

                        self.wlist.append(str(self.file_list[i][:-1]).split(','))

                        self.wlist[i][1] = int(self.wlist[i][1])

                self.wlist.sort(key=itemgetter(1),reverse=True)

                for i in range(0,len(self.file_list)):

                    self.word_list.append(self.wlist[i][0])

                for i in range(1,self.no_of_wm_txtbx+1):

                    self.txt[i].SetValue(self.word_list[i][:])#

                # Reset color highlight of the TEMP button

                self.alp[self.scan_L2].SetBackgroundColour(self.btn_color)

                self.temp = 1 #template mode

                self.scan_L3 = 0

                self.txt[self.scan_L3].SetBackgroundColour(self.sm_color)

                self.Level = self.Lvl["Level_3"] #goto level 3

            elif self.label == 'ERASE':

                self.senttxt_bx.SetValue(self.word_prev)

                self.word = self.word_prev

                self.sm_word = self.clr

                self.temp = 0

                self.wm_flag = 0 #reset Flag

                #Start scaning the button one of level one

                self.scan_L1 = -1  #changed from -1 to 0[starts from wm txt box] so no use

                self.Level = self.Lvl["Level_3"]

            elif self.label == 'EXIT':

                #self.timer.Stop()

                #self.Destroy()

                self.exit_hope()

            elif self.label == 'DONE':# done button clicked

                if self.done ==1: # for first click to stop the scanning

                    self.scan_L2 = 4 # Retain the highlight at Done button

                    # Highlight the DONE button colour to different color than usual

                    self.alp[self.scan_L2].SetBackgroundColour(self.sm_color)

                    self.txt[0].SetBackgroundColour(self.sm_color)

                    if platform.machine()=='armv7l':

                        #subprocess.call(['./gpio.sh','133','high' ])

                        os.system("sudo i2cset -y 2 0x4d 0x4d >/dev/null")

                        os.system("sudo i2cset -y 2 0x4d 0x6d >/dev/null")

                        os.system("sudo i2cset -y 2 0x4d 0x87 >/dev/null")

                    self.read_aloud(self.word[:-1])

                    if platform.machine()=='armv7l':

                        #subprocess.call(['./gpio.sh','133','low' ])

                        os.system("sudo i2cset -y 2 0x4d 0x45 >/dev/null")

                        os.system("sudo i2cset -y 2 0x4d 0x65 >/dev/null")

                        os.system("sudo i2cset -y 2 0x4d 0x89 >/dev/null")

                    self.timer.Stop()# stopping the timer stops the scanning

                    self.wm_flag = 0 #reset Flag

                    self.word = self.word[:-1]+'\n'

                    str_word = str(self.word)

                    if self.word != '\n':

                        if len(str_word.rsplit())>1:

                                self.read_sent = open(path+'temp.txt','a+')

                        else:

                                i = 0

                                while(self.Alp_tri_dict[i].find(self.word[0])==-1):

                                        i = i+1

                                self.read_sent = open(path+self.Alp_tri_dict[i]+'.txt','a+')

                        guess =[]

                        guess_list= self.read_sent.readlines()

                        for i in range(0,len(guess_list)):

                                guess.append(str(guess_list[i][:-1]).split(','))

                                #self.wlist[i][0] = (self.wlist[i][1])

                        match = 0

                        for i in range(0,len(guess)):

                            if guess[i][0] == self.word[:-1]:

                                match =1

                                #print "match", self.word[:-1],guess[i][0]

                                break

                            else:

                                match = 0

                        if match == 0:

                                self.read_sent.writelines(self.word[:-1]+','+'1'+'\n')

                        self.read_sent.close()

                    self.Clr_txt_bx()

                    self.done *= -1 # invert the logic for second click

                else :

                    if platform.machine()=='armV7l':

                        #subprocess.call(['./gpio.sh','133','low'])

                        os.system("sudo i2cset -y 2 0x4d 0x45 >/dev/null")

                        os.system("sudo i2cset -y 2 0x4d 0x65 >/dev/null")

                        os.system("sudo i2cset -y 2 0x4d 0x89 >/dev/null")

                    self.alp[self.scan_L2].SetBackgroundColour(self.btn_color)#Reset the Done button to the normal color

                    self.scan_L1 = -1 # set the scanning button as the first button in the level

                    self.Level = self.Lvl["Level_1"] # Set the active level as one

                    self.senttxt_bx.SetValue(self.clr)

                    self.sm_prev = self.clr

                    self.word = self.clr

                    self.label_prt = self.clr#loop in LEVEL_2

                    self.timer.Start(SPEED) # Resume the Scanning

                    self.done *= -1  # invert the logic for the next click

            else:

                self.temp = 0

                # Reset color highlight of the alphabet button

                self.alp[self.scan_L2].SetBackgroundColour(self.btn_color)

                # Copy the clicked alphabet button label to the spell mode textbox

                self.sm_prev = self.sm_word # copy the text to a variable incase to print previous data if back is pressed

                self.sm_word += self.label

                self.txt_bx1.SetValue(self.sm_word)

                if self.label1!= self.temp_button:

                    self.Update_words()

                #Set LEVEL as three and reset scan to scan the first element

                self.scan_L3 = -1

                self.Level = self.Lvl["Level_3"]

        elif self.Level == self.Lvl["Level_3"]:

            # Get the label value of the selected button

            self.label_3 = self.txt[self.scan_L3].GetLabel()

            if (self.txt[self.scan_L3] == self.txt_bx1):

                #  color highlight of the spell mode button

                self.txt[self.scan_L3].SetBackgroundColour(self.sm1_color)

                #Set LEVEL as one and reset scan to scan the first element

                self.scan_L1 = -1

                self.scan_L2 = -1

                self.Level = self.Lvl["Level_1"]

            elif self.label_3 == 'BACK':

                # Erase the last include alphabet

                self.sm_word = self.sm_prev

                self.txt_bx1.SetValue(self.sm_prev)

                self.Update_words()

                # Reset color highlight of the BACK button

                self.txt[self.scan_L3].SetBackgroundColour(self.btn_color)

                #Set LEVEL as one and reset scan to scan the first element

                self.scan_L2 = -1

                self.Level = self.Lvl["Level_2"]

            elif self.label_3 == 'MORE':

                self.n += 1

                i = 1

                W = len(self.word_list)

                if W>=((self.n-1)*self.no_of_wm_txtbx ):

                    self.display = W-((self.n-1)*self.no_of_wm_txtbx)

                    while ((self.display>0)& (i<=self.no_of_wm_txtbx)):

                        self.txt[i].SetValue(self.word_list[(i+((self.n-1)*(self.no_of_wm_txtbx)))-1][:])#-1

                        i = i+1

                        self.display = self.display-1

                        if i<(self.no_of_wm_txtbx+1):

                            self.loop = 1

                        else: self.loop = 0

                    if ((self.display<self.no_of_wm_txtbx)&(self.display>=0)&(self.loop==1)):

                        for i in range(i,self.no_of_wm_txtbx+1):

                            self.txt[i].SetValue(self.clr)

                            self.loop = 0

                            self.n = 0

                    if (self.display <=0):

                        self.n = 0

                        self.loop = 0

            else :

                self.wm_word = self.txt[self.scan_L3].GetValue()

                str_wm_word = str(self.wm_word)

                if len(str_wm_word.rsplit())>1:

                        Fwrite = open(path+'temp.txt','r')

                else:

                        i = 0

                        while(self.Alp_tri_dict[i].find(self.wm_word[0])==-1):

                                i = i+1

                                #print self.Alp_tri_dict[i]+'.txt'

                        Fwrite = open(path+self.Alp_tri_dict[i]+'.txt','r')

                flist = Fwrite.readlines()

                Fwrite.close()

                if len(str_wm_word.rsplit())>1:

                        Fwrite = open(path+'temp.txt','w')

                else:

                        i = 0

                        while(self.Alp_tri_dict[i].find(self.wm_word[0])==-1):

                                i = i+1

                                #print self.Alp_tri_dict[i]+'.txt'

                        Fwrite = open(path+self.Alp_tri_dict[i]+'.txt','w')

                wordlist=[]

                wlist=[]

                for i in range(0,len(flist)):

                        wlist.append(str(flist[i][:-1]).split(','))

                        wlist[i][1] = int(wlist[i][1])

                wlist.sort(key=itemgetter(1),reverse=True)

                for i in range(0,len(flist)):

                        wordlist.append(wlist[i][0])

                match = 0

                for i in range(0,len(flist)):

                        if wlist[i][0] == self.wm_word:

                                wlist[i][1] = str((wlist[i][1])+1)

                        Fwrite.writelines((wlist[i][0])+','+str(wlist[i][1])+'\n')

                self.word_prev = self.word # used to erase the last added word

                self.word += self.wm_word # append a new word to the sentence

                self.word += ' ' # add space

                self.senttxt_bx.SetValue(self.word)

                # Reset color highlight of the # button

                self.txt[self.scan_L3].SetBackgroundColour(self.btn_color)

                self.txt[self.scan_L3].SetValue(self.refresh_word)#refresh after the word is selected

                self.scan_L2 = 3 #goto done button

                self.Level = self.Lvl["Level_2"] #done is in level 2

                self.wm_flag = 1

    def Update_words(self):

        self.n = 1

        #self.word_list = self.file_list

        search_word = self.sm_word

        #print self.sm_word

        self.wlist=[]

        self.word_list = []

        for i in range(0,len(self.file_list)):

                self.wlist.append(str(self.file_list[i][:-1]).split(','))

                self.wlist[i][1] = int(self.wlist[i][1])

        self.wlist.sort(key=itemgetter(1),reverse=True)

        for i in range(0,len(self.file_list)):

                self.word_list.append(self.wlist[i][0])

        update_list = []

        #print len(self.word_list) , len(search_word)

        for letter in range(0,len(search_word)):

            for word in range(0,len(self.word_list)):

                if len(self.word_list[word])>letter:

                        if search_word[letter] == self.word_list[word][letter]:

                                update_list.append(self.word_list[word])

            self.word_list = update_list

            #print len(update_list)

            update_list = []

        self.k=1

        while ((self.k<=len(self.word_list))& (self.k<=self.no_of_wm_txtbx)&(len(search_word)!=0)):

            self.txt[self.k].SetValue(self.word_list[self.k-1][:])#-1

            self.k = self.k+1

        if self.k<self.no_of_wm_txtbx:

            for i in range(self.k,self.no_of_wm_txtbx+1):

               self.txt[i].SetValue(self.clr)

## Main Loop:

if __name__ == "__main__":

    app = wx.App()

    Class_Frame(None, -1, 'HOPE')   ##main class

    app.MainLoop()