def count_lines(self, s):
        """Count the number of lines in a given text.

        Before calculation, the tab width and line length of the text are
        fetched, so that up-to-date values are used.

        Lines are counted as if the string was wrapped so that lines are never
        over linewidth characters long.

        Tabs are considered tabwidth characters long.
        """
        # Tab width is configurable
        tabwidth = self.editwin.get_tk_tabwidth()

        # Get the Text widget's size
        linewidth = self.editwin.text.winfo_width()
        # Deduct the border and padding
        linewidth -= 2*sum([int(self.editwin.text.cget(opt))
                            for opt in ('border', 'padx')])

        # Get the Text widget's font
        font = Font(self.editwin.text, name=self.editwin.text.cget('font'))
        # Divide the size of the Text widget by the font's width.
        # According to Tk8.5 docs, the Text widget's width is set
        # according to the width of its font's '0' (zero) character,
        # so we will use this as an approximation.
        # see: http://www.tcl.tk/man/tcl8.5/TkCmd/text.htm#M-width
        linewidth //= font.measure('0')

        return count_lines_with_wrapping(s, linewidth, tabwidth)

 def SyntexHighlight(self, event=None):
     from tkinter.font import Font
     for tag in self.tag_names():
         self.tag_delete(tag)
     self.mark_set("range_start", "1.0")
     data = self._get_value()
     self.tag_configure("Token.Comment", foreground="#F00")
     bolder = Font(family=self.app.cnf['font'][0])
     bolder.config(size=self.app.cnf['font'][1]-2)
     bolder.config(weight="bold")
     for token, content in lex(data, PythonLexer()):
         self.mark_set("range_end", "range_start + %dc" % len(content))
         self.tag_add(str(token), "range_start", "range_end")
         self.mark_set("range_start", "range_end")
     self.tag_config("Token.Comment.Single", foreground="#F00")
     self.tag_config("Token.Literal.String.Doc", foreground="#F00")
     for tag in self.tag_names():
         if 'Token.Keyword' == tag:
             self.tag_config(tag, foreground="#008", font=bolder)
         elif 'Token.Keyword.Namespace' == tag:
             self.tag_config(tag, foreground="#00F", font=bolder)
         elif 'Token.Name.Class' in tag:
             self.tag_config(tag, foreground="#F30", background='#AFA')
         elif 'Token.Name.Function' in tag:
             self.tag_config(tag, foreground="#A3A", background='#FFA')
         elif 'Token.Literal' in tag:
             self.tag_config(tag, foreground="#6A0")
         elif 'Token.Operator' in tag:
             self.tag_config(tag, foreground="#A3A")
     print(self.tag_names())

        def text_extents(self, style, text):
            """
            The text extents are calculated using tkinter.Font
            """
            with InternalWindow() as window:
                font_type = ""
                if style["bold"]:
                    font_type += "bold"
                if style["italic"]:
                    if len(font_type) > 0:
                        font_type += " "
                    font_type += "italic"

                # Create the new font object.
                font = Font(window, (style["font"], -int(style["size"]*FONT_SCALING), font_type))
                # Query the data
                width = font.measure(text)
                metrics = font.metrics()

            return {
                "width": width / float(FONT_SCALING),
                "height": metrics["linespace"] / float(FONT_SCALING),
                "ascent": metrics["ascent"] / float(FONT_SCALING),
                "descent": metrics["descent"] / float(FONT_SCALING)
            }

    def initialize(self):
        #Create the menubar
        self.menubar=Menu(self)
        menu=Menu(self.menubar,tearoff=0)
        self.menubar.add_cascade(label="File",menu=menu)
        menu.add_command(label="Open",command=self.openfile)
        #menu.add_command(label="Exit")
        menu=Menu(self.menubar,tearoff=0)
        self.menubar.add_cascade(label="Tools",menu=menu)
        menu.add_command(label="Class",command=self.classwindow)
        menu.add_command(label="Hilbert",command=self.hilbertwindow)
        menu.add_command(label="Entropy",command=self.entropywindow)
        menu.add_command(label="Gradient",command=self.gradientwindow)
        self.master.config(menu=self.menubar)

        #Configure grid layout
        self.columnconfigure(0,pad=5)
        self.columnconfigure(1,pad=5)
        self.columnconfigure(2,pad=5)
        self.rowconfigure(0,pad=5)
        self.rowconfigure(0,pad=5)

        #Add canvas to plot points from converted hex values
        self.plotcanvas=Canvas(self,width=256,height=256)
        self.plotcanvas.configure(background='black')
        self.plotcanvas.grid(row=0,column=0)

        #Add listbox to hold the current group of hexvalues
        listframe=Frame(self)
        hexscroll=Scrollbar(listframe,orient=VERTICAL)
        hexbox_font = Font(size=8)
        hexbox_font.config(family={"posix": "Monospace","nt": "Courier New"})
        self.hexbox=Listbox(listframe,width=75,height=20,font=hexbox_font,yscrollcommand=hexscroll.set,selectmode=EXTENDED)
        hexscroll.config(command=self.hexbox.yview)
        hexscroll.pack(side=RIGHT,fill=Y)
        self.hexbox.pack(side=LEFT)
        listframe.grid(row=0,column=1)

        #Add slider for location in hex lines and size of window of hex values
        commandframe=Frame(self)
        playframe=Frame(commandframe)
        windowframe=Frame(commandframe)
        self.playslider=Scale(playframe,command=self.playslider_moved)
        self.playslider.configure(from_=0,to=100)
        self.playslider.configure(orient=HORIZONTAL)
        self.playslider.pack(side=BOTTOM)
        hexaddress=gethexaddress(int(self.playslider.get()))
        self.currhexaddress=Label(playframe,width=20,text=hexaddress)
        self.currhexaddress.pack(side=TOP)
        self.curroffset=Label(windowframe,text=self.hexaddressoffset)
        self.curroffset.pack(side=TOP)
        self.windowslider=Scale(windowframe,command=self.windowslider_moved)
        self.windowslider.configure(from_=100,to=600,orient=HORIZONTAL)
        self.windowslider.pack(side=TOP)
        self.windowslider.set(self.hexaddressoffset)
        playframe.pack(side=LEFT)
        windowframe.pack(side=RIGHT)
        commandframe.grid(row=1,columnspan=2)

        self.pack()

 def adjust_fonts(self, event):
   new_font = Font(**self.fonts['normal'].configure())
   size = orig_size = new_font['size']
   desired_total_height = event.height
   orig_row_height = new_font.metrics('linespace')
   orig_row_height += self.LS_EXTRA
   orig_total_height = self.N_ROWS * orig_row_height
   if orig_total_height < desired_total_height:
     a, compfname, final_neg_adjust = 1, '__gt__', True
   elif orig_total_height > desired_total_height:
     a, compfname, final_neg_adjust = -1, '__lt__', False
   else:
     return
   prev_total_height = orig_total_height
   while True:
     if a < 0 and size <= self.MIN_FONT_SIZE:
       size = self.MIN_FONT_SIZE
       break
     size += a
     new_font.configure(size=size)
     new_row_height = new_font.metrics('linespace')
     new_row_height += self.LS_EXTRA
     new_total_height = self.N_ROWS * new_row_height
     if new_total_height == prev_total_height:
       size -= a
       break
     compf = getattr(new_total_height, compfname)
     if compf(desired_total_height):
       if final_neg_adjust and size > self.MIN_FONT_SIZE:
         size -= a
       break
     prev_total_height = new_total_height
   if size != orig_size:
     self.fonts['normal'].configure(size=size)
     self.fonts['bold'].configure(size=size)

 def overstrike(self, *args):
     """Toggles overstrike for selected text."""
     try:
         current_tags = self.text.tag_names("sel.first")
         if "overstrike" in current_tags:
             self.text.tag_remove("overstrike", "sel.first", "sel.last")
         else:
             self.text.tag_add("overstrike", "sel.first", "sel.last")
             overstrike_font = Font(self.text, self.text.cget("font"))
             overstrike_font.configure(overstrike=1)
             self.text.tag_configure("overstrike", font=overstrike_font)
     except TclError:
         pass

 def underline(self, *args):
     """Toggles underline for selected text."""
     try:
         current_tags = self.text.tag_names("sel.first")
         if "underline" in current_tags:
             self.text.tag_remove("underline", "sel.first", "sel.last")
         else:
             self.text.tag_add("underline", "sel.first", "sel.last")
             underline_font = Font(self.text, self.text.cget("font"))
             underline_font.configure(underline=1)
             self.text.tag_configure("underline", font=underline_font)
     except TclError:
         pass

 def italic(self, *args):
     """Toggles italic for selected text."""
     try:
         current_tags = self.text.tag_names("sel.first")
         if "italic" in current_tags:
             self.text.tag_remove("italic", "sel.first", "sel.last")
         else:
             self.text.tag_add("italic", "sel.first", "sel.last")
             italic_font = Font(self.text, self.text.cget("font"))
             italic_font.configure(slant="italic")
             self.text.tag_configure("italic", font=italic_font)
     except TclError:
         pass

 def bold(self, *args):
     """Toggles bold for selected text."""
     try:
         current_tags = self.text.tag_names("sel.first")
         if "bold" in current_tags:
             self.text.tag_remove("bold", "sel.first", "sel.last")
         else:
             self.text.tag_add("bold", "sel.first", "sel.last")
             bold_font = Font(self.text, self.text.cget("font"))
             bold_font.configure(weight="bold")
             self.text.tag_configure("bold", font=bold_font)
     except TclError:
         pass

    def GetFont(self, root, configType, section):
        """Retrieve a font from configuration (font, font-size, font-bold)
        Intercept the special value 'TkFixedFont' and substitute
        the actual font, factoring in some tweaks if needed for
        appearance sakes.

        The 'root' parameter can normally be any valid Tkinter widget.

        Return a tuple (family, size, weight) suitable for passing
        to tkinter.Font
        """
        family = self.GetOption(configType, section, 'font', default='courier')
        size = self.GetOption(configType, section, 'font-size', type='int',
                              default='10')
        bold = self.GetOption(configType, section, 'font-bold', default=0,
                              type='bool')
        if (family == 'TkFixedFont'):
            f = Font(name='TkFixedFont', exists=True, root=root)
            actualFont = Font.actual(f)
            family = actualFont['family']
            size = actualFont['size']
            if size <= 0:
                size = 10  # if font in pixels, ignore actual size
            bold = actualFont['weight'] == 'bold'
        return (family, size, 'bold' if bold else 'normal')

 def __init__(self, wdw, sols):
     """
     Stores the list of solutions in sols
     and defines the layout of the GUI.
     """
     wdw.title('solutions scroller')
     self.sols = sols
     self.cursor = 0
     self.lbl = Label(wdw, text="solution : ")
     self.lbl.grid(row=0, column=0, sticky=E) 
     self.ent = Entry(wdw)
     self.ent.grid(row=0, column=1, stick=W)
     self.ent.insert(INSERT, "0 of %d" % len(sols))
     self.myft = Font(family="Courier New", size=12, weight="normal")
     self.mlen = self.myft.measure("M")
     lines = sols[0].split('\n')
     self.width = max([len(line) for line in lines])
     self.display = StringVar()
     self.display.set(self.sols[0])
     self.mess = Message(wdw, textvariable=self.display, \
         font=self.myft, width=self.width*self.mlen, background='white')
     self.mess.grid(row=1, column=0, columnspan=2)
     self.btnext = Button(wdw, command=self.next, text='next')
     self.btnext.grid(row=2, column=1, sticky=W+E)
     self.btprev = Button(wdw, command=self.previous, text='previous')
     self.btprev.grid(row=2, column=0, sticky=W+E)

    def _init_fonts(self, root):
        # See: <http://www.astro.washington.edu/owen/ROTKFolklore.html>
        self._sysfont = Font(font=Button()["font"])
        root.option_add("*Font", self._sysfont)

        # TWhat's our font size (default=same as sysfont)
        self._size = IntVar(root)
        self._size.set(self._sysfont.cget("size"))

        self._boldfont = Font(family="helvetica", weight="bold", size=self._size.get())
        self._font = Font(family="helvetica", size=self._size.get())
        if self._size.get() < 0:
            big = self._size.get() - 2
        else:
            big = self._size.get() + 2
        self._bigfont = Font(family="helvetica", weight="bold", size=big)

    def GetFont(self, root, configType, section):
        """Retrieve a font from configuration (font, font-size, font-bold)
        Intercept the special value 'TkFixedFont' and substitute
        the actual font, factoring in some tweaks if needed for
        appearance sakes.

        The 'root' parameter can normally be any valid Tkinter widget.

        Return a tuple (family, size, weight) suitable for passing
        to tkinter.Font
        """
        family = self.GetOption(configType, section, "font", default="courier")
        size = self.GetOption(configType, section, "font-size", type="int", default="10")
        bold = self.GetOption(configType, section, "font-bold", default=0, type="bool")
        if family == "TkFixedFont":
            if TkVersion < 8.5:
                family = "Courier"
            else:
                f = Font(name="TkFixedFont", exists=True, root=root)
                actualFont = Font.actual(f)
                family = actualFont["family"]
                size = actualFont["size"]
                if size < 0:
                    size = 10  # if font in pixels, ignore actual size
                bold = actualFont["weight"] == "bold"
        return (family, size, "bold" if bold else "normal")

class Scroller(object):
    """
    Scrolls through a solution list.
    """
    def __init__(self, wdw, sols):
        """
        Stores the list of solutions in sols
        and defines the layout of the GUI.
        """
        wdw.title('solutions scroller')
        self.sols = sols
        self.cursor = 0
        self.lbl = Label(wdw, text="solution : ")
        self.lbl.grid(row=0, column=0, sticky=E) 
        self.ent = Entry(wdw)
        self.ent.grid(row=0, column=1, stick=W)
        self.ent.insert(INSERT, "0 of %d" % len(sols))
        self.myft = Font(family="Courier New", size=12, weight="normal")
        self.mlen = self.myft.measure("M")
        lines = sols[0].split('\n')
        self.width = max([len(line) for line in lines])
        self.display = StringVar()
        self.display.set(self.sols[0])
        self.mess = Message(wdw, textvariable=self.display, \
            font=self.myft, width=self.width*self.mlen, background='white')
        self.mess.grid(row=1, column=0, columnspan=2)
        self.btnext = Button(wdw, command=self.next, text='next')
        self.btnext.grid(row=2, column=1, sticky=W+E)
        self.btprev = Button(wdw, command=self.previous, text='previous')
        self.btprev.grid(row=2, column=0, sticky=W+E)

    def show(self):
        """
        Shows the solution at position self.cursor
        in the message widget and updates the entry widget.
        """
        self.display.set(self.sols[self.cursor])
        self.ent.delete(0, END)
        self.ent.insert(INSERT, '%d of %d' % (self.cursor, len(self.sols)))

    def next(self):
        """
        Increases the cursor by one if possible.
        """
        if self.cursor < len(self.sols) - 1:
            self.cursor = self.cursor + 1
        self.show()

    def previous(self):
        """
        Decreases the cursor by one if possible.
        """
        if self.cursor > 0:
            self.cursor = self.cursor - 1
        self.show()

 def __init__(self, master):
     BaseDiablog.__init__(self, master, "Preferences", exit_on_esc=True)
     self.startup_check = Config.config["startup_check"]
     self.general_label = ttk.Label(self.body,
                                    text="General")
     font = Font(self.general_label, self.general_label.cget("font"))
     font.configure(underline=True)
     self.general_label.configure(font=font)
     self.config_frame = ttk.Frame(self)
     self.startup_check_checkbtn = ttk.Checkbutton(self.config_frame,
                                                   text="Check for update at launch",
                                                   variable=PreferencesDialog.startup_check.raw_klass(self),
                                                   command=self._startup_check_clicked)
     self.buttons_frame = ttk.Frame(self)
     self.close_button = ttk.Button(self.buttons_frame,
                                    text="Close",
                                    command=self.destroy)
     options = dict(padx=5, pady=5)
     self.general_label.pack(side=LEFT, **options)
     self.config_frame.pack(fill=BOTH, expand=True, **options)
     self.startup_check_checkbtn.pack(side=LEFT, **options)
     self.buttons_frame.pack(side=BOTTOM, fill=BOTH, expand=True, **options)
     self.close_button.pack(side=RIGHT, expand=False)

 def define_appearance(self):
     self.height = 22
     self.minwidth = 130
     self.maxwidth = 300
     self.addiconwidth = 24
     self.gapwidth = 15
     self.bg = '#c4c4c4'
     self.selbg = '#d3d3d3'
     self.dividerbg = '#b0b0b0'
     self.textcolor = '#424242'
     self.holecolor = '#eeeeee'
     self.titlefont = Font(name='TkTooltipFont', exists=True,
                           root=self.parent)
     self.tooltipfont = Font(name='TkTooltipFont', exists=True,
                             root=self.parent)
     self.plusfont = Font(name='TkMenuFont', exists=True, root=self.parent)

    def test_get_font(self):
        from test.support import requires
        from tkinter import Tk
        from tkinter.font import Font
        conf = self.mock_config()

        requires('gui')
        root = Tk()
        root.withdraw()

        f = Font.actual(Font(name='TkFixedFont', exists=True, root=root))
        self.assertEqual(
            conf.GetFont(root, 'main', 'EditorWindow'),
            (f['family'], 10 if f['size'] <= 0 else f['size'], f['weight']))

        # Cleanup root
        root.destroy()
        del root

    def __init__(self, master=None, **cnf):
        ScrolledText.__init__(self, master, **cnf)

        bold = Font(font=self['font']).copy()
        bold.config(weight='bold')
        italic = Font(font=self['font']).copy()
        italic.config(slant='italic')

        # Define tags for formatting styles
        self.tag_config('X', underline=1)
        self.tag_config('!', font=bold)
        self.tag_config('_', font=italic)

        # Set state to idle
        self.fp = None
        self.lineno = 0

    def __init__(self, master, client, queue, send_command):
        super(ClientUI, self).__init__()
        self.client = client
        self.queue = queue
        self.send_command = send_command
        self.master = master
        self.plugin_manager = PluginManager(self.send_command_with_prefs, self.echo)
        self.interrupt_input = False
        self.interrupt_buffer = deque()
        self.input_buffer = []
        self.input_cursor = 0
        self.list_depth = 0
        self.MAP_OFFSET = 60

        menu_bar = tk.Menu(master)
        self.menu_file = tk.Menu(menu_bar, tearoff=0)
        self.menu_file.add_command(label="Preferences", command=self.show_preferences)
        self.menu_file.add_command(label="Disconnect", command=self.client.shutdown)
        self.menu_file.add_command(label="Quit", command=self.client.quit)
        menu_bar.add_cascade(label="Client", menu=self.menu_file)

        self.create_plugin_menu(menu_bar)

        self.master.config(menu=menu_bar)

        self.master.grid()
        tk.Grid.rowconfigure(self.master, 0, weight=1)
        tk.Grid.columnconfigure(self.master, 0, weight=1)
        self.status = dict()
        self.create_widgets()

        self.side_bar = master.children['side_bar']
        self.output_panel = master.children['output_frame'].children['output']
        self.output_panel.configure(state="normal")
        self.output_panel.bind('<Key>', lambda e: 'break')
        self.input = master.children['input']
        self.context_menu = master.children['context_menu']

        self.char_width = Font(self.output_panel, self.output_panel.cget("font")).measure('0')
        self.line_length = self.calc_line_length(self.output_panel.cget("width"))
        italic_font = Font(self.output_panel, self.output_panel.cget("font"))
        italic_font.configure(slant='italic')
        self.output_panel.tag_configure("italic", font=italic_font)
        bold_font = Font(self.output_panel, self.output_panel.cget("font"))
        bold_font.configure(weight='bold')
        self.output_panel.tag_configure('bold', font=bold_font)
        self.output_panel.tag_configure("center", justify=tk.CENTER)

    def __init__(self, master, client, queue, send_command):
        super(ClientUI, self).__init__()
        self.client = client
        self.queue = queue
        self.send_command = send_command
        self.master = master
        self.interrupt_input = False
        self.interrupt_buffer = deque()
        self.input_buffer = []
        self.input_cursor = 0
        self.list_depth = 0

        menu_bar = tk.Menu(master)
        self.menu_file = tk.Menu(menu_bar, tearoff=0)
        self.menu_file.add_command(label="Preferences", command=self.show_preferences)
        self.menu_file.add_command(label="Disconnect", command=self.client.shutdown)
        self.menu_file.add_command(label="Quit", command=self.client.quit)
        menu_bar.add_cascade(label="Client", menu=self.menu_file)
        self.master.config(menu=menu_bar)

        self.master.grid()
        tk.Grid.rowconfigure(self.master, 0, weight=1)
        tk.Grid.columnconfigure(self.master, 0, weight=1)
        self.create_widgets()

        # pprint(vars(master))
        self.side_bar = master.children['side_bar']
        self.output_panel = master.children['output']
        self.input = master.children['input']

        self.char_width = Font(self.output_panel, self.output_panel.cget("font")).measure('0')
        self.line_length = self.calc_line_length(self.output_panel.cget("width"))
        italic_font = Font(self.output_panel, self.output_panel.cget("font"))
        italic_font.configure(slant='italic')
        self.output_panel.tag_configure("italic", font=italic_font)
        bold_font = Font(self.output_panel, self.output_panel.cget("font"))
        bold_font.configure(weight='bold')
        self.output_panel.tag_configure('bold', font=bold_font)
        self.output_panel.tag_configure("center", justify=tk.CENTER)