def __init__(self):
xdot.DotWindow.__init__(self)
self.widget.connect('clicked', self.on_url_clicked)
toolbar = self.uimanager.get_widget('/ToolBar')
item = gtk.ToolButton(gtk.STOCK_SAVE)
item.set_tooltip_markup("Save")
item.connect('clicked', self.on_save)
item.show()
toolbar.insert(item, 0)
item = gtk.ToolButton(gtk.STOCK_NEW)
item.set_tooltip_markup("New project")
item.connect('clicked', self.on_newproject)
item.show()
toolbar.insert(item, 0)
vbox = self.get_child()
hbox = gtk.HBox()
label = gtk.Label("Search symbol: ")
hbox.pack_start(label, False)
label.show()
entry = gtk.Entry(max=0)
entry.connect('activate', self.on_symbol_enter)
hbox.pack_start(entry, True, True, 10)
entry.show()
vbox.pack_start(hbox, False)
vbox.reorder_child(hbox, 1)
hbox.show()
""" code brower, maybe someday I will implement it """
def __init__(self):
super(PyApp, self).__init__()
self.set_title("Submenu")
self.set_size_request(350, 300)
self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(6400, 6400, 6400))
self.set_position(gtk.WIN_POS_CENTER)
upper = gtk.Toolbar()
upper.set_style(gtk.TOOLBAR_ICONS)
newtb = gtk.ToolButton(gtk.STOCK_NEW)
opentb = gtk.ToolButton(gtk.STOCK_OPEN)
savetb = gtk.ToolButton(gtk.STOCK_SAVE)
upper.insert(newtb, 0)
upper.insert(opentb, 1)
upper.insert(savetb, 2)
lower = gtk.Toolbar()
lower.set_style(gtk.TOOLBAR_ICONS)
quittb = gtk.ToolButton(gtk.STOCK_QUIT)
quittb.connect("clicked", gtk.main_quit)
lower.insert(quittb, 0)
vbox = gtk.VBox(False, 0)
vbox.pack_start(upper, False, False, 0)
vbox.pack_start(lower, False, False, 0)
self.add(vbox)
self.connect("destroy", gtk.main_quit)
self.show_all()
def __init__(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_size_request(640, 480)
self.window.maximize()
#stop event loop on window destroy
self.window.connect("destroy", self.quit)
#a VBox is a container that holds other GUI objects primarily for layout
self.outer_vbox = gtk.VBox()
#toolbar which contains the open and quit buttons
self.toolbar = gtk.Toolbar()
#create open and quit buttons and icons
#add buttons to toolbar
#associate buttons with correct handlers
open_icon = gtk.Image()
quit_icon = gtk.Image()
folder_icon = gtk.Image()
open_icon.set_from_stock(gtk.STOCK_OPEN, gtk.ICON_SIZE_LARGE_TOOLBAR)
folder_icon.set_from_stock(gtk.STOCK_DIRECTORY, gtk.ICON_SIZE_LARGE_TOOLBAR)
quit_icon.set_from_stock(gtk.STOCK_QUIT, gtk.ICON_SIZE_LARGE_TOOLBAR)
self.open_button = gtk.ToolButton(icon_widget=open_icon)
self.folder_button = gtk.ToolButton(icon_widget=folder_icon)
self.quit_button = gtk.ToolButton(icon_widget=quit_icon)
self.open_button.connect("clicked", self.show_file_chooser)
self.folder_button.connect("clicked", self.show_folder_chooser)
self.quit_button.connect("clicked", self.quit)
self.toolbar.insert(self.open_button, 0)
self.toolbar.insert(self.folder_button,1)
self.toolbar.insert(self.quit_button, 2)
#a control to select which file to open
self.file_chooser = gtk.FileChooserWidget()
self.file_chooser.connect("file_activated", self.load_logfile)
#
self.folder_chooser = gtk.FileChooserDialog(action=gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
parent=self.window,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
#a ListStore holds data that is tied to a list view
#this ListStore will store tabular data of the form:
#line_numer, remote_host, status, bytes_sent, logline
self.loglines_store = gtk.ListStore(int, str, str, int, str)
#associate the tree with the data...
self.loglines_tree = gtk.TreeView(model=self.loglines_store)
#...and set up the proper columns for it
self.add_column(self.loglines_tree, 'Line Number', 0)
self.add_column(self.loglines_tree, 'Remote Host', 1)
self.add_column(self.loglines_tree, 'Status', 2)
self.add_column(self.loglines_tree, 'Bytes Sent', 3)
self.add_column(self.loglines_tree, 'Logline', 4)
#make the area that holds the apache log scrollable
self.loglines_window = gtk.ScrolledWindow()
#pack things together
self.window.add(self.outer_vbox)
self.outer_vbox.pack_start(self.toolbar, False, False)
self.outer_vbox.pack_start(self.file_chooser)
self.outer_vbox.pack_start(self.loglines_window)
self.loglines_window.add(self.loglines_tree)
#make everythingvisible
self.window.show_all()
#but specifically hide the file chooser
self.file_chooser.hide()
def __init__(self):
super(PyAppUndoRedoToolbar, self).__init__()
self.set_title("Undo and Redo")
self.set_size_request(350, 300)
self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(6400, 6400, 6440))
self.set_position(gtk.WIN_POS_CENTER)
self.count = 2
toolbar = gtk.Toolbar()
toolbar.set_style(gtk.TOOLBAR_ICONS)
self.undo = gtk.ToolButton(gtk.STOCK_UNDO)
self.redo = gtk.ToolButton(gtk.STOCK_REDO)
sep = gtk.SeparatorToolItem()
quittb = gtk.ToolButton(gtk.STOCK_QUIT)
toolbar.insert(self.undo, 0)
toolbar.insert(self.redo, 1)
toolbar.insert(sep, 2)
toolbar.insert(quittb, 3)
self.undo.connect("clicked", self.on_undo)
self.redo.connect("clicked", self.on_redo)
quittb.connect("clicked", gtk.main_quit)
vbox = gtk.VBox(False, 2)
vbox.pack_start(toolbar, False, False, 0)
self.add(vbox)
self.connect("destroy", gtk.main_quit)
self.show_all()
def __init__(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("Statusbar")
self.window.connect("delete_event", self.delete_event)
self.window.resize(300, 100)
vbox = gtk.VBox()
vbox.set_spacing(6)
vbox.pack_start(gtk.Label("gtkstatusbar example"), True, True, 0)
statusbar = gtk.Statusbar()
store = gtk.ListStore(gobject.TYPE_STRING)
combo = gtk.ComboBox(store)
cell = gtk.CellRendererText()
combo.pack_start(cell, True)
combo.add_attribute(cell, 'text', 0)
combo.insert_text(0, "Apple")
combo.insert_text(1, "Banana")
combo.insert_text(2, "Cherry")
statusbar.add(combo)
statusbar.push(0, "This is some text in the statusbar")
statusbar.add(gtk.ToolButton(gtk.STOCK_ABOUT))
statusbar.add(gtk.ToolButton(gtk.STOCK_OPEN))
vbox.pack_start(statusbar, False, False, 0)
self.window.add(vbox)
vbox.show_all()
self.window.show()
def get_toolitems(self):
"""Return the tool bar items specific to this view."""
items = []
expand_button = gtk.ToolButton()
image = gtk.image_new_from_stock(gtk.STOCK_ADD,
gtk.ICON_SIZE_SMALL_TOOLBAR)
expand_button.set_icon_widget(image)
expand_button.set_label("Expand")
self._set_tooltip(expand_button, "Tree View - Expand all")
expand_button.connect('clicked', lambda x: self.ttreeview.expand_all())
items.append(expand_button)
collapse_button = gtk.ToolButton()
image = gtk.image_new_from_stock(gtk.STOCK_REMOVE,
gtk.ICON_SIZE_SMALL_TOOLBAR)
collapse_button.set_icon_widget(image)
collapse_button.set_label("Collapse")
collapse_button.connect('clicked',
lambda x: self.ttreeview.collapse_all())
self._set_tooltip(collapse_button, "Tree View - Collapse all")
items.append(collapse_button)
self.group_toolbutton = gtk.ToggleToolButton()
self.group_toolbutton.set_active(self.t.should_group_families)
g_image = gtk.image_new_from_stock('group',
gtk.ICON_SIZE_SMALL_TOOLBAR)
self.group_toolbutton.set_icon_widget(g_image)
self.group_toolbutton.set_label("Group")
self.group_toolbutton.connect('toggled', self.toggle_grouping)
self._set_tooltip(self.group_toolbutton,
"Tree View - Click to group tasks by families")
items.append(self.group_toolbutton)
return items
def addToolbar(self):
self.toolbar = gtk.Toolbar()
self.back_button = gtk.ToolButton(gtk.STOCK_GO_BACK)
self.back_button.connect("clicked", self.go_back)
self.forward_button = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
self.forward_button.connect("clicked", self.go_forward)
self.refresh_button = gtk.ToolButton(gtk.STOCK_REFRESH)
self.refresh_button.connect("clicked", self.refresh)
self.toolbar.add(self.back_button)
self.toolbar.add(self.forward_button)
self.toolbar.add(self.refresh_button)
self.url_bar = gtk.Entry()
self.url_bar.connect("activate", self.on_active)
self.web.connect("load_committed", self.update_buttons)
self.scroll_window = gtk.ScrolledWindow(None, None)
self.scroll_window.add(self.web)
self.vbox = gtk.VBox(False, 0)
#self.vbox.pack_start(self.toolbar, False, True, 0)
self.vbox.pack_start(self.url_bar, False, True, 0)
self.vbox.add(self.scroll_window)
self.win.add(self.vbox)
self.win.set_default_size(1060, 800)
def __init__(self, win):
gtk.Toolbar.__init__(self)
self.set_style(gtk.TOOLBAR_ICONS)
self.win = win
self.win.box.pack_start(self, False, False, 0)
self.back = gtk.ToolButton(gtk.STOCK_GO_BACK)
self.back.connect("clicked", self.on_back_clicked)
self.next = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
self.next.connect("clicked", self.on_next_clicked)
self.close = gtk.ToolButton(gtk.STOCK_CLOSE)
self.close.connect("clicked", self.on_close_clicked)
check_item = gtk.ToolItem()
self.check_btn = gtk.CheckButton()
self.check_btn.set_label('Leido')
self.check_btn.connect('toggled', self.toggled)
check_item.add(self.check_btn)
sep = gtk.SeparatorToolItem()
sep.props.draw = False
sep.set_expand(True)
self.insert(self.back, 0)
self.insert(self.next, 1)
self.insert(sep, 2)
self.insert(check_item, 3)
self.insert(self.close, 4)
def create_mainwin_toolbar(self):
# Create toolbar
self.main_toolbar = gtk.Toolbar()
# Create toolbar button items
self.mtb_add = gtk.ToolButton(gtk.STOCK_ADD)
self.mtb_edit = gtk.ToolButton(gtk.STOCK_EDIT)
self.mtb_delete = gtk.ToolButton(gtk.STOCK_DELETE)
self.mtb_close = gtk.ToolButton(gtk.STOCK_QUIT)
self.mtb_add.set_expand(True)
self.mtb_edit.set_expand(True)
self.mtb_delete.set_expand(True)
self.mtb_close.set_expand(True)
# Add all items to toolbar
self.main_toolbar.insert(self.mtb_add, -1)
self.main_toolbar.insert(gtk.SeparatorToolItem(), -1)
self.main_toolbar.insert(self.mtb_edit, -1)
self.main_toolbar.insert(self.mtb_delete, -1)
self.main_toolbar.insert(gtk.SeparatorToolItem(), -1)
self.main_toolbar.insert(self.mtb_close, -1)
self.mtb_add.connect("clicked", callbacks.newrecord, self)
self.mtb_edit.connect("clicked", callbacks.editrecord, self)
self.mtb_delete.connect("clicked", callbacks.deleterecord, self)
self.mtb_close.connect("clicked", callbacks.delete_event, self)
def create_toolbar(self):
"""Create the toolbar"""
toolbar = gtk.Toolbar()
# create the preview button
preview_icon = gtk.Image()
preview_icon.set_from_stock(gtk.STOCK_FIND,
gtk.ICON_SIZE_LARGE_TOOLBAR)
# TRANSLATORS: This is the preview button on the main window. It
# previews changes.
preview_button = gtk.ToolButton(icon_widget=preview_icon,
label=_p('button', "Preview"))
preview_button.connect(
"clicked", lambda *dummy: self.preview_or_run_operations(False))
toolbar.insert(preview_button, -1)
preview_button.set_tooltip_text(
_("Preview files in the selected operations (without deleting any files)"
))
preview_button.set_is_important(True)
# create the delete button
icon = gtk.Image()
icon.set_from_stock(gtk.STOCK_DELETE, gtk.ICON_SIZE_LARGE_TOOLBAR)
# TRANSLATORS: This is the clean button on the main window.
# It makes permanent changes: usually deleting files, sometimes
# altering them.
run_button = gtk.ToolButton(icon_widget=icon,
label=_p("button", "Clean"))
run_button.connect("clicked", self.run_operations)
toolbar.insert(run_button, -1)
run_button.set_tooltip_text(
_("Clean files in the selected operations"))
run_button.set_is_important(True)
return toolbar
def __init__(self, pdb_file, map_file, needs_rebuild=False):
self.file_name = pdb_file
self.needs_rebuild = needs_rebuild
import gtk
import coot
import coot_python
toolbar = coot_python.main_toolbar()
assert (toolbar is not None)
return_button = gtk.ToolButton()
return_button.set_label("Return to PHENIX")
return_button.set_is_important(True)
toolbar.insert(return_button, -1)
return_button.connect("clicked", self.OnReturn)
return_button.show()
maps_button = gtk.ToolButton()
maps_button.set_label("Fetch new maps")
maps_button.set_is_important(True)
toolbar.insert(maps_button, -1)
maps_button.connect("clicked", self.OnNewMaps)
maps_button.show()
self._imol = read_pdb(to_str(pdb_file))
set_molecule_bonds_colour_map_rotation(self._imol, 30)
self._map_mols = []
self.load_maps(map_file)
dialog = gtk.MessageDialog(
None, gtk.DIALOG_MODAL, gtk.MESSAGE_INFO, gtk.BUTTONS_OK,
"You may now edit your model to prepare for further " +
"building and refinement. When you are finished, " +
"click the \"Save model and return\" button on the toolbar, then close "
+
"Coot. If you want to recalculate the map coefficients, click \"Fetch "
+ "new maps\".")
dialog.run()
dialog.destroy()
def __init__(self):
# Create window
self.much_window = gtk.Window()
self.much_window.set_icon_from_file('doge.png')
self.much_window.connect('destroy', lambda w: gtk.main_quit())
self.much_window.set_default_size(360, 600)
# Create navigation bar
self.so_navigation = gtk.HBox()
self.many_back = gtk.ToolButton(gtk.STOCK_GO_BACK)
self.such_forward = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
self.very_refresh = gtk.ToolButton(gtk.STOCK_REFRESH)
self.wow_address_bar = gtk.Entry()
self.many_back.connect('clicked', self.go_back)
self.such_forward.connect('clicked', self.go_forward)
self.very_refresh.connect('clicked', self.refresh_page)
self.wow_address_bar.connect('activate', self.load_page)
self.so_navigation.pack_start(self.many_back, False)
self.so_navigation.pack_start(self.such_forward, False)
self.so_navigation.pack_start(self.very_refresh, False)
self.so_navigation.pack_start(self.wow_address_bar)
# Create view for webpage
self.very_view = gtk.ScrolledWindow()
self.such_webview = webkit.WebView()
self.such_webview.open('http://ready.me')
self.such_webview.connect('title-changed', self.change_title)
self.such_webview.connect('load-committed', self.change_url)
self.very_view.add(self.such_webview)
# Add everything and initialize
self.wow_container = gtk.VBox()
self.wow_container.pack_start(self.so_navigation, False)
self.wow_container.pack_start(self.very_view)
self.much_window.add(self.wow_container)
self.much_window.show_all()
gtk.main()
def popup(self, embedded=True):
"""Popup the application window.
"""
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.connect('key-press-event', self.key_pressed_cb)
window.set_title("Python evaluation")
b = gtk.SeparatorToolItem()
b.set_expand(True)
b.set_draw(False)
self.toolbar.insert(b, -1)
if embedded:
# Add the Close button to the toolbar
b = gtk.ToolButton(gtk.STOCK_CLOSE)
b.connect('clicked', self.close)
self.toolbar.insert(b, -1)
self.control_shortcuts[gtk.keysyms.w] = self.close
else:
# Add the Quit button to the toolbar
b = gtk.ToolButton(gtk.STOCK_QUIT)
b.connect('clicked', lambda b: window.destroy())
self.toolbar.insert(b, -1)
window.connect('destroy', lambda e: gtk.main_quit())
self.control_shortcuts[gtk.keysyms.q] = lambda: gtk.main_quit()
window.add(self.widget)
window.show_all()
window.resize(800, 600)
self.help()
self.source.grab_focus()
return window
def __init__(self, callback):
'''
Конструктор панели
:param callback: Метод-коллбек, который будет вызван при возникновении
события. В качестве параметра будет передан объект PathEvent
'''
gtk.HBox.__init__(self)
self.callback = callback
self.longest_common_path = None
self.path = None
self.pathHBox = gtk.HBox()
self.editBtn = gtk.ToggleToolButton(gtk.STOCK_EDIT)
self.editBtn.connect('clicked', self.__edit_clicked__)
#self.editBtn.set_size_request(32,32)
self.pathEntry = gtk.Entry()
self.completion = gtk.EntryCompletion()
self.pathEntry.set_completion(self.completion)
self.pathEntry.hide()
self.pathEntry.connect('focus-out-event', self.__edit_focus_out__)
self.pathEntry.connect('key-release-event', self.__edit_key_released__)
self.historyBtn = gtk.ToolButton(gtk.STOCK_GO_DOWN)
self.favBtn = gtk.ToolButton(gtk.STOCK_ABOUT)
self.pack_start(self.editBtn, False, False)
self.pack_start(self.pathHBox, True, True)
self.pack_start(self.pathEntry, True, True)
# self.pack_start(self.historyBtn, False, False)
# self.pack_start(self.favBtn, False, False)
# self.historyBtn.show()
# self.favBtn.show()
self.set_no_show_all(True)
def __init__(self):
super(PyAppToolbar, self).__init__()
self.set_title("Toolbar")
self.set_size_request(250, 200)
self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(6400, 6400, 6440))
self.set_position(gtk.WIN_POS_CENTER)
toolbar = gtk.Toolbar()
toolbar.set_style(gtk.TOOLBAR_ICONS)
newtb = gtk.ToolButton(gtk.STOCK_NEW)
opentb = gtk.ToolButton(gtk.STOCK_OPEN)
savetb = gtk.ToolButton(gtk.STOCK_SAVE)
sep = gtk.SeparatorToolItem()
quittb = gtk.ToolButton(gtk.STOCK_QUIT)
toolbar.insert(newtb, 0)
toolbar.insert(opentb, 1)
toolbar.insert(savetb, 2)
toolbar.insert(sep, 3)
toolbar.insert(quittb, 4)
quittb.connect("clicked", gtk.main_quit)
vbox = gtk.VBox(False, 2)
vbox.pack_start(toolbar, False, False, 0)
self.add(vbox)
self.connect("destroy", gtk.main_quit)
self.show_all()
def create_toolbar(self):
self.refresh = gtk.ToolButton(gtk.STOCK_REFRESH)
self.refresh.set_tooltip_text("Refresh Songs/Artists lists")
self.add_fold = gtk.ToolButton(gtk.STOCK_ADD)
self.add_fold.set_tooltip_text("Add a folder containg music")
self.previous = gtk.ToolButton(gtk.STOCK_MEDIA_PREVIOUS)
self.previous.set_tooltip_text("Previous song")
self.play_pause = gtk.ToolButton(gtk.STOCK_MEDIA_PLAY)
self.play_pause.set_tooltip_text("Play or stop the song")
self.next = gtk.ToolButton(gtk.STOCK_MEDIA_NEXT)
self.next.set_tooltip_text("Next song")
self.search_entry = gtk.Entry()
self.search_entry.set_icon_from_stock(1, gtk.STOCK_CLEAR)
self.search_entry.set_tooltip_text("Search a song")
self.search_tool = gtk.ToolItem()
self.search_entry.set_size_request(170, 27)
self.search_tool.add(self.search_entry)
self.active_song = gtk.Label("Title - Artist - Album")
self.active_song.set_tooltip_text(
"Current song (Title - Artist - Album)")
self.active_song_cont = gtk.ToolItem()
self.active_song_cont.add(self.active_song)
self.active_song_cont.set_expand(True)
self.main_toolbar = gtk.Toolbar()
self.main_toolbar.insert(self.search_tool, 0)
self.main_toolbar.insert(self.active_song_cont, 0)
self.main_toolbar.insert(self.next, 0)
self.main_toolbar.insert(self.play_pause, 0)
self.main_toolbar.insert(self.previous, 0)
self.main_toolbar.insert(self.add_fold, 0)
self.main_toolbar.insert(self.refresh, 0)
return self.main_toolbar
def setup_toolbar(self, toolbar):
t = gtk.ToolButton(gtk.STOCK_OPEN)
toolbar.add(t)
t = gtk.ToolButton(gtk.STOCK_SAVE)
toolbar.add(t)
t = gtk.ToolButton(gtk.STOCK_CLOSE)
toolbar.add(t)
def __setup_toolbar(self):
pb = gtk.ToolButton(gtk.STOCK_MEDIA_PLAY)
pb.connect("clicked", self.__play_clicked)
ib = gtk.ToolButton(gtk.STOCK_OPEN)
ib.connect("clicked", self.__open_clicked)
self.toolbar.insert(ib, 0)
self.toolbar.insert(pb, 1)
def __init_toolbar(self):
hb = gtk.HBox()
b2 = gtk.ToolButton(stock_id=gtk.STOCK_CANCEL)
hb.pack_start(b2)
b2.connect('clicked', self.cb_toolbar_clicked, 'cancel')
b1 = gtk.ToolButton(stock_id=gtk.STOCK_YES)
hb.pack_start(b1)
b1.connect('clicked', self.cb_toolbar_clicked, 'ok')
return hb
def __init__(self):
super(PyAppWidgetIconView, self).__init__()
self.set_title("- Icon view -")
self.set_size_request(650, 400)
#self.set_border_width(2)
self.set_position(gtk.WIN_POS_CENTER)
self.connect("destroy", gtk.main_quit)
self.col_path = 0
self.col_pixbuf = 1
self.col_is_directory = 2
self.current_directory = "/"
vbox = gtk.VBox(False, 0)
toolbar = gtk.Toolbar()
vbox.pack_start(toolbar, False, False, 0)
self.upButton = gtk.ToolButton(gtk.STOCK_GO_UP)
self.upButton.set_is_important(True)
self.upButton.set_sensitive(False)
toolbar.insert(self.upButton, -1)
homeButton = gtk.ToolButton(gtk.STOCK_HOME)
homeButton.set_is_important(True)
toolbar.insert(homeButton, -1)
self.fileIcon = self.get_icon(gtk.STOCK_FILE)
self.dirIcon = self.get_icon(gtk.STOCK_DIRECTORY)
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
vbox.pack_start(sw, True, True, 0)
self.store = self.create_store()
self.fill_store()
iconView = gtk.IconView(self.store)
iconView.set_selection_mode(gtk.SELECTION_MULTIPLE)
self.upButton.connect("clicked", self.on_up_clicked)
homeButton.connect("clicked", self.on_home_clicked)
iconView.set_text_column(self.col_path)
iconView.set_pixbuf_column(self.col_pixbuf)
iconView.connect("item-activated", self.on_item_activated)
sw.add(iconView)
iconView.grab_focus()
self.add(vbox)
self.show_all()
def __init__(self, geditwindow):
""" geditwindow -- an instance of pluma.Window """
imagelibrary.initialise()
gtk.VBox.__init__(self)
self.geditwindow = geditwindow
try:
self.encoding = pluma.encoding_get_current()
except:
self.encoding = pluma.gedit_encoding_get_current()
self.active_timeout = False
self.parser = None
self.document_history = [] # contains tuple (doc,line,col)
self.history_pos = 0
self.previousline = 0
self.back = gtk.ToolButton(gtk.STOCK_GO_BACK)
self.back.connect("clicked", self.history_back)
self.back.set_sensitive(False)
self.forward = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
self.forward.connect("clicked", self.history_forward)
self.forward.set_sensitive(False)
tb = gtk.Toolbar()
tb.add(self.back)
tb.add(self.forward)
#self.pack_start(tb,False,False)
# add a treeview
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_IN)
self.browser = gtk.TreeView()
self.browser.set_headers_visible(False)
sw.add(self.browser)
self.browser.connect("button_press_event", self.__onClick)
self.pack_start(sw)
# add a text column to the treeview
self.column = gtk.TreeViewColumn()
self.browser.append_column(self.column)
self.cellrendererpixbuf = gtk.CellRendererPixbuf()
self.column.pack_start(self.cellrendererpixbuf, False)
self.crt = gtk.CellRendererText()
self.column.pack_start(self.crt, False)
# connect stuff
self.browser.connect("row-activated", self.on_row_activated)
self.show_all()
def build_window(self):
self.set_size_request(550, 700)
self.set_title("Open connections")
self.set_resizable(True)
self.vbox = gtk.VBox()
self.add(self.vbox)
""" Toolbar """
toolbar = gtk.Toolbar()
toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
toolbar.set_style(gtk.TOOLBAR_BOTH)
self.new_button = gtk.ToolButton(gtk.STOCK_ADD)
self.new_button.connect('clicked', self.on_add_host)
self.new_button.set_tooltip(gtk.Tooltips(), 'Add')
self.new_button.set_label("Add")
toolbar.insert(self.new_button, -1)
self.edit_button = gtk.ToolButton(gtk.STOCK_EDIT)
self.edit_button.connect('clicked', self.on_edit_host)
self.edit_button.set_tooltip(gtk.Tooltips(), 'Edit')
self.edit_button.set_label("Edit")
toolbar.insert(self.edit_button, -1)
self.copy_button = gtk.ToolButton(gtk.STOCK_COPY)
self.copy_button.connect('clicked', self.on_copy_host)
self.copy_button.set_tooltip(gtk.Tooltips(), 'Copy')
self.copy_button.set_label("Copy")
toolbar.insert(self.copy_button, -1)
self.remove_button = gtk.ToolButton(gtk.STOCK_ADD)
self.remove_button.set_label("Remove")
self.remove_button.set_tooltip(gtk.Tooltips(), 'Remove')
self.remove_button.connect('clicked', self.on_remove_host)
toolbar.insert(self.remove_button, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
self.connect_button = gtk.ToolButton(gtk.STOCK_CONNECT)
self.connect_button.set_label("Connect")
self.connect_button.set_tooltip(gtk.Tooltips(), 'Connect')
self.connect_button.connect('clicked', self.hosts_tree.on_connect)
toolbar.insert(self.connect_button, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
self.vbox.pack_start(toolbar, False, False, 0)
self.vbox.pack_start(self.hosts_tree, True, True)
""" Run """
self.connect("delete_event", self.on_exit)
self.connect("key-press-event", self._key_press_event)
self.show_all()
self.on_cursor_changed()
self.hosts_tree.entry.grab_focus()
self.window.focus(0)
def _create_top_bar(self):
self._top_bar = gtk.HBox()
self.pack_start(self._top_bar, expand=False)
self._title_label = gtk.Label()
self._top_bar.pack_start(self._title_label)
self._top_buttons = gtk.HBox()
self._top_bar.pack_start(self._top_buttons, expand=False)
self._detach_button = gtk.ToolButton(icon_widget=self._create_detach_button())
self._top_buttons.pack_start(self._detach_button)
self._close_button = gtk.ToolButton(icon_widget=self._create_close_button())
self._top_buttons.pack_start(self._close_button)
def createWindow(self):
"""Creates a top-level window, sets various boring attributes,
creates a place to put the video sink, adds some and finally
connects some basic signal handlers. Really, really boring.
"""
# create window, set basic attributes
w = gtk.Window()
w.set_size_request(*self.__def_win_size__)
w.set_title("Gstreamer " + self.__name__)
w.connect("destroy", gtk.main_quit)
# declare buttons and their associated handlers
controls = (("play_button", gtk.ToolButton(gtk.STOCK_MEDIA_PLAY),
self.onPlay), ("pause_button",
gtk.ToolButton(gtk.STOCK_MEDIA_PAUSE),
self.onPause),
("stop_button", gtk.ToolButton(gtk.STOCK_MEDIA_STOP),
self.onStop), ("quit_button",
gtk.ToolButton(gtk.STOCK_QUIT),
gtk.main_quit))
# as well as the container in which to put them
box = gtk.HButtonBox()
# for every widget, connect to its clicked signal and add it
# to the enclosing box
for name, widget, handler in controls:
widget.connect("clicked", handler)
box.pack_start(widget, True)
setattr(self, name, widget)
self.updateButtons(gst.STATE_NULL)
viewer = gtk.DrawingArea()
viewer.modify_bg(gtk.STATE_NORMAL, viewer.style.black)
# we will need this later
self.xid = None
# now finally do the top-level layout for the window
layout = gtk.VBox(False)
layout.pack_start(viewer)
# subclasses can override childWidgets() to supply
# custom controls
layout.pack_start(self.customWidgets(), False, False)
layout.pack_end(box, False, False)
w.add(layout)
w.show_all()
# we want to return only the portion of the window which will
# be used to display the video, not the whole top-level
# window. a DrawingArea widget is, in fact, an X11 window.
return viewer
def __init__(self, p_wspace):
"""
p_wspace: un 'Workspace'.
Retorna: un nuevo 'WorkspaceToolbar'.
Crea un nuevo 'WorkspaceToolbar'.
"""
gtk.Toolbar.__init__(self)
self.set_style(gtk.TOOLBAR_ICONS)
root = os.path.abspath(os.path.join(__file__, os.pardir, os.pardir))
# Boton para crear nuevas variables.
img = gtk.Image()
img.set_from_file(os.path.join(root, "images", "new_var.png"))
new = gtk.ToolButton(img, "New")
new.set_tooltip_text("New variable")
new.connect("clicked", self.on_new_clicked)
new.connect("focus", self.on_button_focus)
self.insert(new, -1)
# Boton para importar datos
img = gtk.Image()
img.set_from_file(os.path.join(root, "images", "import_data.png"))
import_ = gtk.ToolButton(img, "Import")
import_.set_tooltip_text("Import data")
import_.connect("clicked", self.on_import_clicked)
import_.connect("focus", self.on_button_focus)
self.insert(import_, -1)
# Boton para salvar el workspace
img = gtk.Image()
img.set_from_file(os.path.join(root, "images", "save_workspace.png"))
save = gtk.ToolButton(img, "Save")
save.set_tooltip_text("Save")
save.connect("clicked", self.on_save_clicked)
save.connect("focus", self.on_button_focus)
self.insert(save, -1)
# Separador.
self.insert(gtk.SeparatorToolItem(), -1)
# Boton para eliminar variables.
img = gtk.Image()
img.set_from_file(os.path.join(root, "images", "delete_var.png"))
self.__delete = gtk.ToolButton(img, "Delete")
self.__delete.set_tooltip_text("Delete")
self.__delete.connect("clicked", self.on_delete_clicked)
self.__delete.connect("focus", self.on_button_focus)
self.insert(self.__delete, -1)
self.__workspace = p_wspace
def __init__( self, wiki_path, page_uri ):
self.logger = logging.getLogger( 'pynotewiki.editor' )
# Create the main window.
self.window = gtk.Window()
self.window.set_title( 'PyNoteWiki Editor' )
self.window.connect( 'destroy', gtk.main_quit )
mb = gtk.MenuBar()
# Create the file menu.
filemenu = gtk.Menu()
filem = gtk.MenuItem( 'File' )
filem.set_submenu( filemenu )
exitm = gtk.MenuItem( 'Exit' )
exitm.connect( 'activate', gtk.main_quit )
filemenu.append( exitm )
mb.append( filem )
# Create the toolbar.
toolbar = gtk.Toolbar()
saveb = gtk.ToolButton( gtk.STOCK_SAVE )
saveb.connect( 'clicked', self.on_save )
cancelb = gtk.ToolButton( gtk.STOCK_NO )
cancelb.connect( 'clicked', self.on_view )
toolbar.insert( saveb, 0 )
toolbar.insert( cancelb, 1 )
# Create the editor.
self.editor = gtk.TextView()
self.editor.set_editable( True )
editor_scroller = gtk.ScrolledWindow()
editor_scroller.props.vscrollbar_policy = gtk.POLICY_AUTOMATIC
editor_scroller.add( self.editor )
# Pack the widgets and show the window.
vbox = gtk.VBox( False, 2 )
vbox.pack_start( mb, False, False, 0 )
vbox.pack_start( toolbar, False, False, 0 )
vbox.pack_start( editor_scroller, True, True, 0 )
#vbox.pack_start( self.statusbar, False, False, 0 )
self.window.add( vbox )
# TODO: Try to find pynotewiki.png on the system.
self.window.set_icon_from_file( '/usr/share/pixmaps/pynotewiki.png' )
self.window.show_all()
self.load_wiki( wiki_path, page_uri )
gtk.main()
def __init__(self):
super(Browser, self).__init__()
# created our main window
self.set_icon_from_file('navegador.jpg')
self.set_default_size(int(b) - 100, int(c) - 100)
self.navigation = gtk.HBox()
#create back, forward, refresh, and search pannel
#back button
self.back = gtk.ToolButton(gtk.STOCK_GO_BACK)
self.frwd = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
self.refresh = gtk.ToolButton(gtk.STOCK_REFRESH)
self.address_bar = gtk.Entry()
# #what to do with buttons
self.back.connect("clicked", self.go_back)
self.frwd.connect("clicked", self.go_frwd)
self.refresh.connect("clicked", self.refresh_page)
self.address_bar.connect("activate", self.load_page)
self.navigation.pack_start(self.back, False)
self.navigation.pack_start(self.frwd, False)
self.navigation.pack_start(self.refresh, False)
self.navigation.pack_start(self.address_bar)
#create view for web pages
self.view = gtk.ScrolledWindow()
self.webview = webkit.WebView()
self.webview.open('http://www.google.com')
self.webview.connect('title-changed', self.change_title)
self.webview.connect('load-committed', self.change_url)
self.view.add(self.webview)
#Added everything and initialize
self.container = gtk.VBox()
self.container.pack_start(self.navigation, False)
self.container.pack_start(self.view)
self.add(self.container)
self.show_all()
# fixed = gtk.Fixed()
# fixed.put(self.back, 0,0)
# fixed.put(self.frwd, 33,0)
# fixed.put(self.refresh, 60,0)
# fixed.put(self.address_bar,110,000 )
# fixed.put(self.container, 500,500)
#
#destroy process when close window
self.connect('destroy', lambda w: gtk.main_quit())
def __init__(self, win):
super(Toolbar, self).__init__()
self.win = win
self.open_but = gtk.ToolButton(gtk.STOCK_OPEN)
self.open_but.connect('clicked', self.open)
self.refresh_but = gtk.ToolButton(gtk.STOCK_REFRESH)
self.refresh_but.connect('clicked', self.refresh)
self.insert(self.open_but, -1)
self.insert(self.refresh_but, -1)
def get_pixmap_toolbutton(pixmap, callback=None, *p):
if pixmap.startswith('gtk-'):
# Stock-id
b = gtk.ToolButton(pixmap)
else:
i = gtk.Image()
i.set_from_file(config.data.advenefile(('pixmaps', pixmap)))
b = gtk.ToolButton(icon_widget=i)
i.show()
if callback:
b.connect('clicked', callback, *p)
return b
def init(self, context):
self._log.debug("init")
self._context = context
self._scroll = gtk.ScrolledWindow()
self._scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._scroll.set_shadow_type(gtk.SHADOW_IN)
self._store = gtk.TreeStore(gtk.gdk.Pixbuf, str, str, str, object) # icon, message, file, line, Issue object
self._view = gtk.TreeView(self._store)
column = gtk.TreeViewColumn("Job")
pixbuf_renderer = gtk.CellRendererPixbuf()
column.pack_start(pixbuf_renderer, False)
column.add_attribute(pixbuf_renderer, "pixbuf", 0)
text_renderer = gtk.CellRendererText()
column.pack_start(text_renderer, True)
column.add_attribute(text_renderer, "markup", 1)
self._view.append_column(column)
self._view.append_column(gtk.TreeViewColumn("File", gtk.CellRendererText(), text=2))
self._view.append_column(gtk.TreeViewColumn("Line", gtk.CellRendererText(), text=3))
self._handlers[self._view] = self._view.connect("row-activated", self._on_row_activated)
self._scroll.add(self._view)
self.pack_start(self._scroll, True)
# toolbar
self._buttonCancel = gtk.ToolButton(gtk.STOCK_STOP)
self._buttonCancel.set_sensitive(False)
self._buttonCancel.set_tooltip_text("Abort Job")
self._handlers[self._buttonCancel] = self._buttonCancel.connect("clicked", self._on_abort_clicked)
self._buttonDetails = gtk.ToolButton(gtk.STOCK_INFO)
self._buttonDetails.set_sensitive(False)
self._buttonDetails.set_tooltip_text("Show Detailed Output")
self._handlers[self._buttonDetails] = self._buttonDetails.connect("clicked", self._on_details_clicked)
self._toolbar = gtk.Toolbar()
self._toolbar.set_style(gtk.TOOLBAR_ICONS)
self._toolbar.set_icon_size(gtk.ICON_SIZE_SMALL_TOOLBAR) # FIXME: deprecated???
self._toolbar.set_orientation(gtk.ORIENTATION_VERTICAL)
self._toolbar.insert(self._buttonCancel, -1)
self._toolbar.insert(self._buttonDetails, -1)
self.pack_start(self._toolbar, False)
