def start_window():
	import import_from_xlsx

	if not hasattr(import_from_xlsx, 'load_state'):
		setattr(import_from_xlsx, 'load_state', True)
	else:
		reload(import_from_xlsx)
	
	''' tag library '''
	'''
	each tag library corresponds to sqlite table name
	each tag corresponds to sqlite database column name
	'''

	''' config file '''
	config = configparser.ConfigParser()
	config.read(controllers + 'config.ini', encoding='utf-8')

	def convert_to_db():
		source = import_from_xlsx.import_xlsx_path.get_()
		destination = import_from_xlsx.destination_path.get_()

		convert_xlsx_to_db.convert_database(source, destination)
		import_from_xlsx.import_from_xlsx.destroy()

	import_from_xlsx.import_browse_button.settings(\
		command=lambda: import_from_xlsx.import_xlsx_path.set(filedialog.askopenfile().name))
	import_from_xlsx.time_browse_button.settings(\
		command=lambda: import_from_xlsx.time_xlsx_path.set(filedialog.askopenfile().name))
	import_from_xlsx.destination_browse_button.settings(\
		command=lambda: import_from_xlsx.destination_path.set(filedialog.asksaveasfilename() + '.db'))
	import_from_xlsx.cancel_button.settings(command=import_from_xlsx.import_from_xlsx.destroy)
	import_from_xlsx.import_button.settings(command=convert_to_db)

 def findEEPath(self):
   if sys.platform[:3] == 'win': #for windows, wince, win32, etc
     file=filedialog.askopenfile(filetypes=[("Programs","*.exe"),("All files","*")],title="Choose External Editor",parent=self)
   else:
     file=filedialog.askopenfile(filetypes=[("All files","*")],title="Choose External Editor",parent=self)
   if file != None:
     name = os.path.abspath(file.name)
     file.close()
     self.ee.delete(0,END)
     self.ee.insert(END,name)
     self.validate()

 def findAsyPath(self):
   if sys.platform[:3] == 'win': #for windows, wince, win32, etc
     file=filedialog.askopenfile(filetypes=[("Programs","*.exe"),("All files","*")],title="Find Asymptote Executable",parent=self)
   else:
     file=filedialog.askopenfile(filetypes=[("All files","*")],title="Find Asymptote Executable",parent=self)
   if file != None:
     name = os.path.abspath(file.name)
     file.close()
     self.ap.delete(0,END)
     self.ap.insert(END,name)
     self.validate()

 def load(self):
     fname = filedialog.askopenfile(parent=self, mode='rb', title='Choose a file', initialdir="./data")
     self.db.load(fname.name)
     for canvas in self.canvasi:
         self.menubar.remove_item(canvas.name)
         canvas.delete("all")
         canvas.destroy()
     self.canvasi = []
     for name in self.db.names:
         num = 0
         canv = Canv(self, name)
         self.canvasi.append(canv)
         self.canvas_switch(name)
         self.menubar.add_button("show", name, self.canvas_switch)
         for node in self.db.nodes[name]:
             cur = int(node[-1])
             if cur > num:
                 num = cur
             n = {}
             n[node] = {}
             n[node]["tags"] = self.db.tags[node].copy()
             n[node]["text"] = self.db.text[node]
             n[node]["coords"] = self.db.coords[node]
             n[node]["links"] = self.db.links[node].copy()
             canv.insert_sticker(node, n)
         for i in range(num):
             noname = numerate("Node")
         for sticky in canv.stickies:
             for other in canv.stickies[sticky].links:
                 canv.stickies[sticky].connect2box(other, True)

def run():
	Tk().withdraw() #dont need a console open
	if sys.version_info[0] < 3:
		zippath = tkFileDialog.askopenfile() #open up the file system and get the name
	else:
		zippath = filedialog.askopenfile()
	clean(zippath.name)

    def handleOpen(self, event = None):
        global width, height

        # Einlesen der Daten
        file = askopenfile(title = "Öffnen...",
            defaultextension = ".cells",
            filetypes = [("Plaintext-Dateien (*.cells)", "*.cells")])
        f = open(file.name, "r")
        content = f.read()
        f.close()
        # Datei in ihre Zeilen zerlegen
        lines = content.strip().split("\n")
        # Whitespace-Zeichen entfernen
        lines = list(map(lambda line: list(line.strip()), lines))
        # Alle Kommentar-Zeilen entfernen, die mit ! beginnen
        data = list(filter(lambda line: line[0] != "!" if len(line) > 0 else True, lines))
        
        # Aktualisieren von Breite und Höhe
        # (Es werden zwei Zellen Rand auf allen Seiten hinzugefügt)
        height = len(data) + 4
        width = max(list(map(lambda line: len(line), data))) + 4
        self.draw_grid()

        # eingelesene Daten übernehmen
        self.grid = [[0 for y in range(height)] for x in range(width)]
        self.init_grid = [[0 for y in range(height)] for x in range(width)]
        for y in range(len(data)):
            for x in range(len(data[y])):
                if data[y][x] != '.':
                    self.init_grid[x+2][y+2] = 1
        self.handleReset()

    def load(self, simFile=None):

        from tkinter import Tk
        from tkinter.filedialog import askopenfile
        Tk().withdraw()

        if simFile is None:
            simFile = askopenfile(mode="rb", filetypes=[("Newton's Laboratory Simulation File", ".sim")])
            if simFile is None:
                return

        data = pickle.load(simFile)

        for group in data:
            for obj in group:
                obj.simulation = self
                if isinstance(obj, Point):
                    print(obj.displacement)

        self.bodies, self.constraints = data
        self.planet = self.bodies[0]

        for d in data:
            for x in d:
                print(x.__dict__)

def getFileInput():
	root = Tk()
	root.withdraw()
	wordFile = filedialog.askopenfile(title="Open Word File", mode="r", parent=root)
	if wordFile is None:
		raise SystemExit
	return wordFile

def open_file():
	textfield.delete("1.0", END)
	file2open = filedialog.askopenfile(mode='r')
	if file2open is None:
		return
	text2open = file2open.read()
	textfield.insert("1.0", text2open)

def load():
	global loadfile
	global countload
	loadfile[countload] = filedialog.askopenfile()
	loadfile[countload] = str(loadfile[countload]).rsplit("/", 1)[1]
	loadfile[countload] = str(loadfile[countload]).rsplit("'", 5)[0]
	countload += 1

 def ChargerJeu(self):
     self.partie.historique = ""
     self.historique.delete(1.0,END)
     fileName = filedialog.askopenfile(filetypes=[("Save Games", "*.sav")])
     self.partie.charger(fileName.name)
     self.interface_damier.ActualiserPieces(True,False)
     self.CalculPointage()

def load(num):
	global loadfile
	loadfile[num] = filedialog.askopenfile()
	if loadfile[num] != None:
		if num == 1:
			loadbutton1.config(bg = "#33FFFF")
		if num == 2:
			loadbutton2.config(bg = "#33FFFF")
		if num == 3:
			loadbutton3.config(bg = "#33FFFF")
		if num == 4:
			loadbutton4.config(bg = "#33FFFF")
		if num == 5:
			loadbutton5.config(bg = "#33FFFF")
		if num == 6:
			loadbutton6.config(bg = "#33FFFF")
		if num == 7:
			loadbutton7.config(bg = "#33FFFF")
		if num == 8:
			loadbutton8.config(bg = "#33FFFF")
		if num == 9:
			loadbutton9.config(bg = "#33FFFF")
		if num == 10:
			loadbutton10.config(bg = "#33FFFF")
		loadfile[num] = str(loadfile[num]).rsplit("/", 1)[1]
		loadfile[num] = str(loadfile[num]).rsplit("'", 5)[0]

def main():
	root = Tk()
	root.withdraw()
	with filedialog.askopenfile(mode = "r", parent = root) as inputData:
		students = []
		for line in inputData:
			firstName, lastName = line.split(',')
			lastName = lastName.strip()
			scores = []
			scores = lastName.split('  ')	
			lastName = scores.pop(0)
			while '' in scores:
				scores.remove('')
			for item in scores:
				if ' ' in item:
					if ' ' in item[:1]:
						newItem = item[1:]
						scores.insert(scores.index(item), newItem)
						scores.remove(item)
						item = newItem
					if "100" in item:
						first, second = item.split(' ')
						first = first.strip()
						second = second.strip()
						scores.insert(scores.index(item), first)
						scores.insert(scores.index(item) + 1, second)
						scores.remove(item)
					else:
						scores[scores.index(item)] = item.replace(' ', '')
			students.append(Student(firstName, lastName, scores))
		students = sortList(students)	
		longestNameLen = findLongestName(students)
		output(students, longestNameLen, os.path.basename(inputData.name))

 def show_test_vad_open(self, path=path_to_test):
     askopenfile = filedialog.askopenfile(filetypes=[("Wave audio files", "*.wav *.wave")], defaultextension=".wav",
                                          initialdir=path)
     if not askopenfile is None:
         test(WavFile(askopenfile.name), self.nbc)
     else:
         messagebox.showwarning("Warning", "You should select one file. Please, try again")

    def EXP_play_recreates(self, event):
        try:
            f = filedialog.askopenfile(mode='r', defaultextension=".csv")
            if f is None: # askopenfile return `None` if dialog closed with "cancel".
                return
            path_filenames = list()
            for line in f:
                fname = line.rstrip()
                print("fname is: " + str(fname))
                path_filenames.append(line.rstrip())
        finally:
            f.close()

        print("after finally block")
        # colors = ["red", "blue", "green"]
        colors = ["red", "red", "red"]
        c = 0
        for path_file in path_filenames:
            print("before EXP_open_path_from_file")
            self.EXP_open_path_from_file(path_file)
            print("after EXP_open_path_from_file")

            print("before EXP_replay_path_from_file")
            self.EXP_replay_path_from_file(colors[c%3])
            print("after EXP_replay_path_from_file")
            input("press to play next")
            # time.sleep(2)
            c += 1
            if c%1 == 0:
                self.do_clear_canvas()

 def getBOMList(self):
     bFileTxt = filedialog.askopenfile(mode='r', **self.file_opt)
     if bFileTxt != None:
         self.parseFileName(str(bFileTxt))
         bFileCsv = filedialog.asksaveasfile(mode='w', **self.wfile_opt)
         if bFileCsv != None:
             self.parseFileName(str(bFileCsv), fType='csv', mode=1)
             self.toCSV(bFileTxt, bFileCsv, mode=1)

def open_file():
    global filename
    file = askopenfile(parent=root, title='Open File')
    filename = file.name
    data = file.read()
    text_area.delete(0.0, END)
    text_area.insert(0.0, data)
    file.close()

 def restaureDico(self):
     """Restauration du dictionnaire pour pourvoir lire et écrire dedans"""
     fiSource = askopenfile(filetypes=[("Texte", ".txt"), ("Tous", "*")])
     ligneListe = fiSource.readlines()
     for ligne in ligneListe:
         champsValeur = ligne.split()
         self.dico[champsValeur[0]] = champsValeur[1]
     fiSource.close()

 def getNetList(self):
     nFileTxt = filedialog.askopenfile(mode='r', **self.file_opt)
     if nFileTxt != None:
         self.parseFileName(str(nFileTxt))
         nFileCsv = filedialog.asksaveasfile(mode='w', **self.wfile_opt)
         if nFileCsv != None:
             self.parseFileName(str(nFileCsv), fType='csv', mode=1)
             self.toCSV(nFileTxt, nFileCsv)

 def handleNotification( self, notification ) :
     if notification.getName( ) == Messages.FIND_FILES :
         vo = notification.getBody()
         dfile = filedialog.askopenfile( mode='r', title=vo.msg )
         if dfile != None :
             vo.path = dfile.name
             vo.entry.delete( 0, END )
             vo.entry.insert( 0, vo.path )