def initUI(self):
self.entries_found = []
self.parent.title("Search your command cards")
self.style = Style()
self.style.theme_use("default")
self.pack()
self.input_title = Label(self, text="Enter your command below")
self.input_title.grid(row=0, columnspan=2)
self.input_box = Entry(self, width=90)
self.input_box.grid(row=1, column=0)
self.input_box.focus()
self.input_box.bind("<Key>", self.onUpdateSearch)
self.search_btn = Button(self, text="Search", command=self.onSearch)
self.search_btn.grid(row=1, column=1)
self.output_box = Treeview(self, columns=("Example"))
ysb = Scrollbar(self, orient='vertical', command=self.output_box.yview)
xsb = Scrollbar(self,
orient='horizontal',
command=self.output_box.xview)
self.output_box.configure(yscroll=ysb.set, xscroll=xsb.set)
self.output_box.heading('Example', text='Example', anchor='w')
self.output_box.column("#0", minwidth=0, width=0, stretch=NO)
self.output_box.column("Example", minwidth=0, width=785)
self.output_box.bind("<Button-1>", self.OnEntryClick)
self.output_box.grid(row=3, columnspan=2)
self.selected_box = Text(self, width=110, height=19)
self.selected_box.grid(row=4, columnspan=2)
self.gotoadd_btn = Button(self,
text="Go to Add",
command=self.onGoToAdd)
self.gotoadd_btn.grid(row=5)
def __init__(self,
master,
data=None,
ascending_order=True,
ignore_case=False,
autoscroll=False,
vscrollbar=True,
hscrollbar=False,
scrollbar_background=None,
scrollbar_troughcolor=None,
**kwargs):
Frame.__init__(self, master)
self._ignore_case = ignore_case
self._ascending_order = ascending_order
master.grid_rowconfigure(0, weight=1)
master.grid_columnconfigure(0, weight=1)
self._listbox = Listbox(self, *kwargs)
self._listbox.grid(row=0, column=0, sticky=N + E + W + S)
scrollbar_kwargs = {}
if scrollbar_background is not None:
scrollbar_kwargs["background"] = scrollbar_background
if scrollbar_troughcolor is not None:
scrollbar_kwargs["throughcolor"] = scrollbar_troughcolor
if vscrollbar:
self._vbar = Scrollbar(self,
takefocus=0,
command=self._listbox.yview,
**scrollbar_kwargs)
self._vbar.grid(row=0, column=1, sticky=N + S)
if autoscroll:
self._listbox.config(yscrollcommand=lambda f, l:
make_autoscroll(self._vbar, f, l))
else:
self._listbox.config(yscrollcommand=self._vbar.set)
if hscrollbar:
self._hbar = Scrollbar(self,
takefocus=0,
command=self._listbox.xview,
**scrollbar_kwargs)
self._hbar.grid(row=0, column=1, sticky=E + W)
if autoscroll:
self._listbox.config(xscrollcommand=lambda f, l:
make_autoscroll(self._hbar, f, l))
else:
self._listbox.config(xscrollcommand=self._hbar.set)
if data is not None:
for item in data:
self.add_item(item)
def __init__(self, master, width=None, height=None, mousewheel_speed=2, scroll_horizontally=True, xscrollbar=None,
scroll_vertically=True, yscrollbar=None, outer_background=None, inner_frame=Frame, **kw):
super(Scrolling_Area, self).__init__(master, **kw)
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
self._clipper = Frame(self, background=outer_background, width=width, height=height)
self._clipper.grid(row=0, column=0, sticky=N + E + W + S)
self._width = width
self._height = height
self.innerframe = inner_frame(self._clipper, padx=0, pady=0, highlightthickness=0)
self.innerframe.place(in_=self._clipper, x=0, y=0)
if scroll_vertically:
if yscrollbar is not None:
self.yscrollbar = yscrollbar
else:
self.yscrollbar = Scrollbar(self, orient=VERTICAL)
self.yscrollbar.grid(row=0, column=1, sticky=N + S)
self.yscrollbar.set(0.0, 1.0)
self.yscrollbar.config(command=self.yview)
else:
self.yscrollbar = None
self._scroll_vertically = scroll_vertically
if scroll_horizontally:
if xscrollbar is not None:
self.xscrollbar = xscrollbar
else:
self.xscrollbar = Scrollbar(self, orient=HORIZONTAL)
self.xscrollbar.grid(row=1, column=0, sticky=E + W)
self.xscrollbar.set(0.0, 1.0)
self.xscrollbar.config(command=self.xview)
else:
self.xscrollbar = None
self._scroll_horizontally = scroll_horizontally
self._jfraction = 0.05
self._startX = 0
self._startY = 0
# Whenever the clipping window or scrolled frame change size,
# update the scrollbars.
self.innerframe.bind('<Configure>', self._on_configure)
self._clipper.bind('<Configure>', self._on_configure)
self.innerframe.xview = self.xview
self.innerframe.yview = self.yview
Mousewheel_Support(self).add_support_to(self.innerframe, xscrollbar=self.xscrollbar, yscrollbar=self.yscrollbar)
def __init__(self, master, width=None, anchor=N, height=None, mousewheel_speed=2, scroll_horizontally=True,
xscrollbar=None, scroll_vertically=True, yscrollbar=None, outer_background=None, inner_frame=Frame,
**kw):
Frame.__init__(self, master, class_=self.__class__)
if outer_background:
self.configure(background=outer_background)
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
self._width = width
self._height = height
self.canvas = Canvas(self, background=outer_background, highlightthickness=0, width=width, height=height)
self.canvas.grid(row=0, column=0, sticky=N + E + W + S)
if scroll_vertically:
if yscrollbar is not None:
self.yscrollbar = yscrollbar
else:
self.yscrollbar = Scrollbar(self, orient=VERTICAL)
self.yscrollbar.grid(row=0, column=1, sticky=N + S)
self.canvas.configure(yscrollcommand=self.yscrollbar.set)
self.yscrollbar['command'] = self.canvas.yview
else:
self.yscrollbar = None
if scroll_horizontally:
if xscrollbar is not None:
self.xscrollbar = xscrollbar
else:
self.xscrollbar = Scrollbar(self, orient=HORIZONTAL)
self.xscrollbar.grid(row=1, column=0, sticky=E + W)
self.canvas.configure(xscrollcommand=self.xscrollbar.set)
self.xscrollbar['command'] = self.canvas.xview
else:
self.xscrollbar = None
self.rowconfigure(0, weight=1)
self.columnconfigure(0, weight=1)
self.innerframe = inner_frame(self.canvas, **kw)
self.innerframe.pack(anchor=anchor)
self.canvas.create_window(0, 0, window=self.innerframe, anchor='nw', tags="inner_frame")
self.canvas.bind('<Configure>', self._on_canvas_configure)
Mousewheel_Support(self).add_support_to(self.canvas, xscrollbar=self.xscrollbar, yscrollbar=self.yscrollbar)
def __init__(self, master, headers, data, name=None):
Frame.__init__(self, master, name=name)
#: column headers
self.headers = headers
#: table data
self.data = data
#: :class:`~ttk.Treeview` that only shows "headings" not "tree columns"
self.tree = Treeview(self,
columns=self.headers,
show="headings",
name='tabletree')
#: vertical scrollbar
self.yscroll = Scrollbar(self,
orient="vertical",
command=self.tree.yview,
name='table_yscroll')
#: horizontal scrollbar
self.xscroll = Scrollbar(self,
orient="horizontal",
command=self.tree.xview,
name='table_xscroll')
self.tree['yscrollcommand'] = self.yscroll.set # bind to scrollbars
self.tree['xscrollcommand'] = self.xscroll.set
# position widgets and set resize behavior
self.tree.grid(column=0, row=0, sticky=(N + E + W + S))
self.yscroll.grid(column=1, row=0, sticky=(N + S))
self.xscroll.grid(column=0, row=1, sticky=(E + W))
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
# build tree
for col in self.headers:
# NOTE: Use col as column identifiers, crafty!
# NOTE: Also change col to title case using str.title()
# NOTE: make lambda behave nicely in a loop using default arg!
callback = lambda c=col: self.sortby(c, False)
self.tree.heading(col, text=col.title(), command=callback)
# adjust the column's width to the header string
self.tree.column(col, width=tkFont.Font().measure(col.title()))
# insert a new top-level treeview item by suing an empty string
for item in self.data:
self.tree.insert('', END, values=item)
# adjust column's width if necessary to fit each value
for idx, val in enumerate(item):
col_width = tkFont.Font().measure(val)
# option can be specified at least 3 ways: as (a) width=None,
# (b) option='width' or (c) 'width', where 'width' can be any
# valid column option.
if self.tree.column(self.headers[idx], 'width') < col_width:
self.tree.column(self.headers[idx], width=col_width)
def __init__(self, master, widget_class, attributes=None, scrollbar=None):
"""
master is the parent widget
widget_class is the class, like Text or Listbox
attributes are attributes for the widget
scrollbar are attributes for the scrollbar
"""
if attributes is None:
attributes = []
if scrollbar is None:
scrollbar = []
self.master = master
# Parent frame to hold the widget + scrollbar
self.frame = Frame(master)
# The scrollbar
self.scrollbar = Scrollbar(self.frame, **scrollbar)
# The widget itself
self.widget = widget_class(self.frame,
yscrollcommand=self.scrollbar.set,
**attributes)
self.scrollbar.configure(command=self.widget.yview)
self.scrollbar.pack(side="right", fill="y")
self.widget.pack(side="right", fill="both", expand=1)
def _make_rcv_log(self):
# make receive log
recvLogFrame = Frame(self, width=400, height=200)
recvLogFrame.style = self.style
recvLogFrame.grid(row=2,
column=0,
padx=2,
pady=2,
sticky=N + S + E + W)
self.start_stop_button = Button(self,
text="Stop",
command=self.start_stop_clicked)
self.start_stop_button.style = self.style
self.start_stop_button.grid(row=2,
column=1,
padx=2,
pady=2,
sticky=N + S + E + W)
# make a scrollbar
self.scrollbar = Scrollbar(recvLogFrame)
self.scrollbar.pack(side=RIGHT, fill=Y)
# make a text box to put the serial output
self.log = Text(recvLogFrame,
width=50,
height=30,
takefocus=0,
borderwidth=1,
relief='ridge')
self.log.pack(fill=BOTH, expand=True)
# attach text box to scrollbar
self.log.config(yscrollcommand=self.scrollbar.set)
self.scrollbar.config(command=self.log.yview)
def __init__(self, master, name=None, scrollregion=(0, 0, '5i', '5i'),
items=[], window_size=[160, 30], **canvaskw):
Frame.__init__(self, master, name=name)
self.scrollcanvas = Canvas(self, name='scrollcanvas',
scrollregion=scrollregion, **canvaskw)
self.yscroll = Scrollbar(self, name='yscroll',
command=self.scrollcanvas.yview)
self.scrollcanvas['yscrollcommand'] = self.yscroll.set
self.yscroll.pack(side=RIGHT, fill=Y)
self.scrollcanvas.pack(side=LEFT, fill=BOTH, expand=YES)
self.items = dict.fromkeys(items)
for n, i in enumerate(items):
self.items[i] = {'frame': Frame(self, name=(i.lower() + '_frame'))}
self.items[i]['frame'].config(relief=GROOVE, padding=5)
self.items[i]['chbx'] = Checkbutton(self.items[i]['frame'],
name=(i.lower() + '_chbx'))
self.items[i]['chbx']['text'] = i
self.items[i]['chbx'].pack(side=LEFT, fill=X)
y = window_size[1] / 2 + window_size[1] * n
self.items[i]['window'] = self.scrollcanvas.create_window(0, y)
self.scrollcanvas.itemconfigure(self.items[i]['window'],
window=self.items[i]['frame'],
anchor=W, width=window_size[0],
height=window_size[1])
def _setup_breakpoint_list(self):
self.breakpoints_frame = Frame(self.content)
self.breakpoints_frame.grid(column=0, row=0, sticky=(N, S, E, W))
self.file_notebook.add(self.breakpoints_frame, text='Breakpoints')
self.breakpoints = BreakpointView(self.breakpoints_frame,
normalizer=self.filename_normalizer)
self.breakpoints.grid(column=0, row=0, sticky=(N, S, E, W))
# The tree's vertical scrollbar
self.breakpoints_scrollbar = Scrollbar(self.breakpoints_frame,
orient=VERTICAL)
self.breakpoints_scrollbar.grid(column=1, row=0, sticky=(N, S))
# Tie the scrollbar to the text views, and the text views
# to each other.
self.breakpoints.config(yscrollcommand=self.breakpoints_scrollbar.set)
self.breakpoints_scrollbar.config(command=self.breakpoints.yview)
# Setup weights for the "breakpoint list" tree
self.breakpoints_frame.columnconfigure(0, weight=1)
self.breakpoints_frame.columnconfigure(1, weight=0)
self.breakpoints_frame.rowconfigure(0, weight=1)
# Handlers for GUI events
self.breakpoints.tag_bind('breakpoint', '<Double-Button-1>',
self.on_breakpoint_double_clicked)
self.breakpoints.tag_bind('breakpoint', '<<TreeviewSelect>>',
self.on_breakpoint_selected)
self.breakpoints.tag_bind('file', '<<TreeviewSelect>>',
self.on_breakpoint_file_selected)
def _scrolled_text_display(title='Diagnil Text Display',
intro=None, button_proc=null_proc,
tab_stops=(), return_frame=0):
fr = Toplevel()
fr.geometry(newGeometry='-0+50')
if intro: Label(fr, text=intro).pack(padx=10, pady=10)
txt_fr = Frame(fr)
if on_win:
txt = Text(txt_fr, width=70, padx=10, pady=5, wrap=WORD,
tabs=tab_stops)
else:
txt = Text(txt_fr, width=70, padx=10, pady=5, wrap=WORD,
background=text_bg_color, tabs=tab_stops)
scroll = Scrollbar(txt_fr, command=txt.yview)
txt.configure(yscrollcommand=scroll.set)
wrapped_bind(fr, '<Key-Prior>', lambda event: txt.yview_scroll(-1, PAGES))
wrapped_bind(fr, '<Key-Next>', lambda event: txt.yview_scroll(1, PAGES))
wrapped_bind(fr, '<Enter>', lambda event: fr.focus_set())
txt.pack(side=LEFT, fill=BOTH, expand=YES)
scroll.pack(side=LEFT, fill=Y)
txt_fr.pack(padx=5, pady=5, fill=BOTH, expand=YES)
button_proc(fr)
fr.title(string=title)
if return_frame: return fr, txt
else: return txt
def __init__(self, master, **kwargs):
Frame.__init__(self, master)
textarea_frame = Frame(self, bd=1, relief=SOLID, **kwargs)
textarea_frame.pack(fill=X)
textarea_frame.pack_propagate(False)
self.textarea = Text(textarea_frame, height=1, pady=self.TAG_ENTRY_PADY, padx=self.TAG_ENTRY_PADX,
highlightthickness=0, spacing1=0, spacing2=0, spacing3=0, borderwidth=0, wrap="none")
self.textarea.pack(expand=True, fill=BOTH, padx=2)
scrollbar = Scrollbar(self, orient=HORIZONTAL, command=self.textarea.xview)
scrollbar.pack(fill=X)
self.textarea.configure(xscrollcommand=scrollbar.set)
self.textarea.bind("<KeyPress>", self._on_keypress)
tag = Tag(self.textarea, "")
self.textarea.window_create("1.0", window=tag)
self.update_idletasks()
tag_reqheight = tag.winfo_reqheight()
textarea_frame.configure(height=tag_reqheight + 2 * self.TAG_ENTRY_PADY + 2 * self.textarea["borderwidth"])
# I add a hidden frame because I want the cursor centered including when there is no tag
self.textarea.window_create("1.0", window=Frame(self.textarea, height=tag_reqheight, width=0, borderwidth=0))
tag.destroy()
def whois(self, addr=None):
if not addr:
addr = self._remote_addr
addr = addr.split(':')
try:
reverse = subprocess.check_output(['dig', '+short', '-x', addr[0]])
except:
reverse = None
try:
out = subprocess.check_output(['whois', addr[0]])
except:
out = 'No info for this host.'
self.whois_popup = {}
self.whois_popup['window'] = tk.Toplevel(self)
self.whois_popup['window'].title('Whois %s' % addr[0])
self.whois_popup['frame'] = tk.Frame(self.whois_popup['window'])
self.whois_popup['frame'].pack(fill=tk.BOTH, expand=tk.Y)
self.whois_popup['text'] = tk.Text(self.whois_popup['frame'], wrap=tk.WORD, height=32, width=96)
self.whois_popup['text'].pack(fill=tk.BOTH, expand=tk.Y, side=tk.LEFT)
self.whois_popup['scrollbar_y'] = Scrollbar(self.whois_popup['frame'])
self.whois_popup['scrollbar_y'].config(command=self.whois_popup['text'].yview)
self.whois_popup['scrollbar_y'].pack(side=tk.RIGHT, fill=tk.Y)
self.whois_popup['text'].config(yscrollcommand=self.whois_popup['scrollbar_y'].set)
if reverse:
reverse = 'Reverse lookup: %s\n' % reverse
self.whois_popup['text'].insert(tk.END, reverse)
self.whois_popup['text'].insert(tk.END, out)
tk.Button(self.whois_popup['window'], text='Ok', command=self.whois_popup['window'].destroy).pack()
def _setup_stack_frame_list(self):
self.stack_frame = Frame(self.content)
self.stack_frame.grid(column=0, row=0, sticky=(N, S, E, W))
self.file_notebook.add(self.stack_frame, text='Stack')
self.stack = StackView(self.stack_frame,
normalizer=self.filename_normalizer)
self.stack.grid(column=0, row=0, sticky=(N, S, E, W))
# # The tree's vertical scrollbar
self.stack_scrollbar = Scrollbar(self.stack_frame, orient=VERTICAL)
self.stack_scrollbar.grid(column=1, row=0, sticky=(N, S))
# # Tie the scrollbar to the text views, and the text views
# # to each other.
self.stack.config(yscrollcommand=self.stack_scrollbar.set)
self.stack_scrollbar.config(command=self.stack.yview)
# Setup weights for the "stack" tree
self.stack_frame.columnconfigure(0, weight=1)
self.stack_frame.columnconfigure(1, weight=0)
self.stack_frame.rowconfigure(0, weight=1)
# Handlers for GUI events
self.stack.bind('<<TreeviewSelect>>', self.on_stack_frame_selected)
def consolePanel(self):
tmpFrm = Frame(self.bgndFrm, borderwidth=5, relief=RAISED)
tmpFrm.grid()
tmpFrm.grid(column=0, row=1)
self.scrollbar = Scrollbar(tmpFrm)
self.scrollbar.pack(side=RIGHT, fill=Y)
self.log = Text(tmpFrm, wrap=WORD, yscrollcommand=self.scrollbar.set)
self.log.pack()
self.scrollbar.config(command=self.log.yview)
def __init__(self,parent,caller,**args):
Frame.__init__(self,parent,**args)
self.pack(side=TOP)
self.canvas = Canvas(self,scrollregion=(0,0,1000,1000)
,background='white',cursor='pencil')
self.canvas.bind("<Button-1>",lambda event:caller.clickCell(event,1))
self.canvas.bind("<B1-Motion>",lambda event:caller.clickCell(event,1))
self.canvas.bind("<Control-Button-1>",lambda event:caller.clickCell(event,-1))
self.canvas.bind("<Control-B1-Motion>",lambda event:caller.clickCell(event,-1))
vScroll = Scrollbar(self, orient = VERTICAL)
vScroll.pack(side = RIGHT, fill=Y)
vScroll.config(command = self.canvas.yview)
hScroll = Scrollbar(self, orient = HORIZONTAL)
hScroll.pack(side = BOTTOM, fill=X)
hScroll.config(command = self.canvas.xview)
self.canvas.config(xscrollcommand = hScroll.set, yscrollcommand = vScroll.set)
self.canvas.pack(side=LEFT)
def create_scrollable_text_area(self):
""" Creates main text area with scrollbars"""
xscrollbar = Scrollbar(self, orient=HORIZONTAL)
xscrollbar.grid(row=2, column=1, columnspan=5, sticky=E + W)
yscrollbar = Scrollbar(self, orient=VERTICAL)
yscrollbar.grid(row=1, column=6, sticky=N + S)
self.textarea = Text(self,
wrap=NONE,
bd=0,
xscrollcommand=xscrollbar.set,
yscrollcommand=yscrollbar.set)
self.textarea.grid(row=1,
column=1,
columnspan=5,
rowspan=1,
padx=0,
sticky=E + W + S + N)
xscrollbar.config(command=self.textarea.xview)
yscrollbar.config(command=self.textarea.yview)
def _init_ui(self): # Load an image self.img = ImageTk.PhotoImage(Image.open(r"images\dna5.png")) # Define a canvas in a frame frame = Frame(self) c = Canvas(frame, bg="white", height=475, width=475) # Display the image in the canvas c.create_image(0, 0, image=self.img, anchor=NW) # Y-scrollbar yscrollbar = Scrollbar(frame, command=c.yview) c.configure(yscrollcommand=yscrollbar.set) # X-scrollbar xscrollbar = Scrollbar(frame, orient=HORIZONTAL, command=c.xview) c.configure(xscrollcommand=xscrollbar.set) # Display widgets using grid layout. frame.grid(row=0, column=0) yscrollbar.grid(row=0, column=2, sticky=S + N) xscrollbar.grid(row=2, column=0, sticky=W + E) c.grid(row=0, column=0) self.pack(fill=BOTH, expand=1)
def __init__(self, root):
Frame.__init__(self, root)
self.canvas = ResizingCanvas(self, borderwidth=0)
self.frame = Frame(self.canvas)
self.vsb = Scrollbar(
self, orient="vertical", command=self.canvas.yview)
self.canvas.configure(yscrollcommand=self.vsb.set)
self.vsb.pack(side="right", fill="y")
self.canvas.pack(side="left", fill="both", expand=True)
self.canvas.create_window(
(4, 4), window=self.frame, anchor="nw", tags="self.frame")
self.frame.bind("<Configure>", self.OnFrameConfigure)
def initUI(self):
self.columnconfigure(0, weight=0)
self.columnconfigure(1, weight=0)
self.columnconfigure(2, weight=1)
self.columnconfigure(3, weight=1)
self.rowconfigure(0, weight=1)
self.commandFrame = Frame(self, background="white")
self.commandFrame.grid(row=0, column=0, columnspan=5, sticky=W+E)
self.commandFrame.columnconfigure(1, weight=1)
self.btnCommand = Button(self.commandFrame, text="Run")
self.btnCommand.grid(row=0, column=0)
self.strCommand = StringVar()
self.entCommand = Entry(self.commandFrame, textvariable=self.strCommand)
self.entCommand.grid(row=0, column=1, sticky=W+E)
self.lstMacro = Listbox(self)
self.lstMacro.grid(row=1, column=0, sticky=N+S+W+E)
self.treeview = Treeview(self, columns=("Angle"), displaycolumns="#all", selectmode="browse")
self.treeview.grid(row=1, column=1, columnspan=4, sticky=N+S+W+E)
self.treeScrollbar = Scrollbar(self)
self.treeScrollbar.grid(row=1, column=5, sticky=N+S)
self.treeview.config(yscrollcommand=self.treeScrollbar.set)
self.treeScrollbar.config(command=self.treeview.yview)
self.btnFrame = Frame(self, background="white")
self.btnFrame.grid(row=2, column=0, columnspan=5, sticky=W+E)
self.btnRun = Button(self.btnFrame, text="Run", command=self.runMacro)
self.btnRun.grid(row=0, column=0)
self.btnStop = Button(self.btnFrame, text="Stop")
self.btnStop.grid(row=0, column=1)
self.btnSaveMacro = Button(self.btnFrame, text="Save Macro", command=self.saveMacro)
self.btnSaveMacro.grid(row=0, column=2)
self.btnDeleteMacro = Button(self.btnFrame, text="Delete Macro")
self.btnDeleteMacro.grid(row=0, column=3)
self.btnDeleteState = Button(self.btnFrame, text="Delete State")
self.btnDeleteState.grid(row=0, column=4)
def __init__(self, master):
Frame.__init__(self, master)
scrollbar = Scrollbar(self, orient=VERTICAL)
scrollbar.pack(side=RIGHT, fill=Y)
self.canvas = Canvas(self,
bd=0,
highlightthickness=0,
yscrollcommand=scrollbar.set)
self.canvas.pack(side=LEFT, fill=BOTH, expand=1)
scrollbar.config(command=self.canvas.yview)
self.mainframe = Frame(self.canvas)
self.mainframe_id = self.canvas.create_window((0, 0),
window=self.mainframe,
anchor=NW)
self.mainframe.bind('<Configure>', self.config_mainframe)
self.canvas.bind('<Configure>', self.config_canvas)
def initUI(self):
self.parent.title("Text Field")
self.pack(fill=BOTH, expand=True)
frame1 = Frame(self, width=50, height=25)
frame1.pack(fill=X, expand=True)
self.scroll = Scrollbar(frame1)
self.scroll.pack(side="right", fill=Y)
self.text = Text(frame1)
self.text.pack(fill=Y)
self.scroll.config(command=self.text.yview)
self.text.config(yscrollcommand=self.scroll.set)
frame2 = Frame(self)
frame2.pack(fill=X, expand=True)
self.submit = Button(frame2, text="Start Test")
self.submit.bind("<Button-1>", self.startPause)
self.submit.pack(fill=X)
def _init_ui(self):
"""
Composes the UI and associates the appropriate
handler for the actions to catch.
"""
self._parent.title("Events")
self._style = Style()
self._style.theme_use("default")
self.pack(fill=BOTH, expand=1)
self.columnconfigure(1, weight=1)
self.columnconfigure(3, pad=7)
self.rowconfigure(3, weight=1)
self.rowconfigure(5, pad=7)
label = Label(self, text="Actions")
label.grid(sticky=W, pady=4, padx=5)
self._text_area = self.ReadOnlyText(self)
self._text_area.grid(row=1,
column=0,
columnspan=2,
rowspan=4,
padx=5,
sticky=E + W + S + N)
scrollbar = Scrollbar(self, command=self._text_area.yview)
scrollbar.grid(row=1, column=2, rowspan=4, sticky=N + S)
self._text_area['yscrollcommand'] = scrollbar.set
start_button = Button(self, text="Start", command=self._rec_start)
start_button.grid(row=1, column=3)
stop_button = Button(self, text="Stop", command=self._rec_stop)
stop_button.grid(row=2, column=3, pady=4)
save_button = Button(
self,
text="Save",
)
save_button.grid(row=5, column=3)
quit_button = Button(self, text="Quit", command=self._exit)
quit_button.grid(row=5, column=0, padx=5)
def _setup_inspector(self):
self.inspector_frame = Frame(self.content)
self.inspector_frame.grid(column=2, row=0, sticky=(N, S, E, W))
self.inspector = InspectorView(self.inspector_frame)
self.inspector.grid(column=0, row=0, sticky=(N, S, E, W))
# The tree's vertical scrollbar
self.inspector_scrollbar = Scrollbar(self.inspector_frame,
orient=VERTICAL)
self.inspector_scrollbar.grid(column=1, row=0, sticky=(N, S))
# Tie the scrollbar to the text views, and the text views
# to each other.
self.inspector.config(yscrollcommand=self.inspector_scrollbar.set)
self.inspector_scrollbar.config(command=self.inspector.yview)
# Setup weights for the "breakpoint list" tree
self.inspector_frame.columnconfigure(0, weight=1)
self.inspector_frame.columnconfigure(1, weight=0)
self.inspector_frame.rowconfigure(0, weight=1)
self.content.add(self.inspector_frame)
def __init__(self, master, columns, data=None, command=None, editable=True, sort=True, select_mode=None, autoscroll=True, vscrollbar=True, hscrollbar=False, heading_anchor = CENTER, cell_anchor=W, style=None, scrollbar_background=None, scrollbar_troughcolor=None, height=None, padding=None, adjust_heading_to_content=False, stripped_rows=None, selection_background=None, selection_foreground=None, cell_background=None, cell_foreground=None, cell_font=None, field_background=None, heading_font= None, heading_background=None, heading_foreground=None, cell_pady=2, column_header=True, row_numbers=True, entry_background="#d6d6d6", entry_foreground=None, entry_validatecommand=None, entry_selectbackground="#1BA1E2", entry_selectborderwidth=None, entry_selectforeground=None, entry_font = "TkDefaultFont", rowlabel_anchor=E, rowlabel_minwidth=0, rowlabel_hoverbackground="#FFFFFF",frame_relief=None, frame_borderwidth=None, frame_background=None):
frame_kwargs = {}
if frame_relief is not None:
frame_kwargs["relief"] = frame_relief
if frame_borderwidth is not None:
frame_kwargs["borderwidth"] = frame_borderwidth
if frame_background is not None:
frame_kwargs["background"] = frame_background
Frame.__init__(self, master, class_="Multicolumn_Listbox", **frame_kwargs)
self.grid_rowconfigure(0, weight=1)
self.grid_columnconfigure(1, weight=1)
self._multicolumn_listbox = Multicolumn_Listbox(self, columns, data=data, command=command, sort=sort, select_mode=select_mode, heading_anchor = heading_anchor, cell_anchor=cell_anchor, style=style, height=height, padding=padding, adjust_heading_to_content=adjust_heading_to_content, stripped_rows=stripped_rows, selection_background=selection_background, selection_foreground=selection_foreground, cell_background=cell_background, cell_foreground=cell_foreground, cell_font=cell_font, field_background=field_background, heading_font=heading_font, heading_background=heading_background, heading_foreground=heading_foreground, cell_pady=cell_pady, headers=column_header)
self._multicolumn_listbox.interior.grid(row=0, column=1, sticky= N+E+W+S)
self._mousewheel_detection = True
if row_numbers:
self._row_numbers = Row_Header(self, font=self._multicolumn_listbox.font, row_height=self._multicolumn_listbox.row_height, row_minwidth=rowlabel_minwidth, hover_background = rowlabel_hoverbackground, anchor=rowlabel_anchor, onclick=self._on_click_row_label)
self._row_numbers.grid(row=0, column=0, sticky= N+S+E)
self._multicolumn_listbox.interior.bind("<Map>", self._place_vertically_row_numbers)
else:
self._row_numbers = None
if editable:
self._selected_cell = None
self._entry_popup = None
self._multicolumn_listbox.interior.bind("<1>", self._edit_cell)
def configure(event):
"""
if self._entry_popup:
self._entry_popup.destroy()
return
"""
self._multicolumn_listbox.interior.update_idletasks()
self._update_position_of_entry()
self._multicolumn_listbox.interior.bind("<Configure>", configure)
self._entry_kwargs = entry_kwargs = {}
if entry_background is not None:
entry_kwargs["background"] = entry_background
if entry_foreground is not None:
entry_kwargs["foreground"] = entry_foreground
if entry_validatecommand is not None:
entry_kwargs["validatecommand"] = entry_validatecommand
if entry_selectbackground is not None:
entry_kwargs["selectbackground"] = entry_selectbackground
if entry_selectforeground is not None:
entry_kwargs["selectforeground"] = entry_selectforeground
if entry_font is not None:
entry_kwargs["font"] = entry_font
if command is not None:
self._command = command
self._multicolumn_listbox.interior.bind("<<TreeviewSelect>>", self._on_select)
scrollbar_kwargs = {}
if scrollbar_background is not None:
scrollbar_kwargs["background"] = scrollbar_background
if scrollbar_troughcolor is not None:
scrollbar_kwargs["throughcolor"] = scrollbar_troughcolor
if vscrollbar:
if editable:
if row_numbers:
def yview_command(*args):
self._multicolumn_listbox.interior.yview(*args)
self._row_numbers.yview(*args)
self._update_position_of_entry()
else:
def yview_command(*args):
self._multicolumn_listbox.interior.yview(*args)
self._update_position_of_entry()
else:
if row_numbers:
def yview_command(*args):
self._multicolumn_listbox.interior.yview(*args)
self._row_numbers.yview(*args)
else:
yview_command = self._multicolumn_listbox.interior.yview
self._vbar=Scrollbar(self,takefocus=0, command=yview_command, **scrollbar_kwargs)
self._vbar.grid(row=0, column=2, sticky= N+S)
def yscrollcommand(first,last):
first, last = float(first), float(last)
if first <= 0 and last >= 1:
if self._mousewheel_detection:
if autoscroll:
self._vbar.grid_remove()
if row_numbers:
unbind_function_onMouseWheel(self._multicolumn_listbox.interior)
self._mousewheel_detection = False
else:
if not self._mousewheel_detection:
if autoscroll:
self._vbar.grid()
if row_numbers:
bind_function_onMouseWheel(self._row_numbers, "y", binding_widget=self._multicolumn_listbox.interior, unit="pages")
self._mousewheel_detection = True
self._vbar.set(first, last)
if editable:
self._update_position_of_entry()
self._multicolumn_listbox.interior.config(yscrollcommand=yscrollcommand)
if hscrollbar:
if editable:
def xview_command(*args):
self._multicolumn_listbox.interior.xview(*args)
self._update_position_of_entry()
else:
xview_command = self._multicolumn_listbox.interior.xview
self._hbar=Scrollbar(self,takefocus=0, command=xview_command, **scrollbar_kwargs)
self._hbar.grid(row=1, column=1, sticky= E+W)
if autoscroll:
if editable:
def xscrollcommand(f,l, self=self):
make_autoscroll(self._hbar, f, l)
self._update_position_of_entry()
else:
def xscrollcommand(f,l, hbar=self._hbar):
make_autoscroll(hbar, f, l)
self._multicolumn_listbox.interior.config(xscrollcommand=xscrollcommand)
else:
self._multicolumn_listbox.interior.config(xscrollcommand=self._hbar.set)
def __init__(self,
master,
xml=None,
heading_text=None,
heading_anchor=None,
padding=None,
cursor=None,
takefocus=None,
style=None):
Frame.__init__(self, master, class_="XML_Viwer")
self._vsb = Scrollbar(self, orient=VERTICAL)
self._hsb = Scrollbar(self, orient=HORIZONTAL)
kwargs = {}
kwargs["yscrollcommand"] = lambda f, l: autoscroll(self._vsb, f, l)
kwargs["xscrollcommand"] = lambda f, l: autoscroll(self._hsb, f, l)
if style is not None:
kwargs["style"] = style
if padding is not None:
kwargs["padding"] = padding
if cursor is not None:
kwargs["cursor"] = cursor
if takefocus is not None:
kwargs["takefocus"] = takefocus
self._treeview = Treeview(self, **kwargs)
if heading_text is not None:
if heading_anchor is not None:
self._treeview.heading("#0",
text=heading_text,
anchor=heading_anchor)
else:
self._treeview.heading("#0", text=heading_text)
self._treeview.bind("<<TreeviewOpen>>", self._on_open)
self._treeview.bind("<<TreeviewClose>>", self._on_close)
# Without this line, horizontal scrolling doesn't work properly.
self._treeview.column("#0", stretch=False)
self._vsb['command'] = self._treeview.yview
self._hsb['command'] = self._treeview.xview
self._treeview.grid(column=0, row=0, sticky=N + S + W + E)
self._vsb.grid(column=1, row=0, sticky=N + S)
self._hsb.grid(column=0, row=1, sticky=E + W)
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
self._element_tree = None
self._item_ID_to_element = {}
if xml is not None:
self.parse_xml(xml)
except Exception as e:
T.config(yscrollcommand=S.set, state="normal")
T.insert(END, str(e) + '\n', 'redcol')
T.config(yscrollcommand=S.set, state="disabled")
## Tkinter below
root = Tk()
root.title("Updater ver: " + str(v))
root.minsize(280, 300)
frame = Frame(root, height=210, width=600, relief=SUNKEN)
frame.pack_propagate(0)
frame.pack(anchor=NE, side=TOP, padx=20, pady=20)
S = Scrollbar(frame)
T = Text(frame, height=46, width=80, wrap=WORD)
S.pack(side=RIGHT, fill=Y)
T.pack(side=BOTTOM, fill=BOTH, expand=1)
S.config(command=T.yview)
T.tag_configure('redcol', foreground='red')
T.tag_configure('blackcol', foreground='black')
T.tag_configure('greencol', background='#c8d9ea', foreground='#009900')
T.tag_configure('failed', background='#c8d9ea', foreground='red')
button = Button(
root,
text='Reopen client',
command=lambda: {restart_client(), root.destroy()})
button.place(x=180, y=250)
def __init__(self, master):
tk.Frame.__init__(self, master)
self.master = master
self.master.title("Netstat Live")
self.pack(fill=tk.BOTH, expand=tk.Y)
master.protocol("WM_DELETE_WINDOW", self.app_quit)
self._app_quit = False
self._freeze = False
self.tabs = Notebook(self)
self.tabs_frames = OrderedDict()
self.tabs_frames['TCP4'] = {'query': netstat_tcp4}
self.tabs_frames['UDP4'] = {'query': netstat_udp4}
self.tabs_frames['TCP6'] = {'query': netstat_tcp6}
self.tabs_frames['UDP6'] = {'query': netstat_udp6}
for tab in self.tabs_frames:
# Creating tabs
self.tabs_frames[tab]['tab'] = tk.Frame(self.tabs)
self.tabs.add(self.tabs_frames[tab]['tab'], text=tab)
#self.tabs_frames[tab]['tab'].pack(fill=tk.BOTH)
# Adding Treeview widget to tabs
self.tabs_frames[tab]['tbl'] = Treeview(self.tabs_frames[tab]['tab'])
self.tabs_frames[tab]['tbl']['columns'] = ('Pid', 'User', 'Local addr', 'Remote addr', 'State')
for column in self.tabs_frames[tab]['tbl']['columns']:
self.tabs_frames[tab]['tbl'].heading(column, text=column)
self.tabs_frames[tab]['tbl'].column(column, width=150)
self.tabs_frames[tab]['scrollbar_y'] = Scrollbar(self.tabs_frames[tab]['tab'], orient=tk.VERTICAL, command=self.tabs_frames[tab]['tbl'].yview)
self.tabs_frames[tab]['tbl']['yscroll'] = self.tabs_frames[tab]['scrollbar_y'].set
self.tabs_frames[tab]['scrollbar_y'].pack(side=tk.RIGHT, fill=tk.Y)
self.tabs_frames[tab]['tbl'].pack(expand=tk.Y, fill=tk.BOTH)
# Bind right click event for displaying context menu
self.tabs_frames[tab]['tbl'].bind('<Button-3>', self.context_menu_popup)
self.tabs_frames[tab]['tbl'].bind('<Button-1>', self.context_menu_unpost)
# Creating queue for each tab
self.tabs_frames[tab]['queue'] = Queue(maxsize=1)
self.tabs.pack(fill=tk.BOTH, expand=tk.Y)
# Freeze button
self.buttons = tk.Frame(master)
self.buttons.pack(side=tk.BOTTOM, fill=tk.BOTH)
self.freeze_btn = tk.Button(self.buttons, text='Freeze', command=self.freeze_btn_handler)
self.freeze_btn.pack(side=tk.RIGHT)
# Check dependencies
self._xclip = True
self._whois = True
try:
out = subprocess.check_output(['xclip', '-h'], stderr=subprocess.STDOUT)
except:
self._xclip = False
try:
out = subprocess.check_output(['whois', '--version'], stderr=subprocess.STDOUT)
except:
self._whois = False
# Connections list context menu
self._remote_addr = ''
self.context_menu = tk.Menu(self, tearoff=0)
if self._xclip:
self.context_menu.add_command(label='Copy remote addr.', command=self.xclip)
if self._whois:
self.context_menu.add_command(label='Whois', command=self.whois)
self.tabs.bind('<Button-1>', self.context_menu_unpost)
self.poll = Thread(target=self.thread)
self.poll.start()
def __init__(self,
master,
columns,
data=None,
command=None,
sort=True,
select_mode=None,
heading_anchor=CENTER,
cell_anchor=W,
style=None,
height=None,
padding=None,
adjust_heading_to_content=False,
striped_rows=None,
selection_background=None,
selection_foreground=None,
field_background=None,
heading_font=None,
heading_background=None,
heading_foreground=None,
cell_pady=2,
cell_background=None,
cell_foreground=None,
cell_font=None,
headers=True,
right_click_command=None):
self._striped_rows = striped_rows
self._columns = columns
self._number_of_rows = 0
self._number_of_columns = len(columns)
self.row = self.List_Of_Rows(self)
self.column = self.List_Of_Columns(self)
s = Style()
if style is None:
style_name = "Multicolumn_Listbox%s.Treeview" % self._style_index
self._style_index += 1
else:
style_name = style
style_map = {}
if selection_background is not None:
style_map["background"] = [('selected', selection_background)]
if selection_foreground is not None:
style_map["foreground"] = [('selected', selection_foreground)]
if style_map:
s.map(style_name, **style_map)
style_config = {}
if cell_background is not None:
style_config["background"] = cell_background
if cell_foreground is not None:
style_config["foreground"] = cell_foreground
if cell_font is None:
font_name = s.lookup(style_name, "font")
cell_font = nametofont(font_name)
else:
if not isinstance(cell_font, Font):
if isinstance(cell_font, basestring):
cell_font = nametofont(cell_font)
else:
if len(cell_font) == 1:
cell_font = Font(family=cell_font[0])
elif len(cell_font) == 2:
cell_font = Font(family=cell_font[0],
size=cell_font[1])
elif len(cell_font) == 3:
cell_font = Font(family=cell_font[0],
size=cell_font[1],
weight=cell_font[2])
else:
raise ValueError(
"Not possible more than 3 values for font")
style_config["font"] = cell_font
self._cell_font = cell_font
self._rowheight = cell_font.metrics("linespace") + cell_pady
style_config["rowheight"] = self._rowheight
if field_background is not None:
style_config["fieldbackground"] = field_background
s.configure(style_name, **style_config)
heading_style_config = {}
if heading_font is not None:
heading_style_config["font"] = heading_font
if heading_background is not None:
heading_style_config["background"] = heading_background
if heading_foreground is not None:
heading_style_config["foreground"] = heading_foreground
heading_style_name = style_name + ".Heading"
s.configure(heading_style_name, **heading_style_config)
treeview_kwargs = {"style": style_name}
if height is not None:
treeview_kwargs["height"] = height
if padding is not None:
treeview_kwargs["padding"] = padding
if headers:
treeview_kwargs["show"] = "headings"
else:
treeview_kwargs["show"] = ""
if select_mode is not None:
treeview_kwargs["selectmode"] = select_mode
self.interior = Treeview(master, columns=columns, **treeview_kwargs)
# tjw Scrollbar add
self.scrollbar = Scrollbar(master,
orient=VERTICAL,
command=self.interior.yview)
self.interior.configure(yscrollcommand=self.scrollbar.set)
self.scrollbar.grid(row=1, column=len(columns), sticky='NSE')
self.interior.grid(row=1, column=0)
#master.grid_columnconfigure(0, weight=1)
#master.grid_columnconfigure(1, weight=1)
if command is not None:
self._command = command
self.interior.bind("<<TreeviewSelect>>", self._on_select)
if right_click_command is not None:
self._right_click_command = right_click_command
self.interior.bind("<Button-3>", self._on_right_click)
for i in range(0, self._number_of_columns):
if sort:
self.interior.heading(
i,
text=columns[i],
anchor=heading_anchor,
command=lambda col=i: self.sort_by(col, descending=False))
else:
self.interior.heading(i,
text=columns[i],
anchor=heading_anchor)
if adjust_heading_to_content:
self.interior.column(i, width=Font().measure(columns[i]))
self.interior.column(i, anchor=cell_anchor)
if data is not None:
for row in data:
self.insert_row(row)
def __init__(self, master, columns, column_weights=None, column_minwidths=None, height=500, minwidth=20, minheight=20, padx=5, pady=5, cell_font=None, cell_foreground="black", cell_background="white", cell_anchor=W, header_font=None, header_background="white", header_foreground="black", header_anchor=CENTER, bordercolor = "#999999", innerborder=True, outerborder=True, stripped_rows=("#EEEEEE", "white"), on_change_data=None, mousewheel_speed = 2, scroll_horizontally=True, scroll_vertically=True):
outerborder_width = 1 if outerborder else 0
Frame.__init__(self,master, bd= 0)
self._cell_background = cell_background
self._cell_foreground = cell_foreground
self._cell_font = cell_font
self._cell_anchor = cell_anchor
self._stripped_rows = stripped_rows
self._padx = padx
self._pady = pady
self._bordercolor = bordercolor
self._innerborder_width = 1 if innerborder else 0
self._data_vars = []
self._columns = columns
self._number_of_rows = 0
self._number_of_columns = len(columns)
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(1, weight=1)
self._head = Frame(self, highlightbackground=bordercolor, highlightcolor=bordercolor, highlightthickness=outerborder_width, bd= 0)
self._head.grid(row=0, column=0, sticky=E+W)
header_separator = False if outerborder else True
for j in range(len(columns)):
column_name = columns[j]
header_cell = Header_Cell(self._head, text=column_name, borderwidth=self._innerborder_width, font=header_font, background=header_background, foreground=header_foreground, padx=padx, pady=pady, bordercolor=bordercolor, anchor=header_anchor, separator=header_separator)
header_cell.grid(row=0, column=j, sticky=N+E+W+S)
add_scrollbars = scroll_horizontally or scroll_vertically
if add_scrollbars:
if scroll_horizontally:
xscrollbar = Scrollbar(self, orient=HORIZONTAL)
xscrollbar.grid(row=2, column=0, sticky=E+W)
else:
xscrollbar = None
if scroll_vertically:
yscrollbar = Scrollbar(self, orient=VERTICAL)
yscrollbar.grid(row=1, column=1, sticky=N+S)
else:
yscrollbar = None
scrolling_area = Scrolling_Area(self, width=self._head.winfo_reqwidth(), height=height, scroll_horizontally=scroll_horizontally, xscrollbar=xscrollbar, scroll_vertically=scroll_vertically, yscrollbar=yscrollbar)
scrolling_area.grid(row=1, column=0, sticky=E+W)
self._body = Frame(scrolling_area.innerframe, highlightbackground=bordercolor, highlightcolor=bordercolor, highlightthickness=outerborder_width, bd= 0)
self._body.pack()
def on_change_data():
scrolling_area.update_viewport()
else:
self._body = Frame(self, height=height, highlightbackground=bordercolor, highlightcolor=bordercolor, highlightthickness=outerborder_width, bd= 0)
self._body.grid(row=1, column=0, sticky=N+E+W+S)
if column_weights is None:
for j in range(len(columns)):
self._body.grid_columnconfigure(j, weight=1)
else:
for j, weight in enumerate(column_weights):
self._body.grid_columnconfigure(j, weight=weight)
if column_minwidths is not None:
for j, minwidth in enumerate(column_minwidths):
if minwidth is None:
header_cell = self._head.grid_slaves(row=0, column=j)[0]
minwidth = header_cell.winfo_reqwidth()
self._body.grid_columnconfigure(j, minsize=minwidth)
else:
for j in range(len(columns)):
header_cell = self._head.grid_slaves(row=0, column=j)[0]
minwidth = header_cell.winfo_reqwidth()
self._body.grid_columnconfigure(j, minsize=minwidth)
self._on_change_data = on_change_data
def __init__(self):
Frame.__init__(self)
self.style = Style()
self.style.theme_use("default")
self.master.title("Log viewer")
self.pack(fill=BOTH, expand=True)
self.used = [] # List of currently plotted series ([str])
self.series = {} # List of all series ({str -> [number]})
self.names = [] # List of all nodes in tree view ([str])
self.queues = [] # List of all queues ([str])
self.logs = {} # List of all text logs ({str -> [str]})
self.rowconfigure(1, weight=1)
self.columnconfigure(6, weight=3)
self.columnconfigure(11, weight=1)
# Series selection takes row 1-2, col 0-2
self.series_ui = Treeview(self)
self.series_ui.grid(row=1, column=0, columnspan=2, rowspan=2, sticky=N+S)
self.series_ui.configure(show="tree")
self.series_ui.bind("<Double-Button-1>", self.onselect)
self.series_ui.tag_configure("graphall", foreground="#070")
self.series_ui.tag_configure("graphnone", foreground="#000")
self.series_ui.tag_configure("graphsome", foreground="#007")
series_ui_scroll = Scrollbar(self, command=self.series_ui.yview, orient=VERTICAL)
series_ui_scroll.grid(row=1, column=2, rowspan=2, sticky=N+S)
self.series_ui["yscrollcommand"] = series_ui_scroll.set
# The plot takes row 1-2, col 3-6
move_mode = StringVar()
move_mode.set("pan")
show_path = IntVar()
show_path.set(0)
event_bars = IntVar()
event_bars.set(1)
show_debug = IntVar()
show_debug.set(1)
show_error = IntVar()
show_error.set(1)
show_warning = IntVar()
show_warning.set(1)
show_info = IntVar()
show_info.set(1)
self.plot = HackPlot(self, move_mode, show_path, event_bars,
[(show_debug, "[DEBUG]"), (show_error, "[ERROR]"), (show_warning, "[WARNING]"), (show_info, "[INFO]")])
self.plot.canvas.grid(row=1, column=3, columnspan=4, rowspan=2, sticky=N+S+E+W)
# Text logs take row 1-2, col 7-12
self.plot.listbox.grid(row=1, column=7, columnspan=5, sticky=N+S+E+W)
listbox_yscroll = Scrollbar(self, command=self.plot.listbox.yview, orient=VERTICAL)
listbox_yscroll.grid(row=1, column=12, sticky=N+S)
self.plot.listbox["yscrollcommand"] = listbox_yscroll.set
listbox_xscroll = Scrollbar(self, command=self.plot.listbox.xview, orient=HORIZONTAL)
listbox_xscroll.grid(row=2, column=7, columnspan=5, sticky=E+W)
self.plot.listbox["xscrollcommand"] = listbox_xscroll.set
# Controls take row 0, col 0-12
Button(self, text="Load Directory", command=self.loaddir).grid(row=0, column=0)
Button(self, text="Load File", command=self.loadfile).grid(row=0, column=1)
Button(self, text="Fit X", command=self.plot.fit_x).grid(row=0, column=3, sticky=W)
Button(self, text="Fit Y", command=self.plot.fit_y).grid(row=0, column=4, sticky=W)
Button(self, text="Fit Auto", command=self.plot.fit_auto).grid(row=0, column=5, sticky=W)
Button(self, text="Fit Tele", command=self.plot.fit_tele).grid(row=0, column=6, sticky=W)
# Plot controls in a subframe to manage padding so it doesn't look awful
move_mode_control = Frame(self, padx=10)
Radiobutton(move_mode_control, text="Pan", value="pan", variable=move_mode).grid(row=0, column=0, sticky=W)
Radiobutton(move_mode_control, text="Zoom In", value="zoomin", variable=move_mode).grid(row=0, column=1, sticky=W)
Radiobutton(move_mode_control, text="Zoom Out", value="zoomout", variable=move_mode).grid(row=0, column=2, sticky=W)
move_mode_control.grid(row=0, column=7, sticky=W)
Checkbutton(self, text="Event Bars", variable=event_bars, command=self.plot.show_textlogs).grid(row=0, column=8, sticky=W)
Checkbutton(self, text="Debug", variable=show_debug, command=self.plot.show_textlogs).grid(row=0, column=9, sticky=W)
Checkbutton(self, text="Error", variable=show_error, command=self.plot.show_textlogs).grid(row=0, column=10, sticky=W)
Checkbutton(self, text="Warning", variable=show_warning, command=self.plot.show_textlogs).grid(row=0, column=11, sticky=W)
Checkbutton(self, text="Info", variable=show_info, command=self.plot.show_textlogs).grid(row=0, column=12, sticky=W)
Checkbutton(self, text="Directories", variable=show_path, command=self.plot.show_textlogs).grid(row=0, column=13, sticky=E)
