def run(self, graphic):
window = gtk.Window()
self.__window = window
window.set_default_size(200, 200)
vbox = gtk.VBox()
window.add(vbox)
render = GtkGraphicRenderer(graphic)
self.__render = render
vbox.pack_end(render, True, True, 0)
hbox = gtk.HBox()
vbox.pack_start(hbox, False, False, 0)
smaller_zoom = gtk.Button("Zoom Out")
smaller_zoom.connect("clicked", self.__set_smaller_cb)
hbox.pack_start(smaller_zoom)
bigger_zoom = gtk.Button("Zoom In")
bigger_zoom.connect("clicked", self.__set_bigger_cb)
hbox.pack_start(bigger_zoom)
output_png = gtk.Button("Output Png")
output_png.connect("clicked", self.__output_png_cb)
hbox.pack_start(output_png)
window.connect('destroy', gtk.main_quit)
window.show_all()
#gtk.bindings_activate(gtk.main_quit, 'q', 0)
gtk.main()
python类HBox()的实例源码
def create_text_hbox(self, label, value, trace, sensitivity_group, constraints=None):
hbox_main = gtk.HBox()
label_text = gtk.Label(label.title())
label_text.set_alignment(0, 0.5)
label_text.set_padding(8,8)
entry_text = gtk.Entry()
entry_text.set_text(value)
hbox_main.pack_start(label_text)
hbox_main.pack_start(entry_text)
self.plugin_config_widgets.append(entry_text)
self.plugin_config_traces.append(trace)
sensitivity_group.append(label_text)
sensitivity_group.append(entry_text)
return hbox_main
def create_number_hbox(self, label, value, trace, sensitivity_group, constraints=None):
hbox_main = gtk.HBox()
label_text = gtk.Label(label.title())
label_text.set_alignment(0, 0.5)
label_text.set_padding(8,8)
adjustment = gtk.Adjustment(value, 0, sys.maxint, 1)
spinbutton_value = gtk.SpinButton(adjustment)
spinbutton_value.set_value(value)
hbox_main.pack_start(label_text)
hbox_main.pack_start(spinbutton_value)
self.plugin_config_widgets.append(spinbutton_value)
self.plugin_config_traces.append(trace)
sensitivity_group.append(label_text)
sensitivity_group.append(spinbutton_value)
return hbox_main
def create_path_hbox(self, label, value, trace, sensitivity_group, constraints=None):
hbox_main = gtk.HBox()
label_text = gtk.Label(label.title())
label_text.set_alignment(0, 0.5)
label_text.set_padding(8,8)
entry_filepath = gtk.Entry()
entry_filepath.set_text(value)
button_select_folder = gtk.ToolButton(
gtk.image_new_from_file(os.path.join(definitions.ICONS_DIR, "open_small.png")))
button_select_folder.connect("clicked", self.select_folder, entry_filepath)
hbox_main.pack_start(label_text)
hbox_main.pack_start(entry_filepath)
hbox_main.pack_start(button_select_folder)
self.plugin_config_widgets.append(entry_filepath)
self.plugin_config_traces.append(trace)
sensitivity_group.append(label_text)
sensitivity_group.append(entry_filepath)
sensitivity_group.append(button_select_folder)
return hbox_main
def create_filepath_hbox(self, label, value, trace, sensitivity_group, constraints=None):
hbox_main = gtk.HBox()
label_text = gtk.Label(label.title())
label_text.set_alignment(0, 0.5)
label_text.set_padding(8,8)
entry_filepath = gtk.Entry()
entry_filepath.set_text(value)
button_select_folder = gtk.ToolButton(
gtk.image_new_from_file(os.path.join(definitions.ICONS_DIR, "open_small.png")))
button_select_folder.connect("clicked", self.select_file, entry_filepath)
hbox_main.pack_start(label_text)
hbox_main.pack_start(entry_filepath)
hbox_main.pack_start(button_select_folder)
self.plugin_config_widgets.append(entry_filepath)
self.plugin_config_traces.append(trace)
sensitivity_group.append(label_text)
sensitivity_group.append(entry_filepath)
sensitivity_group.append(button_select_folder)
return hbox_main
def __init__(self):
imageLoc = random.choice(os.listdir(os.path.join(WORKINGDIR, "data", "splashScreens")))
imageSize = self.get_image_size(open(os.path.join(WORKINGDIR, "data", "splashScreens", imageLoc), 'rb').read())
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_decorated(False)
self.window.set_title("Micro:Pi")
self.window.set_icon_from_file(os.path.join(WORKINGDIR, "data", "icon.png"))
self.window.set_size_request(imageSize[0], -1)
self.window.set_position(gtk.WIN_POS_CENTER)
main_vbox = gtk.VBox(False, 1)
self.window.add(main_vbox)
hbox = gtk.HBox(False, 0)
self.img = gtk.Image()
self.img.set_from_file(os.path.join(WORKINGDIR, "data", "splashScreens", imageLoc))
main_vbox.pack_start(self.img, True, True)
self.lbl = gtk.Label('')
font = pango.FontDescription("Monospace 7")
self.lbl.modify_font(font)
main_vbox.pack_end(self.lbl, False, False)
self.refresh()
self.window.show_all()
self.refresh()
def _fill_container(container, items, options, id_name):
for item in items:
hbox = gtk.HBox()
label_id = gtk.Label()
label_id.set_text(str(getattr(item, id_name)))
hbox.pack_start(label_id, expand=False)
widget = gtk.RadioButton(label=options[0]) # first widget
hbox.pack_start(widget, expand=False, padding=4)
for option in options[1:]: # create rest of the widgets, use first one as a group
next_widget = gtk.RadioButton(widget, label=option)
hbox.pack_start(next_widget, expand=False, padding=4)
label = gtk.Label()
label.set_text(item.name)
hbox.pack_start(label, padding=16, expand=False)
hbox.show_all()
label_id.hide()
container.pack_start(hbox)
def _setup_onionskin(self):
stock_size = gtk.ICON_SIZE_BUTTON
button_size = 30
onionskin_bar = gtk.HBox()
# active onionskin
b_active = Utils.toggle_button_stock(gtk.STOCK_DND_MULTIPLE,stock_size)
# connect widgets
b_active.connect("clicked",self.on_onionskin)
# tooltips
b_active.set_tooltip_text("enable/disable the onion skin effect")
# add to the disable on play list
w = [b_active]
map(lambda x: self.widgets_to_disable.append(x),w)
# packing everything in gbar
map(lambda x: onionskin_bar.pack_start(x,False,False,0),w)
return onionskin_bar
def make_label(self):
self.label = gtk.HBox(False, 0)
self.text_label = gtk.Label("")
self.text_label.show()
self.label.pack_start(self.text_label, 1, 1, 1)
button = gtk.Button()
button.set_relief(gtk.RELIEF_NONE)
button.set_focus_on_click(False)
icon = gtk.image_new_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU)
icon.show()
button.add(icon)
button.connect("clicked", lambda x: self.emit("want-close"))
button.show()
self.label.pack_start(button, 0, 0, 0)
self.label.show()
def __init__(self, columns):
gtk.HBox.__init__(self, True, 0)
self.columns = columns
types = tuple([x for x, y in columns])
self.__store = gtk.ListStore(*types)
self.__view = gtk.TreeView(self.__store)
self.pack_start(self.__view, 1, 1, 1)
self.__toggle_connected = False
self._make_view()
self.__view.show()
def make_callsigns(self):
box = gtk.HBox(True, 2)
fixed = self.rthread.radio.get_features().has_implicit_calls
frame = gtk.Frame(_("Your callsign"))
self.editor_ucall = CallsignEditor(first_fixed=fixed)
self.editor_ucall.set_size_request(-1, 200)
self.editor_ucall.show()
frame.add(self.editor_ucall)
frame.show()
box.pack_start(frame, 1, 1, 0)
frame = gtk.Frame(_("Repeater callsign"))
self.editor_rcall = CallsignEditor(first_fixed=fixed)
self.editor_rcall.set_size_request(-1, 200)
self.editor_rcall.show()
frame.add(self.editor_rcall)
frame.show()
box.pack_start(frame, 1, 1, 0)
frame = gtk.Frame(_("My callsign"))
self.editor_mcall = CallsignEditor()
self.editor_mcall.set_size_request(-1, 200)
self.editor_mcall.show()
frame.add(self.editor_mcall)
frame.show()
box.pack_start(frame, 1, 1, 0)
box.show()
return box
def add_field(self, label, widget, validator=None):
box = gtk.HBox(True, 2)
lab = gtk.Label(label)
lab.show()
widget.set_size_request(150, -1)
widget.show()
box.pack_start(lab, 0, 0, 0)
box.pack_start(widget, 0, 0, 0)
box.show()
# pylint: disable-msg=E1101
self.vbox.pack_start(box, 0, 0, 0)
self.__fields[label] = widget
def open_file():
window = main_window('toplevel', 'Flash Player', 550, 400)
vbox = gtk.VBox()
hbox = gtk.HBox()
button = gtk.Button("????")
button.set_size_request(200, 70)
button.connect("clicked", on_open_clicked, window, vbox)
vbox.pack_start(hbox, fill=False)
hbox.pack_start(button, fill=False)
window.add(vbox)
window.show_all()
def get_password(self,parent):
dialog = gtk.Dialog("Configure System Password",parent,gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT,(gtk.STOCK_CANCEL,gtk.RESPONSE_REJECT,gtk.STOCK_OK,gtk.RESPONSE_ACCEPT))
self.pass1 = gtk.HBox()
self.label1 = gtk.Label(" Passsword: ")
self.pass1.pack_start(self.label1,False,True,0)
self.password1 = gtk.Entry()
self.password1.set_visibility(False)
self.pass1.pack_start(self.password1,False,True,0)
dialog.vbox.add(self.pass1)
self.pass2 = gtk.HBox()
self.label2 = gtk.Label(" Verify Password: ")
self.pass2.pack_start(self.label2,False,True,0)
self.password2 = gtk.Entry()
self.password2.set_visibility(False)
self.pass2.pack_start(self.password2,False,True,0)
dialog.vbox.add(self.pass2)
dialog.show_all()
response = dialog.run()
if response == gtk.RESPONSE_ACCEPT:
self.a = self.password1.get_text()
self.b = self.password2.get_text()
dialog.destroy()
else:
self.a = ''
self.b = ''
dialog.destroy()
# Configure Network Dialog
def fill_bases(self, baseExplorers):
box = gtk.HBox()
for b in baseExplorers:
box.add(b.newAttributeWidget(self))
row = self.propertyLabels.get('bases')[0]
self.subtable["properties"].attach(box, 1, 2, row, row+1)
box.show_all()
def create_checkbox_hbox(self, label, value, trace, sensitivity_group, constraints=None):
hbox_main = gtk.HBox()
checkbutton_option = gtk.CheckButton(label.title())
checkbutton_option.set_active(value)
if label.lower() == "enabled":
checkbutton_option.connect("toggled", self.enabled_checkbox_toggled, sensitivity_group)
hbox_main.pack_start(checkbutton_option)
self.plugin_config_widgets.append(checkbutton_option)
self.plugin_config_traces.append(trace)
sensitivity_group.append(checkbutton_option)
self.sensitivity_groups.append(sensitivity_group)
self.sensitivity_groups_switch.append(checkbutton_option)
return hbox_main
def create_radio_hbox(self, label, value, trace, sensitivity_group, constraints=None):
hbox_main = gtk.HBox()
label_text = gtk.Label(label.title())
label_text.set_alignment(0, 0.5)
label_text.set_padding(8,8)
radiobuttons = []
if constraints is None:
options = [value]
else:
options = constraints
previous_button = None
for option in options:
new_button = gtk.RadioButton(previous_button, option)
if option == value:
new_button.set_active(True)
radiobuttons.append(new_button)
previous_button = new_button
hbox_main.pack_start(label_text)
for radiobutton in radiobuttons:
hbox_main.pack_start(radiobutton)
self.plugin_config_widgets.append(radiobuttons)
self.plugin_config_traces.append(trace)
sensitivity_group.append(label_text)
sensitivity_group.append(radiobuttons)
return hbox_main
def create_options_hbox(self, label, value, trace, sensitivity_group, constraints=None):
hbox_main = gtk.HBox()
label_text = gtk.Label(label.title())
label_text.set_alignment(0, 0.5)
label_text.set_padding(8,8)
checkbuttons = []
selected_options = value
if constraints is None:
options = []
else:
options = constraints
for option in options:
new_button = gtk.CheckButton(option)
if option in selected_options:
new_button.set_active(True)
checkbuttons.append(new_button)
hbox_main.pack_start(label_text)
for checkbutton in checkbuttons:
hbox_main.pack_start(checkbutton)
self.plugin_config_widgets.append(checkbuttons)
self.plugin_config_traces.append(trace)
sensitivity_group.append(label_text)
sensitivity_group.append(checkbuttons)
return hbox_main
def create_time_hbox(self, label, value, trace, sensitivity_group, constraints=None):
hbox_main = gtk.HBox()
label_text = gtk.Label(label.title())
label_text.set_alignment(0, 0.5)
label_text.set_padding(8,8)
adjustment = gtk.Adjustment(value, 0, sys.maxint, 1)
spinbutton_value = gtk.SpinButton(adjustment)
combobox_units = gtk.combo_box_new_text()
t_value, units = self.get_time_value_and_units(value)
spinbutton_value.set_value(t_value)
options = ["seconds", "minutes", "hours", "days", "weeks"]
for option in options:
combobox_units.append_text(option)
selected_index = options.index(units)
combobox_units.set_active(selected_index)
hbox_main.pack_start(label_text)
hbox_main.pack_start(spinbutton_value)
hbox_main.pack_start(combobox_units)
self.plugin_config_widgets.append([spinbutton_value, combobox_units])
self.plugin_config_traces.append(trace)
sensitivity_group.append(label_text)
sensitivity_group.append(spinbutton_value)
return hbox_main
#TODO: Refactor these
def show(self):
"""Opens a GTK window and puts the heatmap in it. Intelligent enough to work with the GUI as well."""
window_only = 1 #What needs to be destroyed when the window is destroyed?
if HMAP_ENABLED and DISPLAY_ENABLED:
def destroy():
if window_only:
window.destroy()
else:
gtk.main_quit()
gtk.gdk.threads_enter()
window = gtk.Window()
window.set_title("Showing heatmap...")
window.set_border_width(10)
window.set_resizable(False)
window.connect("delete_event", lambda w, e: destroy())
backbone = gtk.HBox(True)
image = gtk.Image()
image.set_from_pixbuf(self._image_to_pixbuf(self.im))
backbone.pack_start(image)
window.add(backbone)
window.show_all()
gtk.gdk.threads_leave()
if gtk.main_level() == 0:
window_only = 0
gtk.main()
else:
raise "HmapError", "Error loading modules or unable to display"
def get_filename(self, w):
def set_filename(w):
self.filename = box.get_filename()
self.parser = getattr(parsers, 'Parse' + parser_lst[button.get_active()])
box.destroy()
Thread(target = self._announce_fileparser).start()
parser_lst = []
#Get the names
for key in parsers.__dict__:
if key.find('Parse') == 0:
pname = key[5:]
if pname == 'Normal': #Pretty sleazy way of hardcoding default
parser_lst.insert(0, pname)
else:
parser_lst.append(pname)
box = gtk.FileSelection("Select file")
box.ok_button.connect("clicked", set_filename)
box.cancel_button.connect("clicked", lambda w: box.destroy())
box.set_resizable(False)
button = gtk.combo_box_new_text()
for text in parser_lst:
button.append_text(text)
button.set_active(0)
parserbox = gtk.HBox(False)
buttonlabel = gtk.Label('Select a Parser:')
for obj in (buttonlabel, button):
parserbox.pack_start(obj)
box.action_area.pack_start(parserbox)
box.show_all()
def fill_bases(self, baseExplorers):
box = gtk.HBox()
for b in baseExplorers:
box.add(b.newAttributeWidget(self))
row = self.propertyLabels.get('bases')[0]
self.subtable["properties"].attach(box, 1, 2, row, row+1)
box.show_all()
def _main_window_default_style(self):
wcfg = self.config['main_window']
vbox = gtk.VBox(False, 5)
vbox.set_border_width(5)
# TODO: Allow user to configure alignment of message, padding?
lbl = gtk.Label()
lbl.set_markup(wcfg.get('message', ''))
lbl.set_alignment(0.5, 0.5)
if wcfg.get('image'):
self._set_background_image(vbox, wcfg.get('image'))
button_box = gtk.HBox(False, 5)
self._main_window_indicator(vbox, button_box)
self._main_window_add_actions(button_box)
vbox.pack_start(lbl, True, True)
vbox.pack_end(button_box, False, True)
self.main_window['window'].add(vbox)
self.main_window.update({
'vbox': vbox,
'label': lbl,
'buttons': button_box})
# TODO: Add other window styles?
def add_query_widget(container, field_names, sel_qf='title', sel_comm='contains', text=''):
hbox = gtk.HBox()
cb = gtk.combo_box_new_text()
select = 0
for i, field in enumerate(QUERY_FIELDS):
if sel_qf == field:
select = i
cb.append_text(field_names[field])
cb.set_active(select)
action_cb = gtk.combo_box_new_text()
select = 0
for i, command in enumerate(QUERY_COMMANDS):
if sel_comm == command:
select = i
action_cb.append_text(QUERY_COMMAND_NAMES[command])
action_cb.set_active(select)
entry = gtk.Entry()
entry.set_text(text)
button = gtk.Button(stock=gtk.STOCK_DELETE)
button.connect("clicked", lambda w: hbox.destroy())
hbox.pack_start(cb, expand=False)
hbox.pack_start(action_cb, expand=False)
hbox.pack_start(entry, expand=True, padding=8)
hbox.pack_start(button, expand=False, fill=False)
hbox.show_all()
container.pack_start(hbox)
gnome_connection_manager.py 文件源码
项目：gnome-connection-manager
作者: mjun
项目源码
文件源码
阅读 21
收藏 0
点赞 0
评论 0
def __init__(self, title, owner_, widget_, popup_):
gtk.HBox.__init__(self, False, 0)
self.title = title
self.owner = owner_
self.eb = gtk.EventBox()
label = self.label = gtk.Label()
self.eb.connect('button-press-event', self.popupmenu, label)
label.set_alignment(0.0, 0.5)
label.set_text(title)
self.eb.add(label)
self.pack_start(self.eb)
label.show()
self.eb.show()
close_image = gtk.image_new_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU)
image_w, image_h = gtk.icon_size_lookup(gtk.ICON_SIZE_MENU)
self.widget=widget_
self.popup = popup_
close_btn = gtk.Button()
close_btn.set_relief(gtk.RELIEF_NONE)
close_btn.connect('clicked', self.on_close_tab, owner_)
close_btn.set_size_request(image_w+7, image_h+6)
close_btn.add(close_image)
style = close_btn.get_style();
self.eb2 = gtk.EventBox()
self.eb2.add(close_btn)
self.pack_start(self.eb2, False, False)
self.eb2.show()
close_btn.show_all()
self.is_active = True
self.show()
def __init__(self, parser, max_tree_depth):
self.parser = parser
self._max_tree_depth = max_tree_depth
self.search_thread = None
self.search_lock = threading.Lock()
self.name_entry = name_entry = gtk.Entry()
name_entry.connect('activate', self.on_name_entry_activate)
search_button = self.search_button = gtk.Button(stock=gtk.STOCK_FIND)
search_button.connect('clicked', self.on_search)
search_button.set_no_show_all(True)
search_button.show()
stop_button = self.stop_button = gtk.Button(stock=gtk.STOCK_STOP)
stop_button.connect('clicked', self.stop_search)
stop_button.set_no_show_all(True)
self.progress = progress = gtk.ProgressBar()
progress.set_size_request(-1, 8)
name_box = gtk.HBox(spacing=8)
name_box.set_border_width(8)
name_box.pack_start(name_entry, True, True)
name_box.pack_start(search_button, False)
name_box.pack_start(stop_button, False)
self.store = gtk.TreeStore(str, str, str, str) # name, icon, fnstyle, info
self.treeview = treeview = self._create_treeview(self.store)
scroller = gtk.ScrolledWindow()
scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroller.add(treeview)
settings_view = SettingsView(max_depth_value=max_tree_depth)
settings_view.on_max_depth_changed = self.on_max_depth_changed
extension = gtk.expander_new_with_mnemonic('_Settings')
extension.add(settings_view.view)
vbox = gtk.VBox()
vbox.pack_start(name_box, False)
vbox.pack_start(progress, False)
vbox.pack_start(scroller, True, True)
vbox.pack_start(extension, False)
self.window = window = gtk.Window()
window.set_title(Application.title)
window.set_default_size(800, 600)
window.set_icon(Application.get_icon())
window.add(vbox)
def __init__(self, parent, notebook):
Dialog.__init__(self, parent,
_('Pages By Number Of Links'), # T: dialog title
buttons=gtk.BUTTONS_CLOSE
)
self.notebook = notebook
self.direction_input = gtk.combo_box_new_text()
for dir in sorted(self.LABELS):
self.direction_input.append_text(self.LABELS[dir])
self.uistate.setdefault('link_direction', LINK_DIR_BACKWARD, self.LABELS.keys())
gtk_combobox_set_active_text(
self.direction_input,
self.LABELS[self.uistate['link_direction']]
)
self.direction_input.connect('changed', self.on_direction_input_changed)
hbox = gtk.HBox()
hbox.pack_start(gtk.Label(_('Trace Links')+':'), False)
hbox.add(self.direction_input)
self.vbox.pack_start(hbox, False)
self.listview = SingleClickTreeView(gtk.ListStore(int, str))
self.listview.set_reorderable(True)
for i, label in enumerate((_('#'), _('Page'))):
column = gtk.TreeViewColumn(label, gtk.CellRendererText(), text=i)
column.set_sort_column_id(i)
self.listview.append_column(column)
# TODO: self.listview.connect('row-activated', self.on_row_activated())
self.vbox.add(ScrolledWindow(self.listview))
self.populate_listview()
def searchfunc(self,widget):
fileName = self.searchfile.get_text()
paths = "\n"
for root, dirs, files in os.walk('/home', topdown=False):
for name in files:
if name == fileName:
paths += " " + str(os.path.join(root, name)) + " \n\n"
for name in dirs:
if name == fileName:
paths += " " + str(os.path.join(root, name)) + " \n\n"
paths = paths[:-1]
if len(paths) > 0 :
self.popup = gtk.Window()
self.popup.set_title( "Paths" )
vbox = gtk.VBox(False,0)
hbox = gtk.HBox(False)
label = gtk.Label(paths)
label.set_line_wrap( True )
label.connect( "size-allocate",self.size_allocate)
vbox.pack_start(gtk.Label(paths),True,False,0)
closeButton = gtk.Button(" Close ")
closeButton.set_sensitive(True)
closeButton.connect("clicked",self.on_destroy)
hbox.pack_start(closeButton,True,False,0)
vbox.pack_start(hbox,True,False,10)
self.popup.add(vbox)
self.popup.set_type_hint( gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
self.popup.show_all()
def spin_button(name="variable",number_type="int",value=0,min=1,max=100,advance=1):
adjustment = gtk.Adjustment(value,min,max,advance,advance)
digits = 0
if number_type != "int":
digits = 3
l = gtk.Label(name)
b = gtk.SpinButton(adjustment,0,digits)
h = gtk.HBox()
h.pack_start(l)
h.pack_start(b)
return h,adjustment
def _setup_editbar(self):
stock_size = gtk.ICON_SIZE_BUTTON
edit_bar = gtk.HBox()
b_back = Utils.button_stock(gtk.STOCK_GO_BACK,stock_size)
b_forward = Utils.button_stock(gtk.STOCK_GO_FORWARD,stock_size)
b_rem = Utils.button_stock(gtk.STOCK_REMOVE,stock_size)
b_add = Utils.button_stock(gtk.STOCK_ADD,stock_size)
b_copy = Utils.button_stock(gtk.STOCK_COPY,stock_size)
# add to the disable on play list
w = [b_back,b_forward,b_rem,b_add,b_copy]
map(lambda x: self.widgets_to_disable.append(x),w)
# connect callbacks:
b_rem.connect("clicked",self.on_remove) # remove frame
b_add.connect("clicked",self.on_add) # add frame
b_copy.connect("clicked",self.on_add,True) # add frame
b_back.connect("clicked",self.on_move,PREV)
b_forward.connect("clicked",self.on_move,NEXT)
# tooltips
b_rem.set_tooltip_text("Remove a frame/layer")
b_add.set_tooltip_text("Add a frame/layer")
b_copy.set_tooltip_text("Duplicate the atual selected frame")
b_back.set_tooltip_text("Move the atual selected frame backward")
b_forward.set_tooltip_text("Move the atual selected frame forward")
# packing everything in gbar
map(lambda x: edit_bar.pack_start(x,False,False,0),w)
return edit_bar
