OwlCyberSecurity - MANAGER

Edit File: Prof.py

from tkinter import *
import tkinter.filedialog
import tkinter.messagebox

from guppy.etc.Descriptor import property_nondata

class MyVar(StringVar):
    _default = 0.0

def set(self, value):
        StringVar.set(self, '%.2g' % value)

suffixes = ('', 'K', 'M', 'G', 'T')

def sizestring(value):
    value = float(value)
    sign = 1
    if value < 0:
        sign = -1
        value = - value
    i = 0
    while value > 99999:
        value /= 1000
        i += 1
    s = str(int(round(value)))+suffixes[i]
    if s.endswith('000'+suffixes[i]):
        s = str(int(round(value/1000)))+suffixes[i+1]
    if sign == -1:
        s = '-' + s
    return s

def percentstring(value):
    a = abs(value)
    if 10 <= a <= 9999:
        return '%d' % round(value)
    elif 0.01 <= a <= 10:
        return '%.2g' % value
    elif a <= 1e-10:
        return '0'
    else:
        return '%.0e' % value

def stringsize(s):
    if s.isdigit():
        return int(s)
    suf = s[-1:].upper()
    mult = 1000
    for su in suffixes[1:]:
        if su == suf:
            break
        mult *= 1000
    else:
        raise ValueError
    return int(s[:-1])*mult

class Menu(Menu):
    # A fix for the .delete() method in Menu.
    # To delete commands defined in the menu items deleted.
    # Also changed the comment: INDEX2 is actually INCLUDED.
    def delete(self, index1, index2=None):
        """Delete menu items between INDEX1 and INDEX2 (included)."""
        if index2 is None:
            index2 = index1
        # First find out what entries have defined commands.
        cmds = []
        for i in range(self.index(index1), self.index(index2)+1):
            c = str(self.entrycget(i, 'command'))
            if c in self._tclCommands:
                # I don't want to delete the command already, since it
                # seems mystical to do that while the entry is not yet deleted.
                cmds.append(c)
        # Delete the menu entries.
        self.tk.call(self._w, 'delete', index1, index2)
        # Now that the menu entries have been deleted,
        # we can delete their commands.
        for c in cmds:
            self.deletecommand(c)

class SizeVar(StringVar):
    _default = 0.0

def set(self, value):
        self._value = value
        s = sizestring(value)
        StringVar.set(self, s)

class ValueLabel(Label):
    def __init__(self, *args, **kwds):
        kwds['width'] = 10
        Label.__init__(self, *args, **kwds)

class ClickButton(Button):
    # Button that runs the command directly at the click, not at release.
    # And has auto-repeat.
    def __init__(self, master, command, firstdelay=500, thendelay=150, **kwds):
        Button.__init__(self, master, **kwds)
        self._command = command
        self._firstdelay = firstdelay
        self._thendelay = thendelay
        self.bind('<Button-1>', self._event_button)
        self.bind('<ButtonRelease-1>', self._event_release)

def _event_button(self, event=None):
        self._command()
        if event is not None:
            delay = self._firstdelay
        else:
            delay = self._thendelay
        self._after = self.after(delay, self._event_button)

def _event_release(self, event):
        self.after_cancel(self._after)
        del self._after

class Stats:
    def __init__(self, mod, fn=None):
        self.mod = mod
        self.os = mod.os
        self.hashlib = mod.hashlib
        self.fn = fn

def clear_cache(self):
        # It is intended to be transparently
        # automagically reopened when needed.
        self.stats = None
        del self.stats

def get_stats(self):
        self.open(self.fn)
        return self.stats

stats = property_nondata(get_stats)

def collect(self):
        if not self.fn:
            return 0, 0

stat = self.os.stat(self.fn)
        if stat == self.laststat:
            return len(self), 0

with open(self.fn) as f:
            str = f.read(self.lastfilesize)
            md5 = self.hashlib.md5(str.encode('utf-8'))
            digest = md5.digest()
            if digest == self.lastdigest:
                numoldstats = len(self)
            else:
                self.loadstr(str, reset=1)
                numoldstats = 0

str = f.read()

self.laststat = self.os.fstat(f.fileno())
        self.lastfilesize = self.laststat.st_size

md5.update(str.encode('utf-8'))
        self.lastdigest = md5.digest()
        self.loadstr(str)

numnewstats = len(self.stats)-numoldstats

return numoldstats, numnewstats

def open(self, fn):
        if not fn:
            self.len_stats = 0
            self.stats = []
            self.max_size = 0
            self.fn = fn
            return

with open(fn) as f:
            str = f.read()
            lastdigest = self.hashlib.md5(str.encode('utf-8')).digest()
            laststat = self.os.fstat(f.fileno())
        self.loadstr(str, reset=1)

# Update these only if there was no exception so far.
        self.fn = fn
        self.lastdigest = lastdigest
        self.laststat = laststat
        self.lastfilesize = laststat.st_size

def loadstr(self, str, reset=0):
        stats = []
        lines = str.split('\n')
        del str
        linesiter = iter(lines)
        max_size = 0
        while 1:
            try:
                st = self.mod.Use.load(linesiter)
            except StopIteration:
                break
            stats.append(st)
            if st.size > max_size:
                max_size = st.size

# Only update self if there were no exception so far

if reset:
            self.stats = []
            self.max_size = 0

self.max_size = max(self.max_size, max_size)
        self.stats.extend(stats)
        self.len_stats = len(self.stats)

def __getitem__(self, idx):
        return self.stats[idx]

def __len__(self):
        try:
            return self.len_stats
        except AttributeError:
            self.len_stats = len(self.stats)
            return self.len_stats

def get_max_size(self):
        return self.max_size

class ProfileRow:
    kindwidth = 30

def __init__(self, master, row, usecolor=1):
        self.master = master
        self.row = row
        if usecolor:
            colbg = Frame(master=master, bg='black', width=1,
                          borderwidth=1, relief=GROOVE)
            self.color = Label(master=colbg, bg='white',
                               width=1, borderwidth=1, relief=GROOVE)
            self.color.grid(row=0, column=0)
            colbg.grid(row=row, column=0, sticky=NW)

self.rsizevar = SizeVar()
        self.rsize = Label(
            master=master, textvariable=self.rsizevar, width=6, anchor=E)
        self.rpercentvar = StringVar()  # BBIntVar()
        self.rpercent = Label(
            master=master, textvariable=self.rpercentvar, width=3, anchor=E)
        self.dsizevar = SizeVar()
        self.dsize = Label(
            master=master, textvariable=self.dsizevar, width=6, anchor=E)
        self.dpercentvar = StringVar()  # BBIntVar()
        self.dpercent = Label(
            master=master, textvariable=self.dpercentvar, width=3, anchor=E)
        self.kindvar = StringVar()
        self.kind = Label(master=master, textvariable=self.kindvar, anchor=NW,
                          width=self.kindwidth, justify=LEFT)

self.rsize.grid(row=row, column=1, sticky=NE)
        self.rpercent.grid(row=row, column=2, sticky=NE)
        self.dsize.grid(row=row, column=3, sticky=NE)
        self.dpercent.grid(row=row, column=4, sticky=NE)
        self.kind.grid(row=row, column=5, sticky=NW)

def set_color_size_percent_kind(self, color, rsize, rpercent, dsize, dpercent, kind):
        self.set_color(color)
        if color is not None:
            self.set_color(color)
        self.rsizevar.set(rsize)
        if rpercent is None:
            rpercent = ''
        else:
            rpercent = str(int(round(rpercent)))
        self.rpercentvar.set(rpercent)

self.dsizevar.set(dsize)
        dpercent = str(int(round(dpercent)))
        self.dpercentvar.set(dpercent)

self.set_kind(kind)

def set_color(self, color):
        self.color.configure(bg=color)

def set_kind(self, kind):
        self.kindtext = kind

if len(kind) > self.kindwidth:
            import textwrap
            kind = textwrap.fill(kind, width=self.kindwidth)
        self.kindvar.set(kind)

def clear(self):
        self.set_color_size_percent_kind(self.master['bg'], 0, 0, 0, 0, '--')

class AxisControl:
    scale_table = [1, 2, 5]
    while scale_table[-1] < 1e12:
        scale_table.append(scale_table[-3] * 10)

def __init__(self, master,
                 name,
                 range,
                 grid,
                 unit,
                 rangecommand,
                 gridcommand,
                 autocommand=None
                 ):
        small = 0

self.name = name
        self.unit = unit
        self.range = range
        self.rangecommand = rangecommand

self.frame = frame = Frame(master, borderwidth=2, relief=GROOVE)

self.rangevar = SizeVar()
        self.rangevar.set(range)
        rangeval = Entry(master=self.frame,
                         # anchor=E,
                         width=4,
                         textvar=self.rangevar,
                         #font=('fixed', '16', 'bold'),
                         #font=('terminal', '16', 'bold'),
                         #font=('terminal', '14'),
                         font=('fixed', '14'),
                         # bg='black',fg='yellow'
                         bg='#fdd'
                         )
        rangeval.bind('<KeyPress-Return>', self.event_range_enter)

namelabel = Menubutton(frame, text=name, relief='raised', anchor=W)

namemenu = Menu(namelabel)
        namelabel['menu'] = namemenu

if autocommand:
            self.autovar = BooleanVar()
            self.autovar.set(True)
            namemenu.add_checkbutton(
                # autobutton = Checkbutton(frame,
                label='Auto',
                variable=self.autovar,
                command=autocommand,
                # relief=RAISED
            )
            autobutton = Checkbutton(frame,
                                     text='Auto',
                                     variable=self.autovar,
                                     command=autocommand,
                                     relief=RAISED
                                     )

else:
            self.autovar = None

if gridcommand:
            self.gridvar = BooleanVar()
            self.gridvar.set(grid)
            namemenu.add_checkbutton(
                label='Grid',
                variable=self.gridvar,
                command=lambda: gridcommand(self.gridvar.get()),
            )

gridbutton = Checkbutton(frame,
                                     text='Grid',
                                     variable=self.gridvar,
                                     command=lambda: gridcommand(
                                         self.gridvar.get()),
                                     relief=RAISED
                                     )

rangelabel = Label(frame, text='Range')

if name == 'Y' and small:
            padx = 5
            pady = 0
        else:
            padx = 3
            pady = 3
        ud = Frame(frame)
        rangeup = ClickButton(ud, text='+',
                              pady=pady, padx=padx,
                              font=('fixed', 8),
                              command=lambda: self.range_button(1))

rangedown = ClickButton(ud, text='-',
                                pady=pady, padx=padx,
                                font=('fixed', 8),
                                command=lambda: self.range_button(-1))

rangedown.grid(row=0, column=0)
        rangeup.grid(row=0, column=1)
        row = 0

if small and name == 'Y':
            namelabel.grid(row=0, rowspan=1, column=0)
            rangeup.grid(row=0, column=1, sticky=W)

autobutton.grid(row=1, column=0)

rangedown.grid(row=1, column=1, sticky=W)
            rangeval.grid(row=2, column=0, columnspan=2,
                          sticky=W, padx=3, pady=3)

elif small and name == 'X':
            namelabel.grid(row=0, column=0)
            rangeval.grid(row=0, column=1, sticky=W, padx=3, pady=3)
            rangedown.grid(row=0, column=2, sticky=W)
            rangeup.grid(row=0, column=3, sticky=W)

else:
            namelabel.grid(row=row, column=0, sticky=N+W,
                           ipadx=0, ipady=0, padx=2, pady=2)
            rangelabel.grid(row=row, column=1, sticky=W)
            ud.grid(row=row, column=2, padx=2)
            row += 1

if gridcommand:
                gridbutton.grid(row=row, column=0, sticky=W)

rangeval.grid(row=row, column=1, padx=3, pady=3)
            if autocommand:
                pass
                autobutton.grid(row=row, column=2)

def cmd_range(self):
        pass

def event_range_enter(self, event):
        str = self.rangevar.get()
        try:
            rng = stringsize(str)
            if rng not in self.scale_table:
                if not 1 <= rng <= self.scale_table[-1]:
                    raise ValueError
        except ValueError:
            self.frame.bell()
            self.errorbox("""\
Invalid range entry.
It should be a positive integer with an optional multiplier:
K, M, G, or T
(1000, 1e6, 1e9, 1e12)
Maximum range is 1T.""")

self.rangevar.set(self.range)
        else:
            if self.autovar:
                self.autovar.set(False)
            self.setrange(rng)

def auto_command(self):
        pass

def errorbox(self, msg):
        tkinter.messagebox.showerror(master=self.frame, message=msg)

def fit(self, range):
        range = self.scale_by_table(range)
        self.setrange(range)

def range_button(self, d):
        if self.autovar:
            self.autovar.set(False)
        self.range_change(d)

def range_change(self, d):
        range = self.range
        srange = self.scale_by_table(range)
        if srange > range:
            if d > 0:
                d -= 1
        i = self.scale_table.index(srange)
        i += d
        if i >= len(self.scale_table):
            i = len(self.scale_table) - 1
        if i < 0:
            i = 0

self.setrange(self.scale_table[i])

def setrange(self, range):
        if range != self.range:
            self.range = range
            self.rangevar.set(range)
            self.rangecommand(range)

def scale_by_table(self, s):
        # Return the scale from table that is higher or equal to s
        for ts in self.scale_table:
            if ts >= s:
                return ts
        return self.scale_table[-1]

WM = 1

class Marker:
    def __init__(self, d, tag, name, pos, poscommand=None):
        self.d = d
        self.tag = tag
        self.name = name
        self.xmarker = pos
        self.butdown = 0
        self.ocursor = d.ocursor
        self.cursor = self.ocursor
        self.poscommand = None
        self.intpos = None
        self.moving = 0
        self.selected = 0
        self.entered = 0
        self.butdownselected = 0
        self.motion_id = None
        self.create()

def bind(self, sequence, function):
        tag = self.tag
        self.d.drawingarea.tag_bind(tag, sequence, function)
        if WM:
            self.xlabel.bind(sequence, function)
        else:
            self.d.xmarks.tag_bind(tag, sequence, function)

def coords(self, canx):
        self.d.drawingarea.coords(self.tag,
                                  canx, 0,
                                  canx, -int(self.d.boty))

self.d.xmarks.coords(self.tag, canx, 10)

def create(self):
        tag = self.tag
        text = self.name
        pos = 0

self.d.drawingarea.create_line(pos, 0, pos, 20-self.d.boty, stipple='gray12',
                                       width=4, tags=(tag,))
        if WM:
            label = self.xlabel = Label(
                self.d.xmarks, text=text, padx=2, pady=2, relief=RAISED)
            self.d.xmarks.create_window(pos, 0, window=label, tags=(tag,))
        else:
            self.d.xmarks.create_text(pos, 0, text=text, tags=(tag,))

self.bind('<Button-1>', self.event_button_1)
        self.bind('<ButtonRelease-1>', self.event_button_1_release)
        self.bind('<Enter>', self.event_enter)
        self.bind('<Leave>', self.event_leave)

self.d.drawingarea.bind('<Enter>', self.event_enter_movearea, add='+')
        self.d.drawingarea.bind(
            '<Button-1>', self.event_button_1_movearea, add='+')

def event_button_1(self, event):
        self.butdown = 1
        if self.selected:
            self.butdownselected = 1
            if self.moving:
                self.event_stop_move(event)
        else:
            self.butdownselected = 0

self.has_moved = 0
        self.event_selected(event)
        self.event_start_move(event)

def event_button_1_movearea(self, event):
        if not self.entered:
            self.event_deselected(event)

def event_button_1_release(self, event):
        self.butdown = 0
        if self.has_moved == self.butdownselected:
            if self.selected:
                if self.moving and not (self.disloy <= event.y_root < self.dishiy):
                    self.event_stop_move(None)
                    self.setcursor(self.ocursor)
            else:
                self.setcursor(self.ocursor)
            return
        self.event_deselected(event)

def event_deselected(self, event):
        if self.selected:
            self.selected = 0
            self.xlabel['relief'] = RAISED
            if self.moving:
                self.event_stop_move(event)

def event_enter(self, event):
        self.entered = 1
        if not self.moving:
            if self.selected:
                self.event_start_move(event)
            else:
                self.setcursor('hand2')

def event_enter_movearea(self, event):
        if self.selected and not self.moving:
            self.event_start_move(event)

def event_leave(self, event):
        self.entered = 0
        if not self.moving:
            self.setcursor(self.ocursor)
        elif not (self.fraloy <= event.y_root < self.frahiy):
            pass

def event_motion(self, event):
        self.has_moved = 1

inside = (self.fraloy <= event.y_root < self.frahiy)

if inside != self.inside:
            self.inside = inside
            if not inside:
                self.out_event = event
                self.event_stop_move(None)
                if self.butdown:
                    self.setcursor('circle')
                    self.d.bind_motion(self.event_motion_downout)
            else:
                self.in_event = event
                #self.delta += self.out_event.x_root - event.x_root
                self.event_start_move(event)
                return

if inside:
            self.moved(event)
            self.setxvars()

def event_motion_downout(self, event):
        # We don't get an enter while button is pressed down
        # Emulate an enter if we detect entering
        inside = (self.fraloy <= event.y_root < self.frahiy)
        if inside:
            self.d.unbind_motion(self.event_motion_downout)
            self.event_enter_movearea(event)

def event_selected(self, event):
        for m in self.d.marks:
            m.event_deselected(event)
        self.selected = 1
        self.xlabel['relief'] = SUNKEN

def event_start_move(self, event):
        self.moving = 1
        self.fralox = self.d.frame.winfo_rootx()
        self.frahix = self.fralox + self.d.frame.winfo_width()

self.fraloy = self.d.frame.winfo_rooty()
        self.frahiy = self.fraloy + self.d.frame.winfo_height()

self.dislox = self.d.drawingarea.winfo_rootx()
        self.dishix = self.dislox + self.d.drawingarea.winfo_width()
        self.disloy = self.d.drawingarea.winfo_rooty()
        self.dishiy = self.disloy + self.d.drawingarea.winfo_height()

self.down_event = event
        self.prev_event = event
        self.down_xmarker = self.xmarker
        self.down_xvfrac = self.d.drawingarea.xview()[0]
        self.inside = 1
        self.delta = 0
        self.lift()

self.motion_id = self.d.bind_motion(self.event_motion)
        self.moved(event)

def event_stop_move(self, event):
        assert self.moving
        self.moving = 0

self.d.unbind_motion(self.motion_id)
        if event is not None:
            self.moved(event)
            self.setxvars()

if self.entered and not self.selected:
            self.setcursor('hand2')
        else:
            self.setcursor(self.ocursor)

def lift(self):
        self.d.xmarks.tag_raise(self.tag)
        if WM:
            self.xlabel.lift()
        self.d.drawingarea.tag_raise(self.tag)

def move(self, sample):
        canx = self.d.canxscaled(sample)
        self.d.xview_pos(canx)
        self.coords(canx)
        self.xmarker = sample
        self.lift()

def moved(self, event):
        curx = event.x_root
        cury = event.y_root
        prevx = self.prev_event.x_root

if prevx > self.dishix and curx < self.dishix:
            prevx = self.dishix
        elif prevx < self.dislox and curx > self.dislox:
            prevx = self.dislox

markx = self.d.canxscaled(self.xmarker) - \
            self.d.drawingarea.canvasx(0) + self.dislox

dx = curx - prevx
        l = r = 1

if self.xmarker >= self.d.numstats-1:
            r = 0

if self.xmarker <= 0:
            l = 0

stop = 0

# Should we allow to move it back or not
        # if it is at an endpoint?
        # Here we don't move it at all, to make marker pos correspond
        # more closely with mouse position.

if ((r == 0 and curx > markx) or (l == 0 and curx < markx)):
            l = r = 0

if self.butdown:
            if curx > self.dishix:
                l = 0
            elif curx < self.dislox:
                r = 0
        else:
            if not (self.dislox <= curx < self.dishix and
                    self.disloy <= cury < self.dishiy):
                l = r = 0
                stop = 1

if l and r:
            self.setcursor('sb_h_double_arrow')
        elif l:
            self.setcursor('sb_left_arrow')
            if dx > 0:
                dx = 0
        elif r:
            self.setcursor('sb_right_arrow')
            if dx < 0:
                dx = 0
        else:
            self.setcursor('dot')
            dx = 0

self.prev_event = event

sample = self.d.limitx(self.xmarker + dx / self.d.xscale)
        canx = self.d.canxscaled(sample)
        self.d.xview_pos(canx)
        self.coords(canx)
        self.xmarker = sample
        if stop and self.moving:
            self.event_stop_move(None)

def set(self):
        canx = self.d.canxscaled(self.xmarker)
        self.coords(canx)
        self.lift()

def set_poscommand(self, command):
        self.poscommand = command
        self.intpos = None

def setcursor(self, cursor):
        if cursor != self.cursor:
            self.xlabel['cursor'] = cursor
            self.cursor = cursor
        self.d.setcursor(cursor)

def setxvars(self):
        if self.poscommand:
            intpos = int(round(self.xmarker))
            if intpos != self.intpos:
                self.intpos = intpos
                self.poscommand(intpos)

class Display:
    orgwidth = 300
    orgheight = 300
    minwidth = 30
    minheight = 30

def __init__(self, master,
                 scale_table,
                 numkindrows,
                 getkindcolor,
                 xrange=100,
                 yrange=100,
                 xgrid=False,
                 ygrid=False,
                 graphtype='Bars',
                 statype='Size',
                 ):
        self.master = master
        self.scale_table = scale_table
        self.numkindrows = numkindrows
        self.getkindcolor = getkindcolor
        self.xrange = xrange
        self.yrange = yrange
        self.xgrid = xgrid
        self.ygrid = ygrid
        self.var_xgrid = BooleanVar()
        self.var_xgrid.set(xgrid)
        self.var_ygrid = BooleanVar()
        self.var_ygrid.set(ygrid)
        self.graphtype = graphtype
        self.statype = statype

self.numstats = 0
        self.ymaxs = []
        self.ymins = []
        self.ymax = 1

# To get around problems with dynamic unbinding / unbinding of motion,
        # I handle it myself. in the bind_motion method using the following.
        self.bound_motions = {}
        self.event_motion_id = None
        #

self.frame = frame = Frame(master,
                                   borderwidth=3,
                                   relief=SUNKEN,
                                   # relief=GROOVE,
                                   # background='green'
                                   )
        #self.frame = frame = Frame(master,background='green')

bordercolor = '#ccc'
        screencolor = '#e0e0e0'
        xscrollincrement = 1
        frame = Frame(self.frame)
        frame.grid(row=0, column=0)
        #move = Frame(frame, height=10,width=10,background='red', relief=RAISED)
        #move = Button(self.frame, height=10,width=10,background='red')
        self.drawingarea = C = Canvas(frame,
                                      width=self.orgwidth,
                                      height=self.orgheight,
                                      xscrollincrement=xscrollincrement,
                                      # background='black',
                                      background=screencolor,
                                      bd=0,
                                      xscrollcommand=self.xscrollbar_set,
                                      # confine=False,
                                      )

#self.yctrlframe = Frame(frame, borderwidth=2,relief=GROOVE)
        self.yscrollbar = Scrollbar(frame, orient=VERTICAL, width=10)
        # self.yscrollbar['command']=self.drawingarea.yview
        #self.drawingarea['yscrollcommand'] = self.yscrollbar_set
        # self.yscrollbar.pack(side=RIGHT,fill=Y)
        #self.yctrlframe.grid(row = 0, column = 0,sticky=N+S,padx=3,pady=3)

self.xaxis = Canvas(frame,
                            width=C['width'],
                            height=20,
                            xscrollincrement=xscrollincrement,
                            bd=0,
                            background=bordercolor,
                            #xscrollcommand = self.xscrollbar_set
                            # confine=False,
                            )
        self.xmarks = Canvas(frame,
                             width=C['width'],
                             height=20,
                             xscrollincrement=xscrollincrement,
                             bd=0,
                             background=bordercolor,
                             #xscrollcommand = self.xscrollbar_set
                             # confine=False,
                             )
        self.yaxis = Canvas(frame, height=C['height'], width=50,
                            bd=0,
                            background=bordercolor,
                            )

self.xscrollbar = Scrollbar(frame, orient=HORIZONTAL,
                                    command=self.drawingarea_xview,
                                    width=12,
                                    background=bordercolor,

)

xy = Canvas(frame, width=50, height=20, bd=0,
                    background=bordercolor,
                    )

var_yrange = SizeVar()
        self.var_yrange = var_yrange

row = 0

Label(frame,
              textvar=var_yrange,
              bd=0,
              relief=FLAT,
              background=bordercolor).grid(
                  row=row,
                  column=0,
                  sticky=W+E+N+S)

self.xscrollbar.grid(row=row, column=1, sticky=E+W)

row += 1

self.yunit = Label(frame,
                           text='Bytes',
                           bd=0,
                           relief=FLAT,
                           background=bordercolor)
        self.yunit.grid(
            row=row,
            column=0,
            sticky=W+E+N+S)

self.xmarks.grid(row=row, column=1, sticky=W+E+N)

row += 1

self.yaxis.grid(row=row, column=0)
        C.grid(row=row, column=1, sticky=W+E)

row += 1

xy.grid(row=row, column=0)
        self.xaxis.grid(row=row, column=1, sticky=W+E+N)

self.botx = float(C['width'])
        self.boty = float(C['height'])
        self.chdim = self.getchdim()
        self.canx0 = 0
        self.tmax = 0
        self.xscale = self.botx / self.xrange
        self.yscale = self.boty / self.yrange
        self.xi0 = None

xy.create_line(0, 2, 44, 2)
        xy.create_line(49, 6, 49, 22)
        xy.create_text(25, 14, text='Sample')

self.setscrollregion()

self.ocursor = self.drawingarea['cursor']
        self.cursor = self.ocursor

self.marks = []

def bind_motion(self, function):
        if self.event_motion_id == None:
            self.event_motion_id = self.frame.bind_all(
                '<Motion>', self.event_motion, add='+')
        self.bound_motions[function] = self.bound_motions.get(function, 0) + 1
        return function

def event_motion(self, event):
        for f in list(self.bound_motions.keys()):
            f(event)

def unbind_motion(self, funcid):
        n = self.bound_motions[funcid] - 1
        if n == 0:
            del self.bound_motions[funcid]
        else:
            self.bound_motions[funcid] = n

def new_xmarker(self, name=None, pos=0):
        tag = 'M%d' % len(self.marks)
        if name is None:
            name = tag
        m = Marker(self, tag, name, pos)
        self.marks.append(m)
        return m

def canxscaled(self, x):
        return x * self.xscale + self.canx0

def canyscaled(self, y):
        return - y * self.yscale

def cmd_xgrid(self):
        self.xgrid = self.var_xgrid.get()
        self.drawxaxis()

def cmd_ygrid(self):
        self.ygrid = self.var_ygrid.get()
        self.drawyaxis()

def cmd_yrange_auto(self):
        self.ymax = None
        self.yrange_auto()

def limitx(self, x):
        lo = 0
        hi = max(0, self.numstats-1)
        if x < lo:
            return lo
        if x > hi:
            return hi
        return x

def resize(self, dx, dy):
        x = self.botx + dx
        y = self.boty + dy
        if x < self.minwidth:
            x = self.minwidth
            dx = x - self.botx
        if y < self.minheight:
            y = self.minheight
            dy = y - self.boty

xv = self.drawingarea.xview()
        yv = self.drawingarea.yview()

self.drawingarea.configure(width=x, height=y)
        self.xaxis.configure(width=x)
        self.xmarks.configure(width=x)
        self.yaxis.configure(height=y)

xscale = float(x) / self.xrange
        yscale = float(y) / self.yrange

xscaleorg = self.drawingarea.canvasx(0)
        yscaleorg = 0

xq = xscale / self.xscale
        yq = yscale / self.yscale

self.drawingarea.scale("all", xscaleorg, yscaleorg, xq, yq)
        #self.drawingarea.scale("barsep",xscaleorg, yscaleorg, xq, yq)
        #self.drawingarea.scale("xmarker",xscaleorg, yscaleorg, xq, yq)

self.canx0 = xscaleorg + (self.canx0 - xscaleorg) * xq

self.botx = x
        self.boty = y
        self.xscale = xscale
        self.yscale = yscale

self.drawxaxis()
        self.drawyaxis()

self.setscrollregion()

# If the size changed much, the canvas may scroll though it shouldn't.
        # Notes 11 and 26 Oct 2005 .
        # I save the current scroll position.
        # The caller has to call the .moveback() method some time later.
        self.wantedpos = xv[0]

return dx, dy

def moveback(self):
        self.frame.update_idletasks()
        self.xview(MOVETO, self.wantedpos)

def draw():
        self.drawxaxis()
        self.drawyaxis()

def draw_stat(self, idx, stat):
        graphtype = self.graphtype
        statype = self.statype

rows = stat.get_rows_n_and_other(self.numkindrows, statype)
        if statype == 'Size':
            kindval = dict([(r.name, r.size) for r in rows])
        else:
            kindval = dict([(r.name, r.count) for r in rows])
        order = [r.name for r in rows]

order.reverse()

lastkindval = self.lastkindval
        self.lastkindval = kindval

C = self.drawingarea

yscale = self.yscale
        xscale = self.xscale

x0 = idx * xscale - 0.5 * xscale + self.canx0
        x1 = x0 + xscale
        ymax = 0
        ymin = 0

y = 0

bw = 0.05*xscale

ocolor = None
        for k in order:
            dy = kindval.get(k, 0)
            if not dy:
                continue
            color = self.getkindcolor(k)

if graphtype == 'Bars':
                line = C.create_rectangle(x0+bw, -y*yscale,
                                          x1-bw, -(y+dy)*yscale,
                                          fill=color,
                                          outline=color,
                                          width=0,
                                          tags=("a",))
                if color == ocolor:
                    C.create_line(x0, -(y)*yscale,
                                  x1, -(y)*yscale,
                                  fill='black',
                                  tags=('barsep',))
                ocolor = color
                y += dy
            elif graphtype == 'Lines':
                if dy > ymax:
                    ymax = dy
                elif dy < ymin:
                    ymin = dy
                y0 = lastkindval.get(k)
                if y0 is None:
                    y0 = dy
                    x00 = x0
                else:
                    x00 = x0 - 0.4 * xscale
                    C.create_line(x00,  - y0 * yscale,
                                  x1 - 0.6 * xscale,  - dy * yscale,
                                  fill=color,
                                  tags=('a',))

C.create_line(x1 - 0.6 * xscale,  - dy * yscale,
                              x1 - 0.4 * xscale,  - dy * yscale,
                              fill=color,
                              width=4,
                              tags=('a',))

if graphtype == 'Bars':
            if y > ymax:
                ymax = y
            elif y < ymin:
                ymin = y

assert idx == len(self.ymaxs) == len(self.ymins)
        self.ymaxs.append(ymax)
        self.ymins.append(ymin)

if idx > self.tmax:
            self.tmax = idx

def drawingarea_xview(self, cmd, what, unit=None):
        if cmd == 'scroll' and unit == 'units':
            what = int(max(2, self.xscale)*int(what))

self.xview(cmd, what, unit)

def setcursor(self, cursor):
        if cursor != self.cursor:
            self.drawingarea['cursor'] = cursor
            self.master['cursor'] = cursor
            self.cursor = cursor

def xmarkers_set(self):
        for m in self.marks:
            m.set()

def xview(self, *args):
        if not args:
            return self.drawingarea.xview()
        self.drawingarea.xview(*args)
        self.xaxis.xview(*args)
        self.xmarks.xview(*args)

def xview_moveto(self, fraction):
        self.xview(MOVETO, fraction)

def xview_pos(self, pos, fraction=None, leftmargin=5, rightmargin=5):
        # Scroll canvas view, if necessary, so that something
        # (eg an x marker) at canvas position pos will be visible
        # with minimum specified margin at left and right.
        # Scroll relative to fraction; default is current xview position.

if fraction is None:
            fraction = self.xview()[0]

x1, y1, x2, y2 = self.scrollregion

cc = x1 + fraction * (x2 - x1)

xm = pos - cc

lo = leftmargin
        hi = self.botx - rightmargin

if xm < lo:
            dx = xm - lo
            xm = lo
        elif xm >= hi:
            dx = (xm - hi)
            xm = hi
        else:
            dx = 0

r = fraction + dx / float(x2 - x1)
        self.xview_moveto(r)

def drawxaxis(self):
        scale_table = self.scale_table
        self.xaxis.delete('all')
        self.drawingarea.delete('xgrid')
        x1, y1, x2, y2 = self.scrollregion

chdx, chdy = self.chdim

i = 0
        while (scale_table[i] * self.xscale <
               min(5, len(str(scale_table[i] * self.tmax))) * chdx):
            i += 1
        self.xstep = scale_table[i]

divisuf = (
            (1000000000000, '%dT'),
            (1000000000, '%dG'),
            (1000000,  '%dM'),
            (1000,  '%dK'),
            (1, '%d')
        )

for divi, form in divisuf:
            if self.xstep >= divi:
                break

self.xdivi = divi
        self.xform = form

self.xi0 = 0
        self.updatexaxis()

def updatexaxis(self):

chdx, chdy = self.chdim
        step = self.xstep

gridon = self.xgrid

for i in range(self.xi0, self.tmax+step, step):
            x = self.canx0 + i*self.xscale
            self.xaxis.create_line(x, 0, x, 4)
            if gridon:
                self.drawingarea.create_line(x, 0, x, -self.boty,
                                             tags=('xgrid',), width=2, stipple="gray25")
            text = self.xform % (i / self.xdivi)
            self.xaxis.create_text(x, chdy,  text=text)

self.xaxis.create_line(self.canx0 + self.xi0 *
                               self.xscale, 1, x+self.xscale, 1)

self.xi0 = i
        self.xmarkers_set()

def drawyaxis(self):

gridon = self.ygrid

self.yaxis.delete('all')
        self.drawingarea.delete('ygrid')

chdx, chdy = self.getchdim()

width = int(self.yaxis['width'])
        i = 0
        maxval = self.yrange

while (self.scale_table[i] * self.yscale < 1.5 * chdy):
            i += 1
        step = self.scale_table[i]

divisuf = (
            (1000000000000, '%4dT'),
            (1000000000, '%4dG'),
            (1000000,  '%4dM'),
            (1000,  '%4dK'),
            (1, '%5d')
        )

for divi, form in divisuf:
            if step >= divi:
                break

for i in range(0, maxval+step, step):
            y = - i*self.yscale
            self.yaxis.create_line(width-3, y, width-1, y)
            if gridon:
                self.drawingarea.create_line(self.scrollregion[0], y,
                                             self.scrollregion[2], y,
                                             stipple="gray25",
                                             tags=('ygrid',))
            text = form % (i / divi)
            self.yaxis.create_text(chdx*2.5, y-0.5*chdy,  text=text)

#self.yaxis.create_text(chdx*2.5, 0.5*chdy, text='bytes')

self.yaxis.create_line(width-1, 0, width-1, -self.boty)
        self.xmarkers_set()

def getchdim(self):
        ch = self.xaxis.create_text(0, 0, text='0')
        x1, y1, x2, y2 = self.xaxis.bbox(ch)
        self.xaxis.delete(ch)
        chdx = abs(x2 - x1)
        chdy = abs(y2 - y1)

return chdx, chdy

def load_stats(self, stats):

ocursor = self.frame.winfo_toplevel()['cursor']
        try:
            self.frame.winfo_toplevel()['cursor'] = 'watch'
            self.frame.update()

self.numstats = len(stats)

self.lastkindval = {}
            self.tmax = 0
            self.ymax = None
            self.ymaxs = []
            self.ymins = []

C = self.drawingarea

C.delete('barsep')
            C.delete('a')

for (i, st) in enumerate(stats):
                self.draw_stat(i, st)

try:
                self.drawingarea.tag_raise('barsep', 'a')
            except TclError:
                pass  # May be 'tagOrId "a" doesn't match any items' if empty!

self.drawxaxis()
            self.drawyaxis()
            self.xmarkers_set()
            self.yrange_auto()
        finally:
            self.frame.winfo_toplevel()['cursor'] = ocursor

def add_stats(self, stats):
        for (i, st) in enumerate(stats):
            self.draw_stat(i+self.numstats, st)
        self.numstats += len(stats)
        self.updatexaxis()
        self.setscrollregion()

def setxgrid(self, grid):
        self.xgrid = grid
        self.drawxaxis()

def setygrid(self, grid):
        self.ygrid = grid
        self.drawyaxis()

def setgraphtype(self, gmode, stats):
        graphtype, statype = gmode.split(' ')
        if graphtype != self.graphtype or statype != self.statype:
            self.graphtype = graphtype
            self.statype = statype
            if statype == 'Size':
                self.yunit['text'] = 'Bytes'
            elif statype == 'Count':
                self.yunit['text'] = 'Objects'
            else:
                raise ValueError
            self.load_stats(stats)

def setscrollregion(self):
        C = self.drawingarea
        botx = self.botx
        x1 = self.canx0
        x2 = self.tmax * self.xscale + self.canx0
        x1extra = botx / 2 + 2  # max(5, self.xscale*0.5)
        x2extra = botx / 2 + 2  # max(5, self.xscale*0.5)

x1 -= x1extra
        x2 += x2extra

y1 = 1-self.boty
        y2 = 1

self.scrollregion = (x1, y1, x2, y2)
        C.configure(scrollregion=self.scrollregion)

self.xaxis.configure(scrollregion=(x1, 0, x2, 10))
        self.xmarks.configure(scrollregion=(x1, 0, x2, 20))
        self.yaxis.configure(scrollregion=(0, y1, 20, y2))

self.drawingarea.yview(MOVETO, 0.0)

def setxrange(self, xrange):
        dxrange = self.xrange / float(xrange)
        self.xrange = xrange
        xscaleorg = self.drawingarea.canvasx(self.botx/2)
        self.drawingarea.scale("a", xscaleorg, 0, dxrange, 1.0)
        self.drawingarea.scale("barsep", xscaleorg, 0, dxrange, 1.0)
        self.canx0 = xscaleorg + (self.canx0 - xscaleorg) * dxrange
        self.xscale = self.botx / float(self.xrange)
        self.setxscrollincrement(max(2, self.xscale))
        self.drawxaxis()
        self.setscrollregion()

def setxscrollincrement(self, dx):
        return
        self.drawingarea.configure(xscrollincrement=dx)
        self.xaxis.configure(xscrollincrement=dx)
        self.xmarks.configure(xscrollincrement=dx)

def setyrange(self, yrange):

dyrange = float(self.yrange) / yrange
        self.yrange = yrange
        self.var_yrange.set(yrange)

self.drawingarea.scale("a", 0, 0, 1.0, dyrange)
        self.drawingarea.scale("barsep", 0, 0, 1.0, dyrange)
        self.yscale = float(self.boty) / self.yrange
        self.drawingarea.yview(MOVETO, 0.0)
        self.drawyaxis()

def xscrollbar_set(self, first, last):
        self.xscrollbar.set(first, last)
        self.yrange_auto()

def yrange_auto(self, force=0):
        if force or self.ycontrol.autovar.get():
            lo = max(0,
                     int(0.5+(self.drawingarea.canvasx(0) - self.canx0) / self.xscale))
            hi = min(len(self.ymaxs),
                     int(1.5+(self.drawingarea.canvasx(self.botx) - self.canx0) / self.xscale))
            if lo == hi:
                ymax = 1
            else:
                ymax = max(self.ymaxs[lo:hi])
            if ymax != self.ymax:
                self.ymax = ymax
                self.ycontrol.fit(ymax)

class MarkerControl:
    def __init__(self, master,
                 marker,
                 setcommand=lambda: 0
                 ):
        self.sample = 0
        self.numsamples = 0
        self.setcommand = setcommand
        self.marker = marker
        self.name = marker.name
        sf = self.frame = Frame(master, borderwidth=2, relief=GROOVE)
        self.samplevar = SizeVar()
        Label(sf, text='%s sample' % marker.name).grid(row=0, column=0)
        Label(sf,
              textvariable=self.samplevar,
              font=('terminal', '16', 'bold'),
              bg='black', fg='yellow'
              ).grid(row=1, column=0, padx=3, pady=3)
        ClickButton(sf, text='-',
                    pady=0, padx=5,
                    command=lambda: self.changesample(-1)).grid(row=0, column=1, sticky=E)
        ClickButton(sf, text='+',
                    pady=0, padx=5,
                    command=lambda: self.changesample(1)).grid(row=0, column=2, sticky=W)
        self.trackingvar = BooleanVar()
        self.trackbutton = Checkbutton(
            sf, text='Track',
            padx=5,

variable=self.trackingvar,
            relief=RAISED,
            command=self.settracking,
            indicatoron=1,
        )
        self.trackbutton.grid(row=1, column=1, columnspan=2)

def changesample(self, d):
        sample = self.sample + d
        if 0 <= sample < self.numsamples:
            self.setmarker(sample)

def setmarker(self, sample):
        self.marker.move(sample)
        self.setsample(sample)

def setnumsamples(self, num):
        self.numsamples = num
        if self.trackingvar.get() or self.sample >= self.numsamples:
            self.setmarker(max(0, self.numsamples-1))

def setsample(self, sample):
        self.sample = sample
        self.samplevar.set(sample)
        self.setcommand()

def settracking(self, tracking=None):
        if tracking is not None:
            self.trackingvar.set(tracking)
        else:
            tracking = self.trackingvar.get()
        if tracking:
            self.setmarker(max(0, self.numsamples-1))

class Window:
    def __init__(self, app, frame, windowmenu=None):
        self.app = app
        self.frame = frame
        self.windowmenu = windowmenu
        self.wtitle = frame.title()
        self._is_destroyed = 0
        # Binding to <destroy> didnt work well:
        #   frame.bind('<Destroy>', self.event_destroy, add='+')
        # I give up. I modify .destroy of frame argument instead.
        self.old_destroy = frame.destroy
        frame.destroy = self.new_destroy

def new_destroy(self):
        if self._is_destroyed:
            return
        self._is_destroyed = 1
        self.app.del_window(self)
        try:
            self.old_destroy()
        except TclError:
            # This may happen at closing last window
            # because exit destroys the root when it sees all windows were closed.
            # So I ignore it.
            pass

def title(self, title):
        self.frame.title(title)
        self.frame.iconname(title)
        self.wtitle = title
        self.app.chg_window(self)

def wakeup(self):
        frame = self.frame
        try:
            if frame.wm_state() == "iconic":
                frame.wm_deiconify()
            frame.tkraise()
            # I don't think I want .focus_set: it behaved strange in X at least.
            # frame.focus_set()
        except TclError:
            # This can happen when the window menu was torn off.
            # Simply ignore it.
            pass

class WindowMenu:
    def __init__(self, frame, variable):
        self.button = Menubutton(frame, text='Window')
        self.menu = Menu(self.button)
        self.button['menu'] = self.menu
        self.variable = variable
        self.wmap = {}

def add_window(self, window):
        self.menu.add_radiobutton(
            command=window.wakeup,
            label='%d %s' % (window.wid, window.wtitle),
            value=window.wid,
            variable=self.variable)
        self.wmap[window.wid] = self.menu.index(END)

def chg_window(self, window):
        self.menu.delete(self.wmap[window.wid])
        self.menu.insert_radiobutton(
            self.wmap[window.wid],
            command=window.wakeup,
            label='%d %s' % (window.wid, window.wtitle),
            value=window.wid,
            variable=self.variable)

def del_window(self, window):
        idx = self.wmap[window.wid]
        del self.wmap[window.wid]
        try:
            self.menu.delete(idx)
        except TclError:
            # This can happen if the menu was destroyed before its contents.
            # Simply ignore it.
            pass
        for wid in list(self.wmap.keys()):
            if self.wmap[wid] > idx:
                self.wmap[wid] -= 1

class ProfileApp:
    def __init__(self, mod):
        self.mod = mod
        root = Tk()
        self.root = root
        root.withdraw()
        self.windows = {}
        self.windowmenus = {}
        self.var_window = IntVar(root)

def add_window(self, window):
        window.wid = max([0]+list(self.windows.keys()))+1
        self.windows[window.wid] = window
        wm = getattr(window, 'windowmenu', None)
        if wm:
            self.windowmenus[window.wid] = wm
            for w in list(self.windows.values()):
                if w is not window:
                    wm.add_window(w)
        for wm in list(self.windowmenus.values()):
            wm.add_window(window)
        self.var_window.set(window.wid)
        window.frame.bind('<FocusIn>',
                          lambda event: self.var_window.set(window.wid), add='+')
        window.frame.bind('<Deactivate>',
                          lambda event: self.var_window.set(0), add='+')

def add_window_frame(self, frame, windowmenu=None):
        w = Window(self, frame, windowmenu)
        self.add_window(w)
        return w

def chg_window(self, window):
        for wm in list(self.windowmenus.values()):
            wm.chg_window(window)

def del_window(self, window):
        wid = window.wid
        if getattr(window, 'windowmenu', None):
            del self.windowmenus[wid]
        del self.windows[wid]
        for wm in list(self.windowmenus.values()):
            wm.del_window(window)
        if not self.windows:
            self.exit()

def exit(self):
        try:
            self.root.destroy()
        except TclError:
            pass
        self.root.quit()

def mainloop(self):
        return self.root.mainloop()

def new_profile_browser(self, filename):
        return ProfileBrowser(self, filename)

class PaneDiv:
    def __init__(self, master, movecommand):
        self.frame = frame = Frame(master)
        self.movecommand = movecommand

self.butsize = bs = 6
        bc = self.butcent = bs / 2 + 3
        h = 10
        self.top = Canvas(
            frame,
            width=10,
            height=h,
        )

self.top.create_line(
            bc, 0, bc, h, fill='#808080', width=1)
        self.top.create_line(
            bc+1, 0, bc+1, h, fill='white', width=1)

self.rsbut = Canvas(
            frame,
            cursor='crosshair',
            width=self.butsize,
            height=self.butsize,
            relief=RAISED,
            bd=2
        )

self.bot = Canvas(
            frame,
            width=10,
            height=300,
            bd=0
        )

self.top.grid(row=0, column=0, sticky=N)
        self.rsbut.grid(row=1, column=0, sticky=N)
        self.bot.grid(row=2, column=0, sticky=N)

self.rsbut.bind('<Button-1>', self.but_down)
        self.rsbut.bind('<ButtonRelease-1>', self.but_up)

def but_down(self, event):
        self.down_event = event
        self.rsbut.configure(relief=SUNKEN)

def but_up(self, event):
        self.rsbut.configure(relief=RAISED)
        dx = event.x - self.down_event.x
        self.movecommand(dx)

def setheight(self, height):
        h = height - 18
        self.bot['height'] = h

bc = self.butcent

self.bot.create_line(
            bc, 0, bc, h, fill='#808080', width=1)
        self.bot.create_line(
            bc+1, 0, bc+1, h, fill='white', width=1)

class TableFrame:
    def __init__(self, graph, master, numkindrows, samplevar):
        self.graph = graph
        self.mod = graph.mod
        frame = self.frame = Frame(master, borderwidth=2, relief=GROOVE)
        row = 0
        self.marktime = StringVar()
        self.totsizevar = SizeVar()
        self.sampler = StringVar()
        self.sampler.set('R')

fr = Frame(frame)  # For header
        om = OptionMenu(fr, self.sampler, 'R', 'L', 'R-L')
        om.grid(row=0, column=0, sticky=W)
        Label(fr, text='Sample').grid(row=0, column=1, sticky=W)
        Label(fr, textvariable=samplevar, background='black', foreground='yellow',
              ).grid(row=0, column=2, sticky=W, pady=3)
        Label(fr, text='at').grid(row=0, column=3, sticky=W)
        Label(fr, textvariable=self.marktime).grid(
            row=0, column=4, sticky=W)
        Label(fr, text='Total size = ').grid(
            row=1, column=0, columnspan=3, sticky=W)
        Label(fr, textvar=self.totsizevar).grid(
            row=1, column=3, columnspan=2, sticky=W)
        fr.grid(row=row, column=0, sticky=W)
        row += 1

orow = row

tb = Frame(frame)
        row = 0

Label(tb, text="").grid(row=row, column=0)
        Label(tb, text="R", ).grid(row=row, column=1, sticky=E)
        Label(tb, text="%R").grid(row=row, column=2, sticky=E)
        Label(tb, text="R-L", ).grid(row=row, column=3, sticky=E)
        Label(tb, text="%L").grid(row=row, column=4, sticky=E)
        Label(tb, text="Kind").grid(row=row, column=5, sticky=W)

row += 1
        self.profrows = []
        self.totrow = ProfileRow(tb, row)
        self.profrows.append(self.totrow)
        row += 1

for i in range(numkindrows+1):
            profrow = ProfileRow(tb, row)
            self.profrows.append(profrow)
            row += 1

row = orow
        tb.grid(row=row, column=0, sticky=W)

# for next..
        row += 1

self.totresize = 0
        self.kindwidth = ProfileRow.kindwidth

def resize(self, dx, dy):
        dx = int(dx)
        self.totresize += dx
        charresize, extra = divmod(self.totresize, 7)
        newwidth = ProfileRow.kindwidth + charresize
        oldwidth = self.profrows[0].kind['width']
        if newwidth < 10:
            newwidth = 10
            dx = (newwidth - oldwidth) * 7 + extra
        for pr in self.profrows:
            pr.kind['width'] = newwidth
            pr.kindwidth = newwidth
            pr.kind['padx'] = extra / 2
            import textwrap
            kindtext = textwrap.fill(pr.kindtext, width=pr.kindwidth)
            pr.set_kind(pr.kindtext)

return dx, dy

def update(self, lsamp, rsamp):

self.marktime.set(self.mod.time.asctime(
            self.mod.time.localtime(rsamp.stat.timemade)))

return

for pr in self.profrows:
            pr.clear()

rdiv = float(rsamp.stat.size)
        ldiv = float(lsamp.stat.size)

self.totrow.set_color_size_percent_kind(
            None,
            rsamp.stat.size,
            100.0,
            rsamp.stat.size - lsamp.stat.size,
            (rsamp.stat.size - lsamp.stat.size) * 100.0 / ldiv,
            '<Total>'
        )

for i, r in enumerate(rsamp.rows):
            l = lsamp.kindrows[r.name]
            self.profrows[i+1].set_color_size_percent_kind(
                self.graph.getkindcolor(r.name),
                r.size,
                r.size * 100.0 / rdiv,
                r.size - l.size,
                (r.size - l.size) * 100.0 / ldiv,
                r.name)

class ColSpec:
    def __init__(self, tf, header, width, pos, render, idx=()):
        self.tf = tf
        self.header = header
        self.name = header
        self.width = width
        self.pos = pos
        self.render = render
        self.idx = idx

def align(self, text):
        sp = ' '*(self.width - len(text))
        if self.pos == LEFT:
            text = text + sp
        elif self.pos == RIGHT:
            text = sp[:-1] + text + ' '
        else:
            assert 0
        assert len(text) == self.width
        return text

class TableFrame:
    def __init__(self, graph, master):
        self.graph = graph
        self.mod = graph.mod

frame = self.frame = Frame(
            master,
            borderwidth=3,
            relief=SUNKEN
        )

self.colspecs = {}
        self.colwidths = []

def defcol(names, width, pos, put, idxfunc=lambda x: ()):
            if callable(put):
                put = [put]*len(names)
            self.colwidths.append(width)
            for name, put in zip(names, put):
                spec = ColSpec(self, name, width, pos, put, idxfunc(name))
                self.colspecs[name] = spec

defcol(('A', 'B'), 2, LEFT, self.putcolor, lambda x: x)
        defcol(('Size', 'Count'), 7, RIGHT, [self.putsize, self.putcount])
        defcol(('%A:Tot', '%B:Tot'), 7, RIGHT,
               self.putpercent, lambda name: name[1])
        defcol(('B-A', 'A-B', 'Cumul'), 7, RIGHT, [self.putdiff, self.putdiff, self.putcumul],
               lambda name: [(), name.split('-')]['-' in name])
        defcol(('%A:Tot', '%B:Tot'), 7, RIGHT,
               self.putpercent, lambda name: name[1])
        defcol(('Kind',), 20, LEFT, self.putkind)

width = 0
        for w in self.colwidths:
            width += w
        self.totxresize = 0
        self.totyresize = 0
        self.kindcol = self.colspecs['Kind']
        self.orgkindwidth = self.kindcol.width
        self.widthbeforekind = width - self.orgkindwidth
        self.minkindwidth = 10
        self.mintextheight = 2
        width += 1
        self.width = self.orgwidth = width

wrap = NONE
        cursor = master['cursor']
        relief = FLAT
        self.minpadx = 3
        self.tothead = Text(
            frame,
            width=width,
            wrap=wrap,
            background='#ccc',
            height=2,
            padx=self.minpadx,
            relief=relief,
            cursor=cursor,
        )

self.rowhead = Text(
            frame,
            width=width,
            wrap=wrap,
            background='#ccc',
            height=1,
            padx=self.minpadx,
            relief=relief,
            cursor=cursor,
        )

self.tsframe = Frame(frame)

self.textminpady = 2
        self.text = Text(
            self.tsframe,
            width=width,
            wrap=wrap,
            height=21,
            background='#e0e0e0',
            relief=relief,
            takefocus=0,
            cursor=cursor,
            padx=self.minpadx,
            pady=self.textminpady,
        )

self.scrollbar = Scrollbar(
            self.tsframe,
            width=10,
            orient=VERTICAL,
            command=self.text.yview
        )
        self.scrollbar_totwidth = int(
            self.scrollbar['width']) + 6  # width + padding

self.uses_scrollbar = 0
        self.auto_scrollbar = 1

self.orgtextheight = int(self.text['height'])

padx = 0
        pady = 0
        self.tothead.pack(anchor=N+W, padx=padx, pady=pady)
        self.rowhead.pack(anchor=N+W, padx=padx, pady=pady)
        self.text.pack(side=LEFT, anchor=N+W, padx=padx, pady=pady)
        self.tsframe.pack(anchor=N+W, padx=padx, pady=pady)

def setchdim(self):
        self.text.update()
        self.chdx = float(self.text.winfo_width()) / self.width
        self.chdy = float(self.text.winfo_height()) / self.orgtextheight
        self.chdx = int(round(self.chdx))
        self.chdy = int(round(self.chdy))
        self.pixwidth = self.width * self.chdx
        self.pixheight = self.width * self.chdy

def putcolor(self, col):
        if self.colorow.name == '<Total>':
            text = col.align(' ')
            color = '#e0e0e0'
        else:
            color = self.graph.getkindcolor(self.colorow.name),
            text = col.align('@')
        self.text.insert('end', text, (color,))
        self.text.tag_config(color, foreground=color, background='#e0e0e0',
                             font=('terminal', '12', 'bold'),)

def putcount(self, col):
        self.valmode = 'Count'
        count = self.colorow.count
        self.cumulval += count
        self.putval(col, count)

def putsize(self, col):
        self.valmode = 'Size'
        size = self.colorow.size
        self.cumulval += size
        self.putval(col, size)

def putval(self, col, val):
        self.curval = val
        self.ap(col.align(sizestring(val)))

def putpercent(self, col):
        a = self.statbyname[col.idx]

if self.valmode == 'Count':
            ref = a.count
        elif self.valmode == 'Size':
            ref = a.size

if ref:
            ps = percentstring(self.curval * 100.0 / ref)
        else:
            ps = '---'
        self.ap(col.align(ps))

def putdiff(self, col):

a, b = self.rowbyname[col.idx[0]], self.rowbyname[col.idx[1]]
        if self.valmode == 'Count':
            a, b = a.count, b.count
        elif self.valmode == 'Size':
            a, b = a.size, b.size

self.putval(col, a - b)

def putcumul(self, col):
        self.putval(col, self.cumulval)

def putkind(self, col):
        # Must be last!
        import textwrap
        wraplines = textwrap.wrap(self.colorow.name, width=col.width)
        self.ap(col.align(wraplines[0]))
        if len(wraplines) > 1:
            initial = '\n'+' '*(self.widthbeforekind)
            for line in wraplines[1:]:
                self.ap(initial+col.align(line))

def setmode(self, mode, numkindrows):
        self.mode = mode
        self.numkindrows = numkindrows
        self.mcontrols = self.graph.mcontrolbyname
        self.stats = self.graph.stats
        self.cols = [self.colspecs[x.strip()]
                     for x in mode.split(' ') if x.strip()]
        self.controlnames = {}
        name = self.cols[0].idx
        self.colorcontrol = self.mcontrols[name]
        self.controlnames[name] = 1
        self.controls = [self.colorcontrol]
        self.lastidxs = [None]
        for i, co in enumerate(self.cols):
            idx = co.idx
            if not isinstance(idx, (tuple, list)):
                idx = (idx,)
            for idx in idx:
                if idx not in self.controlnames:
                    self.controls.append(self.mcontrols[idx])
                    self.controlnames[idx] = 1
                    self.lastidxs.append(None)

def setscrollbar(self, sb):
        if sb == self.uses_scrollbar:
            return
        self.uses_scrollbar = sb
        w = self.scrollbar_totwidth
        if sb:
            self.resize(-w, 0, setscrollbar=0)
            self.scrollbar.pack(side=LEFT, fill=Y)
            self.text['yscrollcommand'] = self.scrollbar.set
        else:
            self.resize(w, 0, setscrollbar=0)
            self.scrollbar.pack_forget()
            self.text['yscrollcommand'] = None

def update_simple(self, lsamp, rsamp):
        t = self.text
        t.delete('1.0', '100.0')
        t.insert('1.0', str(rsamp.stat))

def update(self, force=0, setscrollbar=1):

stats = self.stats

idxs = [max(0, min(control.sample, len(stats)-1))
                for control in self.controls]
        if (idxs == self.lastidxs) and not force:
            return

self.lastidxs = idxs

self.text['state'] = self.tothead['state'] = self.rowhead['state'] = NORMAL

self.text.delete('1.0', END)
        self.tothead.delete('1.0', END)
        self.rowhead.delete('1.0', END)

if not stats:
            self.tothead.insert('end', '-- No Sample --')
            self.text['state'] = self.tothead['state'] = self.rowhead['state'] = DISABLED
            return

self.statbyname = {}
        statbyidx = []
        for i, control in enumerate(self.controls):
            stat = stats[idxs[i]]
            statbyidx.append(stat)
            self.statbyname[control.name] = stat

samps = self.samps = [
            Sample(self.mod, statbyidx[0], self.controls[0].marker.name, idxs[0],
                   numkindrows=self.numkindrows,
                   statype=self.graph.display.statype
                   )]

self.colorsamp = samps[0]
        if len(self.controls) > 1:
            samps.append(Sample(self.mod, statbyidx[1], self.controls[1].marker.name, idxs[1],
                                relative=samps[0]))

self.relsamp = samps[1]

t = self.tothead

n = max([len(str(samp.index)) for samp in samps])
        for samp in samps:
            t.insert('end', 'Sample %s: ' % samp.name)
            t.insert('end', ('%%%dd' % n) % samp.index, ('index',))
            t.insert('end', ' at %s\n' % (samp.datetime))

t.tag_configure('index', background='#e0e0e0')

t = self.rowhead

self.sizes = [float(samp.stat.size) for samp in samps]

for col in self.cols:
            t.insert('end', col.align(col.header), ('header',))
        t.insert('end', '\n')

t = self.text

self.ap = lambda text: t.insert('end', text)

self.colorow = Row(samps[0].count, samps[0].size, '<Total>')
        self.rowbyname = self.statbyname
        self.cumulval = 0
        for col in self.cols:
            col.render(col)
        self.ap('\n\n')

self.cumulval = 0
        for i, a in enumerate(samps[0].rows):
            self.colorow = a
            if len(samps) > 1:
                self.rowbyname = {
                    samps[0].name: a,
                    samps[1].name: samps[1].kindrows[a.name]
                }
            for col in self.cols:
                col.render(col)
            self.ap('\n')

if setscrollbar and self.auto_scrollbar:
            numrows = int(self.text.index('end').split('.')[0])-2
            h = int(self.text['height'])
            needs_scrollbar = numrows > h
            if needs_scrollbar != self.uses_scrollbar:
                self.setscrollbar(needs_scrollbar)

self.text['state'] = self.tothead['state'] = self.rowhead['state'] = DISABLED

def resize(self, dx, dy, setscrollbar=1):
        dx = int(dx)
        oldwidth = self.pixwidth
        newwidth = self.pixwidth + dx
        if newwidth < self.chdx * 2:
            newwidth = self.chdx * 2

self.pixwidth = newwidth
        dx = newwidth - oldwidth

charwidth, extra = divmod(newwidth, self.chdx)

self.kindcol.width = max(
            charwidth - self.widthbeforekind - 1, self.minkindwidth)

self.totxresize += dx
        for t in (self.tothead, self.rowhead, self.text):
            t['width'] = charwidth
            t['padx'] = self.minpadx + extra / 2

dy = int(dy)

rowresize, extra = divmod(self.totyresize + dy, self.chdy)
        newheight = self.orgtextheight + rowresize
        oldheight = int(self.text['height'])
        if newheight < self.mintextheight:
            newheight = self.mintextheight
            dy = (newheight - oldheight) * self.chdy + extra
        self.totyresize += dy

self.text['height'] = newheight
        self.text['pady'] = self.textminpady + extra / 2

self.update(force=1, setscrollbar=1)

return dx, dy

class Filler:
    def __init__(self, master):
        self.frame = self.can = Canvas(
            master,
            # background='blue',
            width=0,
            height=0)

def getsize(self):
        return int(self.can['width']), int(self.can['height']),

def setsize(self, w, h):
        self.can.configure(
            width=w,
            height=h
        )

def resize(self, dw, dh):
        w, h = self.getsize()
        self.setsize(max(0, w + dw), max(0, h + dh))

class Row:
    def __init__(self, count, size, name):
        self.count = count
        self.size = size
        self.name = name

class Sample:
    def __init__(self, mod, stat, name, index, numkindrows=None, statype='Size', relative=None):
        self.stat = stat
        self.size = stat.size
        self.count = stat.count
        self.name = name
        self.index = index

self.datetime = mod.time.asctime(mod.time.localtime(stat.timemade))

self.kindrows = {}

if numkindrows is not None:
            rows = stat.get_rows_n_and_other(numkindrows, statype)
            for r in rows:
                self.kindrows[r.name] = r
        else:
            kinds = []
            oidx = None
            for row in relative.rows:
                if row.name == '<Other>':
                    oidx = len(kinds)
                    continue
                else:
                    kinds.append(row.name)

rows = stat.get_rows_of_kinds(kinds)
            size = 0
            count = 0
            for i, row in enumerate(rows):
                kind = kinds[i]
                if row is None:
                    row = Row(0, 0, kind)
                self.kindrows[kind] = row
                size += row.size
                count += row.count

if oidx is not None:
                other = Row(stat.count - count, stat.size - size, '<Other>')
                rows[oidx:oidx] = [other]
                self.kindrows['<Other>'] = other

self.rows = rows

class ProfileBrowser:
    colors = ("red", "green", "blue", "yellow", "magenta", "cyan", 'white')
    numkindrows = 10

def __init__(self, app, filename):
        self.inited = 0
        self.app = app
        self.mod = mod = app.mod
        self.master = master = app.root
        if filename:
            filename = mod.path.abspath(filename)
            self.initialdir = mod.path.dirname(filename)
        else:
            self.initialdir = mod.os.getcwd()

self.frame = frame = Toplevel(
            master,
            # background='#bbb'
        )
        #frame['cursor'] = 'umbrella'
        # frame.resizable(True,True)

self.menubar = Frame(self.frame, relief=RAISED, bd=2)

self.filebutton = Menubutton(self.menubar, text='File')
        self.filemenu = Menu(self.filebutton)
        self.filebutton['menu'] = self.filemenu
        self.filemenu.add_command(
            label='New Profile Browser', command=self.cmd_new)
        self.filemenu.add_command(label='Open Profile', command=self.cmd_open)
        self.filemenu.add_command(label='Close Window', command=self.cmd_close)
        self.filemenu.add_command(
            label='Clear Cache', command=self.cmd_clear_cache)
        self.filemenu.add_command(label='Exit', command=self.cmd_exit)
        self.panebutton = Menubutton(self.menubar, text='Pane')
        self.panemenu = Menu(self.panebutton)
        self.panebutton['menu'] = self.panemenu

choices = [
            ('Bars', 'Lines'),
            ('Size', 'Count'),
        ]

self.graphtypevar = StringVar()
        self.graphbutton = self.modechooser(
            self.menubar, 'Graph', choices,
            self.graphtypevar, self.cmd_graphtype)

choices = [
            ('A', 'B'),
            ('Size', 'Count'),
            ('%A:Tot', '%B:Tot'),
            ('Cumul', 'A-B', 'B-A'),
            ('%A:Tot', '%B:Tot'),
            ('Kind',),
        ]

self.var_tablemode = StringVar()
        self.tablebutton = Menubutton(self.menubar, text='Table')
        self.tablemenu = Menu(self.tablebutton)
        self.tablebutton['menu'] = self.tablemenu
        self.headermenu = Menu(self.tablebutton, title='Table header')
        self.addmodechooser(
            self.headermenu,
            choices,
            self.var_tablemode,
            self.cmd_tablemode
        )
        self.tablemenu.add_cascade(label='Header', menu=self.headermenu)
        self.var_tablescrollbar = StringVar()
        self.tablescrollbarmenu = Menu(
            self.tablebutton, title='Table scrollbar')

self.addmodechooser(
            self.tablescrollbarmenu,
            [('Auto', 'On', 'Off')],
            self.var_tablescrollbar,
            self.cmd_tablescrollbar
        )

self.tablemenu.add_cascade(
            label='Scrollbar',
            menu=self.tablescrollbarmenu)

self.windowmenu = WindowMenu(self.menubar, self.app.var_window)
        self.window = app.add_window_frame(self.frame, self.windowmenu)

self.helpbutton = Menubutton(self.menubar, text='Help')
        self.helpmenu = Menu(self.helpbutton)
        self.helpbutton['menu'] = self.helpmenu
        self.helpmenu.add_command(label='About', command=self.cmd_about)
        self.helpmenu.add_command(label='Help', command=self.cmd_help)

self.ctrlframe = Frame(
            self.frame,
            bd=2,
            relief=GROOVE,
            # background='#999',

)

self.exitbutton = Button(self.ctrlframe, text='Exit', command=self.cmd_exit,
                                 background='red')

self.set_filename(filename)

self.id_collect = None
        self.collecting = IntVar()
        self.collecting.set(0)
        self.collectbutton = Checkbutton(self.ctrlframe, text='Collect',
                                         variable=self.collecting,
                                         command=self.cmd_collect,
                                         relief=RAISED)

self.stats = Stats(self.mod)

self.disptab = Frame(self.frame,
                             # relief=SUNKEN,
                             # bd=3
                             )

self.display = Display(self.disptab,
                               scale_table=AxisControl.scale_table,
                               numkindrows=self.numkindrows,
                               getkindcolor=self.getkindcolor,
                               )

self.xcontrol = AxisControl(self.ctrlframe,
                                    name='X',
                                    range=self.display.xrange,
                                    grid=self.display.xgrid,
                                    unit='samples',
                                    rangecommand=self.display.setxrange,
                                    gridcommand=self.display.setxgrid
                                    )

self.ycontrol = AxisControl(self.ctrlframe,
                                    name='Y',
                                    range=self.display.yrange,
                                    grid=self.display.ygrid,
                                    unit='bytes',
                                    rangecommand=self.display.setyrange,
                                    gridcommand=self.display.setygrid,
                                    autocommand=self.display.cmd_yrange_auto
                                    )

self.display.xcontrol = self.xcontrol
        self.display.ycontrol = self.ycontrol

self.mcontrols = []
        self.mcontrolbyname = {}
        for name in ('A', 'B'):
            marker = self.display.new_xmarker(name)
            control = MarkerControl(
                self.ctrlframe, marker, self.update_tableframe)
            marker.set_poscommand(control.setsample)
            self.mcontrols.append(control)
            self.mcontrolbyname[name] = control

self.var_showcontrol = BooleanVar()
        self.var_showcontrol.set(1)
        self.panemenu.add_checkbutton(
            label='Show Control Panel',
            variable=self.var_showcontrol,
            command=self.cmd_showcontrol)

self.var_showgraph = BooleanVar()
        self.var_showgraph.set(1)
        self.panemenu.add_checkbutton(
            label='Show Graph',
            variable=self.var_showgraph,
            command=self.cmd_showgraph)

self.var_showtable = BooleanVar()
        self.var_showtable.set(1)
        self.panemenu.add_checkbutton(
            label='Show Table',
            variable=self.var_showtable,
            command=self.cmd_showtable)

tf = self.tf = TableFrame(self, self.disptab)
        d_t = self.d_t = PaneDiv(self.disptab, movecommand=self.cmd_dt_moved)

self.xcontrol.frame.grid(row=0, column=0, padx=3, pady=3, sticky=W)
        self.ycontrol.frame.grid(row=1, column=0, padx=3, pady=3)
        self.mcontrols[0].frame.grid(
            row=0, column=1, columnspan=1, sticky=W, padx=3, pady=3)
        self.mcontrols[1].frame.grid(
            row=1, column=1, columnspan=1, sticky=W, padx=3, pady=3)
        self.exitbutton.grid(row=0, column=2, padx=3, pady=3)
        self.collectbutton.grid(row=0, column=3, padx=3, pady=3)

self.filler = Filler(self.frame)

self.filebutton.pack(side=LEFT)
        self.panebutton.pack(side=LEFT)
        self.graphbutton.pack(side=LEFT)
        self.tablebutton.pack(side=LEFT)
        self.windowmenu.button.pack(side=LEFT)
        self.helpbutton.pack(side=LEFT)

self.menubar.grid(column=0, columnspan=4, sticky=N+W+E)
        self.gridmain()

frame.bind('<Map>', self.event_map)

self.tf.setmode(self.var_tablemode.get(), self.numkindrows)

self.load_filename(filename)

d_t.frame.update_idletasks()
        d_t.setheight(max(self.display.frame.winfo_height(),
                          tf.frame.winfo_height()))

d_t.frame.update_idletasks()
        self.minsize = (500, 400)
        self.maxsize = (self.frame.winfo_screenwidth(),
                        self.frame.winfo_screenheight())
        minsizes = {
            # (ctrl, disp, tab) : (width, height)
            (0, 0, 0): (270, 25),
            (1, 0, 0): (363, 61),
            (0, 1, 0): (270, 131),
            (1, 1, 0): (270, 131),
        }

self.setusergeometry()

def initfinal():
            self.tf.setchdim()

rx = self.frame.winfo_rootx() + self.frame.winfo_width()
            self.tf_wanted_margin = rx - \
                (self.tf.frame.winfo_rootx() + self.tf.frame.winfo_width())

self.lastw = self.frame.winfo_width()
            self.lasth = self.frame.winfo_height()
            self.in_configure = 0
            frame.bind('<Configure>', self.event_configure)
            self.inited = 1

initfinal()
        # self.frame.after_idle(initfinal)

def cmd_about(self):
        self.cmd_help('about')

def cmd_help(self, pickname='help'):
        os = self.mod.os
        ocursor = self.frame.winfo_toplevel()['cursor']
        try:
            self.frame.winfo_toplevel()['cursor'] = 'watch'
            self.frame.update()
            m = self.mod.Text.gsltextviewer(
                self.frame,
                inpickle=getattr(self.mod.pbhelp, pickname)
                # htmloutfile='/tmp/x.html',
            )

self.app.add_window_frame(m)
        finally:
            self.frame.winfo_toplevel()['cursor'] = ocursor

def cmd_clear_cache(self):
        self.stats.clear_cache()

def cmd_close(self):
        self.frame.destroy()

def cmd_collect(self, *args):
        # self.afterfunc()
        # self.frame.after(1, self.afterfunc) # Turn on button first.??

if self.collecting.get():
            self.event_collect()
        else:
            if self.id_collect is not None:
                self.frame.after_cancel(self.id_collect)
                self.id_collect = None

def event_collect(self):
        o, n = self.stats.collect()
        if n:
            if o != self.display.numstats:
                self.display.load_stats(self.stats)
            else:
                st = self.stats[-n:]
                self.display.add_stats(st)
            for c in self.mcontrols:
                c.setnumsamples(len(self.stats))

self.id_collect = self.frame.after(1000, self.event_collect)

def cmd_dt_moved(self, dx):
        # The division between display and table panes moved.

# Disable configure event handling while we are resizing.
        self.in_configure += 1

# Right x position of enclosing frame

rx = self.frame.winfo_rootx() + self.frame.winfo_width()

# Right margin between pane divider and enclosing window

mx = rx - (self.d_t.frame.winfo_rootx() + self.d_t.frame.winfo_width())

# Don't move pane divider outside window
        dx = min(dx, mx)

# Right margin between table and enclosing window
        # before resizing
        mx = rx - (self.tf.frame.winfo_rootx() + self.tf.frame.winfo_width())

dx, _ = self.display.resize(dx, 0)

wanted_margin = self.tf_wanted_margin

# After move
        mx -= dx
        self.tf.resize(mx - wanted_margin, 0)

self.display.moveback()

self.in_configure -= 1

def cmd_exit(self):
        self.app.exit()

def cmd_graphtype(self):
        self.display.setgraphtype(self.graphtypevar.get(), self.stats)
        self.cmd_tablemode()

def cmd_new(self):
        self.app.new_profile_browser(self.filename)

def cmd_open(self):
        op = tkinter.filedialog.Open(self.frame,
                                     # ? Should we have default extension or not??
                                     # defaultextension='.hpy',
                                     initialdir=self.initialdir,
                                     filetypes=[('Heapy data files', '.hpy'),
                                                ('All files', '*')
                                                ]
                                     )
        filename = op.show()
        if filename:
            self.load_filename(filename)

def cmd_showcontrol(self):
        self.grid_things()

def cmd_showgraph(self):
        if self.var_showgraph.get() and self.var_showtable.get():
            self.tf.resize(-self.tf.totxresize, 0)
            self.display.resize(self.display.orgwidth - self.display.botx, 0)
            self.display.moveback()
        self.grid_things()

cmd_showtable = cmd_showgraph

def cmd_tablemode(self):
        self.tf.setmode(self.var_tablemode.get(), self.numkindrows)
        self.tf.update()

def cmd_tablescrollbar(self):
        tf = self.tf
        s = self.var_tablescrollbar.get()
        if s == 'Auto':
            tf.auto_scrollbar = 1
            tf.update(force=1, setscrollbar=1)
        elif s == 'On':
            tf.auto_scrollbar = 0
            tf.setscrollbar(1)
        elif s == 'Off':
            tf.auto_scrollbar = 0
            tf.setscrollbar(0)
        else:
            assert 0

def setusergeometry(self):
        # Make the geometry of the window be user-specified
        # This is called after Tk has determined the size
        # of the window needed for the initial widget configuration.
        # The size is not to be changed after that, other than
        # on user request.
        # I couldn't just do frame.geometry(frame.geometry()) because,
        # presumably, of a bug in the Tk and/or wm I am using. I hope
        # this works for all systems .. Notes  26 Oct 2005.

self.frame.update()
        g = '%dx%d+%d+%d' % (
            self.frame.winfo_width(),
            self.frame.winfo_height(),
            self.frame.winfo_rootx(),
            self.frame.winfo_rooty())
        self.frame.geometry(g)

def modechooser(self, frame, name, choices, cmdvar, command):

button = Menubutton(frame, text=name)
        menu = Menu(button)
        button['menu'] = menu

self.addmodechooser(menu, choices, cmdvar, command)
        return button

def addmodechooser(self, menu, choices, cmdvar, command):

def setcmdvar():
            cmdvar.set(' '.join([v.get() for v in vars]))

def cmd():
            setcmdvar()
            command()

vars = []
        for ch in choices:
            var = StringVar()
            vars.append(var)
            var.set(ch[0])
            for a in ch:
                menu.add_radiobutton(
                    command=cmd,
                    label=a,
                    value=a,
                    variable=var,
                    #font=('Courier','12', 'bold'),
                    #font=('Helvetica','12', 'bold'),
                    columnbreak=(a == ch[0])
                )

setcmdvar()

def grid_things(self):
        ow = self.frame.winfo_width()
        oh = self.frame.winfo_height()

self.ctrlframe.grid_forget()
        self.display.frame.grid_forget()
        self.d_t.frame.grid_forget()
        self.tf.frame.grid_forget()
        self.disptab.grid_forget()
        self.filler.frame.grid_forget()

self.gridmain()

self.frame.update_idletasks()
        self.sizewidgets()

def gridmain(self):

row = 1

c = self.var_showcontrol.get()
        if c:
            self.ctrlframe.grid(row=row, column=0,
                                columnspan=3, padx=3, pady=3, sticky=W)
            row += 1

column = 0

g = self.var_showgraph.get()
        t = self.var_showtable.get()
        gt = (g, t)
        if g:
            self.display.frame.grid(row=0, column=column, sticky=N+W,
                                    padx=3, pady=3
                                    )
            column += 1

if g and t:
            self.d_t.frame.grid(row=0, column=column, sticky=N+W)
            column += 1
        if t:
            self.tf.frame.grid(row=0, column=column, sticky=N+W, padx=3, pady=3
                               )
        if g or t:
            self.disptab.grid(row=row, column=0,
                              sticky=N+W,
                              # padx=3,pady=3,
                              )
            row += 1
        self.filler.setsize(0, 0)
        self.filler.frame.grid(row=row, column=3, sticky=N+W)

self.frame.resizable(1, 1)

def event_configure(self, event):
        if event.widget is not self.frame:
            return

if not self.inited:
            return

if self.in_configure:
            return

curw = self.frame.winfo_width()
        curh = self.frame.winfo_height()
        if curw == self.lastw and curh == self.lasth:
            return

self.in_configure += 1

self.lastw = curw
        self.lasth = curh

self.sizewidgets()

self.in_configure -= 1

def sizewidgets(self):
        self.frame.update()
        curw = self.frame.winfo_width()
        curh = self.frame.winfo_height()

mbx = self.menubar.winfo_rootx()
        mby = self.menubar.winfo_rooty()

sfs = []
        if self.var_showgraph.get():
            sfs.append(self.display)
        if self.var_showtable.get():
            sfs.append(self.tf)

if not sfs:
            sfs.append(self.filler)

dys = {}
        didh = 0
        for sf in sfs:
            f = sf.frame
            diy = f.winfo_rooty()
            dih = f.winfo_height()

ch = diy - mby + dih
            dy = curh - ch - 7
            didh = didh or dy
            dys[sf] = dy

if self.var_showtable.get():
            f = self.tf.frame
        elif self.var_showgraph.get():
            f = self.display.frame
        else:
            f = self.filler.frame

fx = f.winfo_rootx()
        fw = f.winfo_width()

cw = fx - mbx + fw

fdw = curw - cw - 6

if f is self.filler.frame and not self.var_showcontrol.get():
            fdw = curw - self.filler.getsize()[0] - 3

if didh or fdw:
            if self.var_showgraph.get() and self.var_showtable.get():
                dprop = float(self.display.frame.winfo_width())
                dprop = dprop / (dprop + self.tf.frame.winfo_width())
                dx, dy = self.display.resize(fdw * dprop, dys[self.display])
                self.tf.resize(fdw - dx, dys[self.tf])
                self.frame.update_idletasks()
                self.d_t.setheight(max(self.display.frame.winfo_height(),
                                       self.tf.frame.winfo_height()))

elif self.var_showgraph.get():
                self.display.resize(fdw, dys[self.display])
            elif self.var_showtable.get():
                self.tf.resize(fdw, dys[self.tf])
            else:
                self.filler.resize(fdw, dys[self.filler])
                self.filler.setsize(self.filler.getsize()[0], 1000)
            if self.var_showgraph.get():
                self.display.moveback()

#self.resize(dw, dh)

def resize(self, dw, dh):
        self.display.resize(dw, dh)
        # self.frame.wm_geometry('')

def event_map(self, event):
        self.frame.unbind('<Map>')
        self.frame.bind('<Unmap>', self.event_unmap)
        self.frame.lift()

def event_unmap(self, event):
        self.frame.unbind('<Unmap>')
        self.frame.bind('<Map>', self.event_map)

def load_filename(self, filename):
        ocursor = self.frame.winfo_toplevel()['cursor']
        try:
            self.frame.winfo_toplevel()['cursor'] = 'watch'
            self.frame.update()
            if filename:
                filename = self.mod.path.abspath(filename)
            try:
                self.stats.open(filename)
            except Exception:
                __import__('traceback').print_exc()
                etype, value, tb = self.mod._root.sys.exc_info()
                tkinter.messagebox.showerror(
                    master=self.frame,
                    message=(
                        "Error when loading\n%r:\n" % filename +
                        "%s" % ''.join(self.mod._root.traceback.format_exception_only(
                            etype, value)))
                )
            else:
                self.display.load_stats(self.stats)

for c in self.mcontrols:
                    c.setnumsamples(len(self.stats))
                # self.scontrol.trackcommand(1)
                self.set_filename(filename)

self.xrange_fit()
                self.display.xview_moveto(0)
                self.mcontrols[1].settracking(0)
                self.mcontrols[0].settracking(1)
                self.yrange_fit()
                self.tf.update(force=1)
                if filename:
                    self.initialdir = self.mod.path.dirname(filename)

finally:
            self.frame.winfo_toplevel()['cursor'] = ocursor

def update_tableframe(self):
        self.tf.update()

def getkindcolor(self, kind):
        if kind == '<Other>':
            return 'black'
        else:
            return self.colors[abs(hash(kind)) % len(self.colors)]

def set_filename(self, filename):
        self.filename = filename
        if not filename:
            filename = '<No File>'
        title = 'Heapy Profile Browser: %s' % filename
        self.window.title(title)

def setnormpos(self):
        self.setscrollregion()
        if self.ymax >= self.yrange:
            self.yrange_fit()
        if self.xi0 is None:
            self.drawxaxis()
        else:
            self.updatexaxis()

self.track()

def redraw_all(self):
        pass

def trackoff(self):
        self.rcontrol.settracking(0)

def xrange_fit(self):
        self.xcontrol.fit(len(self.stats))

def yrange_fit(self):
        self.display.yrange_auto(force=1)

class _GLUECLAMP_:
    _imports_ = (
        '_parent:Use',
        '_parent:pbhelp',
        '_root.guppy.etc:textView',
        '_root:hashlib',
        '_root:os',
        '_root.os:path',
        '_root:time',
        '_root.guppy.gsl:Text',
    )

def pb(self, filename=None):
        """pb( [filename: profilefilename+])

Create a Profile Browser window.

Argument
    filename: profilefilename+
        The name of a file containing profile data.
See also
    Heapy Profile Browser[1]
    Screenshot[2]
References
    [0] heapy_Use.html#heapykinds.Use.pb
    [1] ProfileBrowser.html
    [2] pbscreen.jpg"""

pa = ProfileApp(self)
        pa.new_profile_browser(filename)
        pa.mainloop()

def tpg(self):
        self('/tmp/x.hpy')