def deck_options(self,decknum):
        if not self.deckopt:
            self.deckopt = Toplevel(self)
            self.deckopt.resizable(0,0)
            self.deckopt.protocol('WM_DELETE_WINDOW', self.close_deck_opt)
            self.current_deckopt_num = decknum-1

            custom_title = Label(self.deckopt,text="Deck %i options:"%decknum,font=tkFont.nametofont("TkTextFont"))
            custom_title.grid(row=0,column=0)
            
            self.deckopt_button = Button(self.deckopt, text="Deck %i enabled"%decknum,font=self.mediumfont, command=self.config_deckbutton)
            self.deckopt_button.grid(row=1,column=0)
            if self.current_deckopt_num in defines.DECKS_TO_USE:
                self.deckopt_button.configure(background="#00ff00",text="Deck %i Enabled "%decknum)
            else:
                self.deckopt_button.configure(background="#ff0000",text="Deck %i Disabled"%decknum)

            self.target = IntVar()
            self.target.set(defines.TARGETING[self.current_deckopt_num])
            Label(self.deckopt,text="Targeting preference:",         font=tkFont.nametofont("TkTextFont")).grid(row=2,column=0,sticky=W)
            Radiobutton(self.deckopt, text="No targeting",           font=tkFont.nametofont("TkTextFont"), variable=self.target, value=0, command=self.config_preferences).grid(row=3,column=0,sticky=W)
            Radiobutton(self.deckopt, text="Opponent hero",          font=tkFont.nametofont("TkTextFont"), variable=self.target, value=1, command=self.config_preferences).grid(row=4,column=0,sticky=W)
            #Radiobutton(self.deckopt, text="Enemy taunt minion",     font=tkFont.nametofont("TkTextFont"), variable=self.target, value=2, command=self.config_preferences).grid(row=5,column=0,sticky=W)
            #Radiobutton(self.deckopt, text="Random friendly minion", font=tkFont.nametofont("TkTextFont"), variable=self.target, value=3, command=self.config_preferences).grid(row=6,column=0,sticky=W)

        else:
            self.close_deck_opt()
            self.deck_options(decknum)

    def lables(self):
        ''' displays the labels on the main page'''
        font.nametofont('TkDefaultFont').configure(size=15)
        MyFont = font.Font(size=20)#Changes the font size
        self.labelItems = Label(root,text="Items", font=MyFont)
        self.labelItems.configure(background='white')
        self.labelItems.pack()

        self.labelType = Label(root,text="Type")
        self.labelType.configure(background='white')
        self.labelType.place(x=100,y=80)

        self.labelTime = Label(root,text="Time")
        self.labelTime.configure(background='white')
        self.labelTime.place(x=100,y=160)

        self.labelSearching = Label(root,text="Searching")
        self.labelSearching.configure(background='white')
        self.labelSearching.place(x=60,y=240)

        self.labelSorting = Label(root,text="Sorting")
        self.labelSorting.configure(background='white')
        self.labelSorting.place(x=80,y=320)

        self.lableRobotColour = Label(root,text= "Robots colour")
        self.lableRobotColour.configure(background='white')
        self.lableRobotColour.place(x=185,y=400)

def initialize_font():
    if "Open Sans" in tkFont.families():
        default_font = tkFont.nametofont("TkDefaultFont")
        default_font.configure(family="Open Sans", size=11)
        
        default_font = tkFont.nametofont("TkTextFont")
        default_font.configure(family="Open Sans", size=11)

    def __init__(self, variable_base=None, fixed_base=None):
        if variable_base is None:
            variable_base = tkFont.nametofont("TkDefaultFont")
        if fixed_base is None:
            fixed_base = tkFont.nametofont("TkFixedFont")

        self.default = self.clone_font(variable_base, "default")
        self.fixed = self.clone_font(fixed_base, "fixed")
        self._reset()

    def __init__(self, parent):
        Frame.__init__(self, parent)
        self.parent = parent 
        menubar = Menu(self.parent)
        self.parent.config(menu=menubar)

        self.mediumfont = tkFont.nametofont("TkFixedFont")
        self.mediumfont.configure(size=22)
        self.mediumfont.configure(family="Helvetica")

        optionsmenu = Menu(menubar, tearoff=0)
        optionsmenu.add_command(label="Custom Decks", command=self.select_decks_to_use)
        optionsmenu.add_command(label="Gameplay", command=self.misc)
        optionsmenu.add_command(label="Controls", command=self.controls)
        optionsmenu.add_command(label="Resolution", command=self.resolutions)
        optionsmenu.add_separator()
        optionsmenu.add_command(label="Exit", command=self.quit)
        menubar.add_cascade(label="Options", menu=optionsmenu)

        helpmenu = Menu(menubar, tearoff=0)
        helpmenu.add_command(label="Help", command=self.help_window)
        helpmenu.add_command(label="Donate Bitcoin!", command=self.donate_window)
        menubar.add_cascade(label="Help", menu=helpmenu)

        self._job_id = None
        self._error  = ""
        self.parent.title(defines.titles[randint(0,len(defines.titles)-1)])
        self.parent.resizable(0,0)

        default_font = tkFont.nametofont("TkDefaultFont")
        default_font.configure(size=42)
        self.led = Button(self,state='disabled')
        self.qmessage = Label(self,text="Edit the decks for the bot to use with Options->Custom_Decks before starting",font=tkFont.nametofont("TkTextFont"))
        self.start_button = Button(self, text="start", command=self.start_click)
        self.stop_button  = Button(self, text="stop", command=self.stop_click)

        self.start_button.grid(row=1,column=0,sticky='N')
        self.stop_button.grid(row=1,column=1,sticky='N')
        self.led.grid(row=1,column=2)
        self.qmessage.grid(row=0,column=0,columnspan=3)

        self.change_led_color("#ff0000"," off ")
        self.stop_button.config(state='disabled')
        
        self.deckopt=False
        self.deckwin=False
        
        self.queue       = Queue.Queue()
        self.logicthread = GameLogicThread(self.queue)

 def zoom_in(self, event):
     """ Ctrl+= increases text size """
     self.root.grid_propagate(False)
     font = tkFont.nametofont("CodeFont")
     size = font.actual()["size"]+2
     font.configure(size=size)
     return 'break'

 def __init__(self, parent):
     Frame.__init__(self, parent)
     Worker.__init__(self)
     self.customFont = tkFont.nametofont("TkDefaultFont")
     self.variables = {}
     self.pack()
     self.create_widgets()

 def zoom_out(self, event):
     """ Ctrl+- decreases text size (minimum of 8) """
     self.root.grid_propagate(False)
     font = tkFont.nametofont("CodeFont")
     size = max(8, font.actual()["size"]-2)
     font.configure(size=size)
     return  'break'

 def config_tags(self):
     """Get style defintions from the friendly local pygments formatter, and
     instantiate them as Tk.Text tag definitions."""
     
     # Discover what 'basefont' currently in use
     curFontName = self.cget('font')
     curFont = tkFont.nametofont(curFontName)
     curFontSpecs = curFont.actual()
     basefont = ' '.join([ str(curFontSpecs[k]) for k in 'family size'.split() ])
     
     # Get tag definitions from our pygments formatter
     styledict = self.formatter.get_style_defs()
     
     # Define our tags accordingly
     for tagName, attTupleList in styledict.iteritems():
         # print "tagconfig:", tagName, tkatts
         for attTuple in attTupleList:
             (attName, attValue) = attTuple
             if attName == 'font':
                 f = basefont.rsplit(' ', 1)
                 f = (f[0], f[1], attValue)
                 self.tag_configure(tagName, font = f)
                 #self.tag_configure(tagName, font = basefont + ' ' + attValue)
             else:
                 attSetter = dict([attTuple])
                 self.tag_configure(tagName, **attSetter)

    def __init__(self, master, text, background=None, font=None, familiy=None, size=None, underline=True, visited_fg = "#551A8B", normal_fg = "#0000EE", visited=False, action=None):
        self._visited_fg = visited_fg
        self._normal_fg = normal_fg
        
        if visited:
            fg = self._visited_fg
        else:
            fg = self._normal_fg

        if font is None:
            default_font = nametofont("TkDefaultFont")
            family = default_font.cget("family")

            if size is None:
                size = default_font.cget("size")

            font = Font(family=family, size=size, underline=underline)

        Label.__init__(self, master, text=text, fg=fg, cursor="hand2", font=font)

        if background is None:
            background = get_background_of_widget(master)

        self.configure(background=background)

        self._visited = visited
        self._action = action

        self.bind("<Button-1>", self._on_click)

    def __init__(self, parent):

        """ My constructor """

        self.tk = Tk()

        # set min and preferred size of main gui
        self.minwinwidth = 300
        self.minwinheight = 300
        screen_width = self.winfo_screenwidth()
        screen_height = self.winfo_screenheight()
        self.preferwinwidth = int(screen_width * 0.8)
        self.preferwinheight = int(screen_height * 0.8)
        self.minsize(width=self.minwinwidth, height=self.minwinheight)
        self.geometry("{}x{}".format(self.preferwinwidth, self.preferwinheight))

        # tweak the aspect ratio of the menu and data gui
        self.menuaspect = [1, 0.15]
        self.dataaspect = [1, 1 - 0.15]
        self.dpi = 80

        # find exect dir
        self.execdir = __file__.split("zfit.py")[0]
        if len(self.execdir) == 0:
            self.execdir = "./"

        # Fiddle with font
        default_font = tkFont.nametofont("TkDefaultFont")
        default_font.configure(size=14)

        # init gui frame
        self.initialize()

	def __init__(self, master, app, *kw, **kwargs):
		Listbox.__init__(self, master, *kw, **kwargs)
		self.bind("<Button-1>",		self.button1)
		self.bind("<ButtonRelease-1>",	self.release1)
		self.bind("<Double-1>",		self.double)
		self.bind("<Return>",		self.edit)
		self.bind("<KP_Enter>",		self.edit)
		self.bind("<Insert>",		self.insertItem)
		self.bind("<Control-Key-Return>",self.insertItem)
		self.bind("<Control-Key-space>",self.commandFocus)
		self.bind("<Delete>",		self.deleteLine)
		self.bind("<BackSpace>",	self.deleteLine)
		try:
			self.bind("<KP_Delete>",self.deleteLine)
		except:
			pass

		self.bind("<Control-Key-b>",	self.insertBlock)
		self.bind("<Control-Key-r>",	self.fill)

		self._blockPos = []
		self._items    = []
		self.app       = app
		self.gcode     = app.gcode
		self.font      = tkFont.nametofont(self.cget("font"))
		self._ystart   = 0
		self._double   = False	# double clicked handled
		self._hadfocus = False

 def building_fonts(self):
     "building fonts"
     if not ON_PYTHON3:
         import tkFont
     else:
         from tkinter import font as tkFont
     self.title_font = tkFont.nametofont("TkCaptionFont")
     self.button_font = tkFont.Font(name="Helvetica", size=28)

    def zoom_in(self, event):
        """ Ctrl+= increases text size """

        font = tkFont.nametofont("CodeFont")
        size = font.actual()["size"]+2
        font.configure(size=size)

        return 'break'

    def controls(self):
        self.controlwin = Toplevel(self)
        self.controlwin.resizable(0,0)
        custom_title = Label(self.controlwin,text="Control options:",font=tkFont.nametofont("TkTextFont"))
        custom_title.grid(row=0,column=0,columnspan=3)
        #self.mouse_button = Button(self.controlwin,    text="Move mouse         ",font=self.mediumfont, command=self.toggle_move_mouse)
        #self.mouse_button.grid(row=1,column=0)
        #if defines.USE_MOUSE:
        #    self.mouse_button.configure(background="#00ff00")
        #else:
        #    self.mouse_button.configure(background="#ff0000")

        mouse_speed_label = Label(self.controlwin,text="Mouse speed:",font=tkFont.nametofont("TkTextFont"))
        mouse_speed_label.grid(row=2,column=0)
        self.mouse_speed_scale = Scale(self.controlwin, from_=1, to=9,font=tkFont.nametofont("TkTextFont"), orient=HORIZONTAL,command=self.save_mouse_speed)
        self.mouse_speed_scale.grid(row=2,column=1)
        self.mouse_speed_scale.set(defines.MOUSE_SPEED)

        start_hour_label = Label(self.controlwin,text="Hour to start:",font=tkFont.nametofont("TkTextFont"))
        start_hour_label.grid(row=3,column=0)
        self.start_hour_scale = Scale(self.controlwin, from_=0, to=24,font=tkFont.nametofont("TkTextFont"), orient=HORIZONTAL,command=self.save_start_hour)
        self.start_hour_scale.grid(row=3,column=1)
        self.start_hour_scale.set(defines.START_HOUR)
        
        stop_hour_label = Label(self.controlwin,text="Hour to stop:",font=tkFont.nametofont("TkTextFont"))
        stop_hour_label.grid(row=4,column=0)
        self.stop_hour_scale = Scale(self.controlwin, from_=0, to=24,font=tkFont.nametofont("TkTextFont"), orient=HORIZONTAL,command=self.save_stop_hour)
        self.stop_hour_scale.grid(row=4,column=1)
        self.stop_hour_scale.set(defines.STOP_HOUR)

    def create_res_window(self, results, table_name):
        """Creates a window to navigate and select item results of query.
        As side effect, uses set_selection function to resolve selection events.

        :param results: the results to display
        :param table_name: the name of the table being queried
        :return: None
        """

        self.results = results

        def to_string(item):
            """Returns an appropriate string reps for results display.

            :param item: item to represent
            :return: formatted string
            """
            the_string = ''
            for i in [1, 2, 3, 4, 8, 6]:
                if i == 6:
                    the_string += "$" + "%.2f" % item[i] + '   '
                elif i == 2:
                    if table_name == 'Tie':
                        the_string += str(item[i]) + '"' + '   '
                    else:
                        the_string += str(item[i]) + '   '
                elif i == 8:
                    the_string += item[i] + " (" + item[10] + ", " + item[11] + ")   "
                else:
                    the_string += item[i] + '   '
            return the_string

        # setup toplevel display
        self.scroll_window = Toplevel(self.frame)
        self.scroll_window.geometry("%dx%d%+d%+d" % (500, 200, self.frame.winfo_rootx()+10, self.frame.winfo_rooty()))

        inner_window = Frame(self.scroll_window)
        inner_window.pack(fill=BOTH)

        # setup horizontal and vertical scrollbars
        scrollbar = Scrollbar(inner_window, orient=VERTICAL)
        xscrollbar = Scrollbar(inner_window, orient=HORIZONTAL)
        self.select_list = Listbox(inner_window, yscrollcommand=scrollbar.set, xscrollcommand=xscrollbar.set,
                                   font=tkFont.nametofont('TkFixedFont'))
        scrollbar.config( command = self.select_list.yview)
        scrollbar.pack(side=RIGHT, fill=Y)
        xscrollbar.config( command = self.select_list.xview)
        xscrollbar.pack(side=BOTTOM, fill=X)

        # insert string reps of result items
        for item in results:
            self.select_list.insert(END, to_string(item))
        self.select_list.pack(side=LEFT, fill=BOTH, expand=1)

        #currently destroy window... need to return/set selection
        Button(self.scroll_window, text="Select", command=self.set_selection).pack(side=LEFT, expand=1)
        Button(self.scroll_window, text="Cancel", command=lambda: self.set_selection(True)).pack(side=RIGHT, expand=1)

    def createLabel(self, text, row):
        paddingLeft = WINDOW_BORDER
        paddingTop = WINDOW_BORDER if (row == 0) else 0

        labelFont = tkFont.nametofont("TkDefaultFont")

        text = text + ":"
        label = Tkinter.Label(self, anchor="e", fg="black", text=text, width=WINDOW_LABEL_WIDTH, font=labelFont)
        label.grid(
            column=0, row=row, sticky="NE", padx=(paddingLeft, WINDOW_SPACING), pady=(paddingTop, WINDOW_SPACING)
        )

def set_font(root, size):
    """TODO: Docstring for set_font.

    :root: TODO
    :size: TODO
    :returns: TODO

    """
    default_font = tkFont.nametofont('TkDefaultFont')
    default_font.configure(size=size)
    root.option_add('*Font', default_font)

    def __init__(self, *args, **kwargs):
        tk.Label.__init__(self, *args, **kwargs)

        # clone the font, so we can dynamically change
        # it to fit the label width
        font = self.cget("font")
        base_font = tkFont.nametofont(self.cget("font"))
        self.font = tkFont.Font()
        self.font.configure(**base_font.configure())
        self.configure(font=self.font)

        self.bind("<Configure>", self._on_configure)

 def createSpace(self, row):
     paddingLeft = WINDOW_BORDER
     paddingTop = WINDOW_BORDER if (row == 0) else 0
     
     labelFont = tkFont.nametofont("TkDefaultFont")
     labelFont = labelFont.copy()
     labelFont.config(weight='bold')
     
     text = ""
     label = Tkinter.Label(self,
         anchor="e", fg="black", text=text, width=WINDOW_LABEL_WIDTH, font=labelFont)
     label.grid(column=0, row=row, sticky='NE',
         padx=(paddingLeft, WINDOW_SPACING), pady=(paddingTop, WINDOW_SPACING))