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 goodUser():
    errorMsg = Tk()

    goodCRN = Label(errorMsg, text="Please enter a valid Villanova username")

    goodCRN.pack()
    errorMsg.mainloop()

    def enable(self, app=None):
        """Enable event loop integration with Tk.

        Parameters
        ----------
        app : toplevel :class:`Tkinter.Tk` widget, optional.
            Running toplevel widget to use.  If not given, we probe Tk for an
            existing one, and create a new one if none is found.

        Notes
        -----
        If you have already created a :class:`Tkinter.Tk` object, the only
        thing done by this method is to register with the
        :class:`InputHookManager`, since creating that object automatically
        sets ``PyOS_InputHook``.
        """
        if app is None:
            try:
                from tkinter import Tk  # Py 3
            except ImportError:
                from Tkinter import Tk  # Py 2
            app = Tk()
            app.withdraw()
            self.manager.apps[GUI_TK] = app
            return app

def main():

    root = Tk()
    ex = Janela(root)
    root.geometry("300x250+300+300")
    center(root)
    root.mainloop()

def main():
    root = Tk()
    f1 = tkinter.Frame(width=200, height=200)
    ex = Example(root)
    f1.pack(fill="both", expand=True, padx=20, pady=20)
    ex.place(in_=f1, anchor="c", relx=.5, rely=.5)
    root.mainloop()

 def __init__(self, app, kind='', icon_file=None, center=True):
     self.findIcon()
     Tk.__init__(self)
     if center:
         pass
     self.__app = app
     self.configBorders(app, kind, icon_file)

    def interactive_ask_ref(self, code, imagefn, testid):
        from os import environ
        if 'UNITTEST_INTERACTIVE' not in environ:
            return True

        from tkinter import Tk, Label, LEFT, RIGHT, BOTTOM, Button
        from PIL import Image, ImageTk

        self.retval = False

        root = Tk()

        def do_close():
            root.destroy()

        def do_yes():
            self.retval = True
            do_close()

        image = Image.open(imagefn)
        photo = ImageTk.PhotoImage(image)
        Label(root, text='The test %s\nhave no reference.' % testid).pack()
        Label(root, text='Use this image as a reference ?').pack()
        Label(root, text=code, justify=LEFT).pack(side=RIGHT)
        Label(root, image=photo).pack(side=LEFT)
        Button(root, text='Use as reference', command=do_yes).pack(side=BOTTOM)
        Button(root, text='Discard', command=do_close).pack(side=BOTTOM)
        root.mainloop()

        return self.retval

class TkWindowMainLoop(Thread):
    '''class for thread that handles Tk window creation and main loop''' 
    
    def __init__(self, client):
        Thread.__init__(self)
        
        self.window = None
        self.canvas = None
        self.client = client
        
        self.start()

    
    def callbackDeleteWindow(self):
        self.client.stop()
        
    def stop(self):
        self.window.quit()
        
    
    def run(self):
        self.window = Tk()
        self.canvas = Canvas(self.window, width=1024, height=768)
        self.canvas.pack()
        
        self.window.protocol("WM_DELETE_WINDOW", self.callbackDeleteWindow)
        
        self.window.mainloop()

    def getWindow(self):
        return self.window
    
    def getCanvas(self):
        return self.canvas

    def save():
        """This function will save the file.
        It will also save the day, too!

        You just might be safe with this one!"""
        from tkinter import Tk
        import tkinter.filedialog
        root = Tk()
        root.withdraw()
        fd = tkinter.filedialog.FileDialog(master=root,title='Project Celestia')
        savefile = fd.go()
        if savefile != None:
            import os.path, tkinter.dialog
            if os.path.exists(savefile):
                if os.path.isdir(savefile):
                    tkinter.filedialog.FileDialog.master.bell()
                    return savefile
                d = tkinter.dialog.Dialog(master=None,title='Hold your horses!',
                                          text='Are you sure you want to rewrite this file?'
                                          '\nI mean, I have already seen the file before...\n'
                                          '\n-Twilight Sparkle',
                                          bitmap='questhead',default=0,strings=('Eeyup','Nah'))
                if d.num != 1:
                    return savefile
        else:
            FlashSentry.save_error()
        root.destroy()

    def __init__(self,root):
        Tk.__init__(self,root)
        self.root = root

        self.MAX_F = 12

        self.info = StringVar()
        self.sliders = []
        self.parameters = []
        self.filters = []
        self.isAdvancedMode = False

        self.isWritting = False

        self.configFile = "config.xml"

        self.cw = ConfigWritter(self.configFile)
        if not isfile(self.configFile): self._createConfigFile()
        self.cp = ConfigParser(self.configFile)
        self._parseConfigFile()


        self.canvas = Canvas()
        self.canvas.pack(expand=YES,fill=BOTH)

        self.initialize()

def _calltip_window(parent):  # htest #
    import re
    from tkinter import Tk, Text, LEFT, BOTH

    root = Tk()
    root.title("Test calltips")
    width, height, x, y = list(map(int, re.split('[x+]', parent.geometry())))
    root.geometry("+%d+%d"%(x, y + 150))

    class MyEditWin: # conceptually an editor_window
        def __init__(self):
            text = self.text = Text(root)
            text.pack(side=LEFT, fill=BOTH, expand=1)
            text.insert("insert", "string.split")
            root.update()
            self.calltip = CallTip(text)

            text.event_add("<<calltip-show>>", "(")
            text.event_add("<<calltip-hide>>", ")")
            text.bind("<<calltip-show>>", self.calltip_show)
            text.bind("<<calltip-hide>>", self.calltip_hide)

            text.focus_set()
            root.mainloop()

        def calltip_show(self, event):
            self.calltip.showtip("Hello world", "insert", "end")

        def calltip_hide(self, event):
            self.calltip.hidetip()

    MyEditWin()

 def __init__(self, title="", message="", button="Ok", image=None,
              checkmessage="", style="clam", **options):
     """
         Create a messagebox with one button and a checkbox below the button:
             parent: parent of the toplevel window
             title: message box title
             message: message box text
             button: message displayed on the button
             image: image displayed at the left of the message
             checkmessage: message displayed next to the checkbox
             **options: other options to pass to the Toplevel.__init__ method
     """
     Tk.__init__(self, **options)
     self.resizable(False, False)
     self.title(title)
     s = Style(self)
     s.theme_use(style)
     if image:
         Label(self, text=message, wraplength=335,
               font="Sans 11", compound="left",
               image=image).grid(row=0, padx=10, pady=(10, 0))
     else:
         Label(self, text=message, wraplength=335,
               font="Sans 11").grid(row=0, padx=10, pady=(10, 0))
     b = Button(self, text=button, command=self.destroy)
     b.grid(row=2, padx=10, pady=10)
     self.var = BooleanVar(self)
     c = Checkbutton(self, text=checkmessage, variable=self.var)
     c.grid(row=1, padx=10, pady=0, sticky="e")
     self.grab_set()
     b.focus_set()
     self.wait_window(self)

	def ingresarUsuario(cls):
		
		cls.nombre=""
		
		def salir():
			root.quit()
	
		def cargarArchivo():
			cls.nombre=a.get()
			root.destroy()
	
		def obtenerN():
			n=a.get()
			return (n)
		
		root = Tk()
		root.title('CargarDatos')
		a = StringVar()
		atxt = Entry(root, textvariable=a,width=20)
		cargar = Button(root, text="Cargar Archivo", command=cargarArchivo,width=15)
		salirB= Button(root, text ="Salir", command=root.destroy, width=10)
		atxt.grid(row=0, column=0)
		cargar.grid(row=1, column=0)
		salirB.grid(row=1,column=1)
		root.mainloop()
		return (obtenerN())

def main():
    q = Queue()

    root = Tk()
    root.geometry("400x350+300+300")
    Example(root, q)
    root.mainloop()

def main():
    #abort shutdown
    abortShutdown()
    #load the application
    root = Tk()
    app = FullScreenApp(root)
    root.mainloop()

def test():
    """
    Kolorem czarnym są narysowane obiekty utworzone
    za pomocą klas fabrycznych.
    Kolorem czerwonym obiekty utworzone przy użyciu
    funkcji shapeFactory
    """
    creator = RectangleCreator()
    rect = creator.factory("Rectangle",a=40,b=60)
    rect2 = shapeFactory("Rectangle",a=40,b=60, outline="#f00")
    creator = TriangleCreator()
    tri = creator.factory("Triangle",a=100,b=100,c=100)
    tri2 = shapeFactory("Triangle",a=100,b=100,c=100,outline="#f00")
    creator = SquareCreator()
    sq = creator.factory("Square",a=60)
    sq2 = shapeFactory("Square",a=60,outline="#f00")
    root = Tk()
    w = Window(root)
    w.drawShape(rect,100,100)
    w.drawShape(rect2,100,200)
    w.drawShape(tri,200,100)
    w.drawShape(tri2,200,200)
    w.drawShape(sq,370,100)
    w.drawShape(sq2,370,200)
    root.geometry("600x400+100+100")
    root.mainloop()

def main():
    logger.level = logs.DEBUG

    usage = 'PRACMLN Query Tool'

    parser = argparse.ArgumentParser(description=usage)
    parser.add_argument("-i", "--mln", dest="mlnarg", help="the MLN model file to use")
    parser.add_argument("-d", "--dir", dest="directory", action='store', help="the directory to start the tool from", metavar="FILE", type=str)
    parser.add_argument("-x", "--emln", dest="emlnarg", help="the MLN model extension file to use")
    parser.add_argument("-q", "--queries", dest="queryarg", help="queries (comma-separated)")
    parser.add_argument("-e", "--evidence", dest="dbarg", help="the evidence database file")
    parser.add_argument("-r", "--results-file", dest="outputfile", help="the results file to save")
    parser.add_argument("--run", action="store_true", dest="run", default=False, help="run with last settings (without showing GUI)")

    args = parser.parse_args()
    opts_ = vars(args)

    root = Tk()
    conf = PRACMLNConfig(DEFAULT_CONFIG)
    app = MLNQueryGUI(root, conf, directory=os.path.abspath(args.directory) if args.directory else None)

    if args.run:
        logger.debug('running mlnlearn without gui')
        app.infer(savegeometry=False, options=opts_)
    else:
        root.mainloop()

def main(options):
    """Create GUI and perform interactions."""
    root = Tk()
    root.title('Oscilloscope GUI')
    gui = Tdsgui(root, options)
    print(type(gui))
    root.mainloop()

    def __init__(self, drs, size_canvas=True, canvas=None):
        """
        :param drs: ``AbstractDrs``, The DRS to be drawn
        :param size_canvas: bool, True if the canvas size should be the exact size of the DRS
        :param canvas: ``Canvas`` The canvas on which to draw the DRS.  If none is given, create a new canvas.
        """
        master = None
        if not canvas:
            master = Tk()
            master.title("DRT")

            font = Font(family='helvetica', size=12)

            if size_canvas:
                canvas = Canvas(master, width=0, height=0)
                canvas.font = font
                self.canvas = canvas
                (right, bottom) = self._visit(drs, self.OUTERSPACE, self.TOPSPACE)

                width = max(right+self.OUTERSPACE, 100)
                height = bottom+self.OUTERSPACE
                canvas = Canvas(master, width=width, height=height)#, bg='white')
            else:
                canvas = Canvas(master, width=300, height=300)

            canvas.pack()
            canvas.font = font

        self.canvas = canvas
        self.drs = drs
        self.master = master

def savePreset(main, filename=None):

    if filename is None:
        root = Tk()
        root.withdraw()
        filename = simpledialog.askstring(title='Save preset',
                                          prompt='Save config file as...')
        root.destroy()

    if filename is None:
        return

    config = configparser.ConfigParser()
    fov = 'Field of view'
    config['Camera'] = {
        'Frame Start': main.frameStart,
        'Shape': main.shape,
        'Shape name': main.tree.p.param(fov).param('Shape').value(),
        'Horizontal readout rate': str(main.HRRatePar.value()),
        'Vertical shift speed': str(main.vertShiftSpeedPar.value()),
        'Clock voltage amplitude': str(main.vertShiftAmpPar.value()),
        'Frame Transfer Mode': str(main.FTMPar.value()),
        'Cropped sensor mode': str(main.cropParam.value()),
        'Set exposure time': str(main.expPar.value()),
        'Pre-amp gain': str(main.PreGainPar.value()),
        'EM gain': str(main.GainPar.value())}

    with open(os.path.join(main.presetDir, filename), 'w') as configfile:
        config.write(configfile)

    main.presetsMenu.addItem(filename)