def get_player_control_toolbar(self):
"""Return a player control toolbar
"""
tb = gtk.Toolbar()
tb.set_style(gtk.TOOLBAR_ICONS)
for text, tooltip, stock, callback in (
(_("Play"), _("Play"), gtk.STOCK_MEDIA_PLAY, lambda b: self.player.play()),
(_("Pause"), _("Pause"), gtk.STOCK_MEDIA_PAUSE, lambda b: self.player.pause()),
(_("Stop"), _("Stop"), gtk.STOCK_MEDIA_STOP, lambda b: self.player.stop()),
):
b=gtk.ToolButton(stock)
b.set_tooltip_text(tooltip)
b.connect("clicked", callback)
tb.insert(b, -1)
tb.show_all()
return tb
def _get_container(self, actions, horiz = True):
"return Gtk container with the specified actions or None for no actions"
if not actions:
return None
#print "ACTIONS:", actions
if len(actions) > 1:
bar = gtk.Toolbar()
if horiz:
bar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
else:
bar.set_orientation(gtk.ORIENTATION_VERTICAL)
bar.set_style(gtk.TOOLBAR_BOTH)
# disable overflow menu to get toolbar sized correctly for panels
bar.set_show_arrow(False)
bar.set_tooltips(True)
else:
bar = None
tooltips = gtk.Tooltips()
for action in actions:
#print action
offset = action.find("=")
if offset >= 0:
# handle "<name>=<keycode>" action specification
name = action[:offset]
text = action[offset+1:]
(widget, tip) = self._create_key_control(name, text)
widget.set_tooltip(tooltips, "Insert " + tip)
elif action == "|":
widget = gtk.SeparatorToolItem()
elif action == "close":
if bar:
widget = create_toolbutton(gtk.STOCK_CLOSE, self._close_cb)
else:
widget = create_button("Close", self._close_cb)
else:
widget = self.actions.get_action(action).create_tool_item()
if not widget:
continue
if bar:
if action != "|":
widget.set_expand(True)
bar.insert(widget, -1)
if bar:
return bar
return widget
def __init__(self, activity):
super(_Toolbox, self).__init__(activity)
toolbar = gtk.Toolbar()
def add_button(icon_name, tooltip, signal_name):
button = ToolButton(icon_name)
toolbar.add(button)
def callback(source):
self.emit(signal_name)
button.connect('clicked', callback)
button.set_tooltip(tooltip)
return button
add_button('new-game', _("New"), 'new-game-clicked')
add_button('replay-game', _("Replay"), 'replay-game-clicked')
add_button('edit-undo', _("Undo"), 'undo-clicked')
add_button('edit-redo', _("Redo"), 'redo-clicked')
toolbar.add(gtk.SeparatorToolItem())
levels = []
def add_level_button(icon_name, tooltip, signal_name):
if levels:
button = RadioToolButton(named_icon=icon_name, group=levels[0])
else:
button = RadioToolButton(named_icon=icon_name)
levels.append(button)
toolbar.add(button)
def callback(source):
if source.get_active():
self.emit(signal_name)
button.connect('clicked', callback)
button.set_tooltip(tooltip)
add_level_button('easy-level', _("Easy"), 'easy-clicked')
add_level_button('medium-level', _("Medium"), 'medium-clicked')
add_level_button('hard-level', _("Hard"), 'hard-clicked')
self.add_toolbar(_("Game"), toolbar)
self.set_current_toolbar(1)
def initialize_components(self):
# The big box to hold them all:
box = gtk.VBox(False, 2)
self.add(box)
# The browser engine container:
webview = webkit.WebView()
# Scrollable box for the WebView:
scroller = gtk.ScrolledWindow()
scroller.add(webview)
# A toolbar with all the necessary controls:
toolbar = gtk.Toolbar()
toolbar.set_style(gtk.TOOLBAR_ICONS)
# Buttons and stuff:
# newTb = gtk.ToolButton(gtk.STOCK_NEW)
clear_button = gtk.ToolButton(gtk.STOCK_CLEAR)
refresh_button = gtk.ToolButton(gtk.STOCK_REFRESH)
go_button = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
back_button = gtk.ToolButton(gtk.STOCK_GO_BACK)
# The address bar needs to be split because Toolbar only accepts ToolItems.
addressbar_item = gtk.ToolItem()
addressbar = gtk.Entry()
addressbar.connect('key_press_event', self.on_key_press, webview)
addressbar.set_width_chars(100)
addressbar_item.add(addressbar)
# Let's give the buttons a purpose:
go_button.connect('clicked', self.go, webview, addressbar)
clear_button.connect('clicked', Toolbox.clear_text, addressbar)
back_button.connect('clicked', Toolbox.go_back, webview)
refresh_button.connect('clicked', Toolbox.refresh, webview)
# Assemble the toolbar:
# toolbar.insert(newTb, 0)
toolbar.insert(back_button, 0)
toolbar.insert(refresh_button, 1)
toolbar.insert(addressbar_item, 2)
toolbar.insert(clear_button, 3)
toolbar.insert(go_button, 4)
# Put it all in a box:
box.pack_start(toolbar, False, False, 0)
box.pack_start(scroller)
def __init__(self, handle):
print "running activity init", handle
activity.Activity.__init__(self, handle)
print "activity running"
self.set_title('Teach Teacher')
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbar = gtk.Toolbar()
self.xois = ToolButton('computer-xo')
self.xois.set_tooltip("T's XO")
self.xois.connect('clicked', self.xois_clicked)
toolbar.insert(self.xois, -1)
self.xois.show()
self.guide = ToolButton('go-next')
self.guide.set_tooltip("T's Guide")
self.guide.connect('clicked', self.guide_clicked)
toolbar.insert(self.guide, -1)
self.guide.show()
self.diary = ToolButton('activity-journal')
self.diary.set_tooltip("T's Diary")
self.diary.connect('clicked', self.diary_clicked)
toolbar.insert(self.diary, -1)
self.diary.show()
self.society = ToolButton('zoom-neighborhood')
self.society.set_tooltip("T's Society")
self.society.connect('clicked', self.society_clicked)
toolbar.insert(self.society, -1)
self.society.show()
toolbar.show()
toolbox.add_toolbar("Menu", toolbar)
toolbox.show()
self.webview = WebView()
self.set_canvas(self.webview)
self.webview.show()
self.webview.load_uri('http://teach-teacher.ep.io/')
print "AT END OF THE CLASS"
def main(self, filenames):
# Build main window
window = gtk.Window()
mainbox = gtk.VBox()
videos = gtk.HBox()
window.add(mainbox)
mainbox.add(videos)
# Create VLC widgets
for fname in filenames:
v = DecoratedVLCWidget()
v.player.set_media(
instance.media_new(fname, "overlay", "avcodec-dr=1",
"avcodec-hw=vaapi"))
videos.add(v)
# Create global toolbar
tb = gtk.Toolbar()
tb.set_style(gtk.TOOLBAR_ICONS)
def execute(b, methodname):
"""Execute the given method on all VLC widgets.
"""
for v in videos.get_children():
getattr(v.player, methodname)()
return True
for text, tooltip, stock, callback, arg in (
(_("Play"), _("Global play"), gtk.STOCK_MEDIA_PLAY, execute,
"play"),
(_("Pause"), _("Global pause"), gtk.STOCK_MEDIA_PAUSE, execute,
"pause"),
(_("Stop"), _("Global stop"), gtk.STOCK_MEDIA_STOP, execute,
"stop"),
):
b = gtk.ToolButton(stock)
b.set_tooltip_text(tooltip)
b.connect("clicked", callback, arg)
tb.insert(b, -1)
mainbox.pack_start(tb, expand=False)
window.show_all()
window.connect("destroy", gtk.main_quit)
gtk.main()
def build_gui(self):
"""
Build the GUI interface.
"""
vbox = gtk.VBox()
self.top = vbox
button_panel = gtk.Toolbar()
self.button_add = button_panel.insert_stock(gtk.STOCK_ADD,
_("Add Mapping"), None,
self.add_mapping_clicked,
None, -1)
self.button_edit = button_panel.insert_stock(gtk.STOCK_EDIT,
_("Edit Mapping"), None,
self.edit_mapping_clicked,
None, -1)
self.button_del = button_panel.insert_stock(
gtk.STOCK_REMOVE, _("Remove Mapping"), None,
self.remove_mapping_clicked, None, -1)
vbox.pack_start(button_panel, expand=False, fill=True, padding=5)
self.treestore = gtk.TreeStore(str, str)
self.treeview = gtk.TreeView(self.treestore)
self.treeview.connect("row-activated", self.row_double_clicked)
self.column1 = gtk.TreeViewColumn(_('Surname'))
self.column2 = gtk.TreeViewColumn(_('Group Name'))
self.treeview.append_column(self.column1)
self.treeview.append_column(self.column2)
self.cell1 = gtk.CellRendererText()
self.cell2 = gtk.CellRendererText()
self.column1.pack_start(self.cell1, True)
self.column1.add_attribute(self.cell1, 'text', 0)
self.column2.pack_start(self.cell2, True)
self.column2.add_attribute(self.cell2, 'text', 1)
self.treeview.set_search_column(0)
self.column1.set_sort_column_id(0)
self.column2.set_sort_column_id(1)
vbox.pack_start(self.treeview, expand=True, fill=True)
return vbox
def create_visual_elements(self):
# create visual elements
# create the toolbar
self.toolbar = gtk.Toolbar()
self.toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
self.toolbar.set_style(gtk.TOOLBAR_BOTH)
my_images_button = self.append_toolbar_button(
self.toolbar, "Images", hic.ICON_IMAGES_DISPLAY_FILE,
hic.ICON_IMAGES_HOVER_FILE, "Open previously built images",
self.my_images_button_clicked_cb)
settings_button = self.append_toolbar_button(
self.toolbar, "Settings", hic.ICON_SETTINGS_DISPLAY_FILE,
hic.ICON_SETTINGS_HOVER_FILE, "View additional build settings",
self.settings_button_clicked_cb)
self.details_top_buttons = self.add_onto_top_bar(self.toolbar)
def __init__(self):
""""""
gtk.VBox.__init__(self)
self.download_manager = DownloadTree()
self.upload_manager = UploadTree()
#toolbar
toolbar = gtk.Toolbar()
self.pack_start(toolbar, False)
toolbar.set_style(gtk.TOOLBAR_BOTH)
tool_buttons = [
(_("Add Downloads"), media.ICON_DOWNLOAD,
lambda x: self.add_downloads),
(_("Add Uploads"), media.ICON_UPLOAD, lambda x: self.add_uploads),
(None, None, None),
(_("Clear Complete"), media.ICON_CLEAR, lambda x: x.clear_cb),
(None, None, None),
(_("Move Up"), media.ICON_UP, lambda x: x.move_up_cb),
(_("Move Down"), media.ICON_DOWN, lambda x: x.move_down_cb),
(None, None, None),
(_("Start Selected"), media.ICON_START, lambda x: x.start_cb),
(_("Stop Selected"), media.ICON_STOP, lambda x: x.stop_cb),
]
for name, icon_path, get_callback in tool_buttons:
if name == None:
item = gtk.SeparatorToolItem()
else:
icon = gtk.image_new_from_file(icon_path)
item = gtk.ToolButton(icon, name)
item.connect("clicked", self.manage_callbacks, get_callback)
toolbar.insert(item, -1)
#notebook
self.notebook = gtk.Notebook()
self.pack_start(self.notebook)
self.notebook.set_show_tabs(False)
self.control_buttons = {}
self.button_box = gtk.HBox()
self.pack_start(self.button_box, False)
self.download_id = self.add_page(self.download_manager,
gtk.STOCK_GO_DOWN,
_("Show Downloads"))
self.upload_id = self.add_page(self.upload_manager, gtk.STOCK_GO_UP,
_("Show Uploads"))
def build_toolbar(self):
try:
# Use new >= 0.86 toolbar
self.max_participants = 1
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
self._insert_create_tools(toolbar_box.toolbar)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_size_request(0, -1)
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
return toolbar_box
except NameError:
# Use old <= 0.84 toolbar design
toolbox = activity.ActivityToolbox(self)
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.share.props.visible = False
create_toolbar = gtk.Toolbar()
self._insert_create_tools(create_toolbar)
toolbox.add_toolbar(_("Create"), create_toolbar)
create_toolbar.show()
toolbox.set_current_toolbar(1)
toolbox.show()
self.set_toolbox(toolbox)
return activity_toolbar
def __init__(self, handle):
print "running activity init", handle
activity.Activity.__init__(self, handle)
print "activity running"
self.set_title('Teach Teacher')
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbar = gtk.Toolbar()
self.goBack = ToolButton('go-left')
self.goBack.set_tooltip("Go Back")
self.goBack.connect('clicked', self.back_clicked)
toolbar.insert(self.goBack, -1)
self.goBack.show()
self.home = ToolButton('go-home')
self.home.set_tooltip("Home")
self.home.connect('clicked', self.home_clicked)
toolbar.insert(self.home, -1)
self.home.show()
self.xois = ToolButton('computer-xo')
self.xois.set_tooltip("T's XO")
self.xois.connect('clicked', self.xois_clicked)
# toolbar.insert(self.xois, -1)
# self.xois.show()
self.guide = ToolButton('go-next')
self.guide.set_tooltip("T's Guide")
self.guide.connect('clicked', self.guide_clicked)
# toolbar.insert(self.guide, -1)
# self.guide.show()
toolbar.show()
toolbox.add_toolbar("Menu", toolbar)
toolbox.show()
self.webview = WebView()
self.set_canvas(self.webview)
self.webview.show()
self.webview.load_uri('http://147.47.120.20/~tsquare/menu.php')
print "AT END OF THE CLASS"
def __init__(self):
#Window definitions
super(Window, self).__init__()
self.set_size_request(400, 400)
self.connect("destroy", gtk.main_quit)
#Define elements
self.layout = gtk.VBox()
self.toolbar = gtk.Toolbar()
self.add_new = gtk.ToolButton()
self.add_new.set_label("Přidat")
self.add_new.set_icon_name("document-new")
self.add_new.connect("clicked", self.on_add_new_clicked)
self.toolbar.insert(self.add_new, 0)
#odebiraci tlacitko
#list-remove
self.rem = gtk.ToolButton()
self.rem.set_label("Odebrat")
self.rem.set_icon_name("list-remove")
self.rem.connect("clicked", self.on_rem_clicked)
self.toolbar.insert(self.rem, 1)
self.treeview = gtk.TreeView()
# First name, last name
self.model = gtk.TreeStore(str, str)
jmena = [["Karel", "Omacka"], ["Josef", "Hnizdo"], ["Tomas", "Maly"],
["Blanka", "Protrhla"]]
#Pro kazdy prvek v poli jmen dosadit do modelu
for prvek in jmena:
self.model.append(None, prvek)
#Setting data for treeview
self.treeview.set_model(self.model)
sloupce = ["Jmeno", "Prijmeni"]
renderer = gtk.CellRendererText()
#Pripojeni sloupcu
pozice = 0
for i in sloupce:
tmp = gtk.TreeViewColumn(i, renderer, text=pozice)
self.treeview.append_column(tmp)
pozice += 1
#Packing
self.layout.pack_start(self.toolbar, expand=False)
self.layout.pack_start(self.treeview)
self.add(self.layout)
self.show_all()
def _init_comp(self, path):
self.tbar = gtk.Toolbar()
self.tbar.set_style(gtk.TOOLBAR_ICONS)
self.pathentry = gtk.Entry()
self.pathentry.connect("key-press-event", self._on_keypressed)
self.pack_start(self.pathentry, False, False, 5)
self.refreshbtn = gtk.ToolButton("gtk-refresh")
self.refreshbtn.connect("clicked", self._on_btnrefresh_clicked)
self.gobtn = gtk.ToolButton("gtk-ok")
self.gobtn.connect("clicked", self._on_btngo_clicked)
self.upbtn = gtk.ToolButton("gtk-go-up")
self.upbtn.connect("clicked", self._on_upbtnclicked)
self.homebtn = gtk.ToolButton("gtk-home")
self.homebtn.connect("clicked", self._on_homebtnclicked)
self.tbar.insert(self.refreshbtn, 0)
self.tbar.insert(self.upbtn, 1)
self.tbar.insert(self.gobtn, 2)
self.tbar.insert(self.homebtn, 3)
scrolled = gtk.ScrolledWindow()
self.fbtv = FileBrowserTV(path)
self.pathentry.set_text(self.fbtv.path)
self.fbtv.connect("row-activated", self._ontvitemclicked)
scrolled.add(self.fbtv)
self.pack_start(self.tbar, False, False, 0)
self.pack_start(scrolled, True, True, 0)
self.matchfilenameexpander = gtk.Expander("Match Filename:")
self.pack_start(self.matchfilenameexpander, False, False, 2)
self.matchfilenameentry = gtk.Entry()
self.matchfilenameentry.connect("key-press-event",
self._onmatchfilenameentry_keypressed)
self.matchfilenameexpander.add(self.matchfilenameentry)
#FIXME:
self.matchfilename = ""
def _build_toolbar(self):
_toolbar = gtk.Toolbar()
_toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
_toolbar.set_style(gtk.TOOLBAR_BOTH)
_toolbar.set_border_width(5)
_btnNew = self._build_toolbar_button(gtk.STOCK_NEW, "New",
"Starts a new simulation",
self.__on_new_game)
_toolbar.insert(_btnNew, -1)
_btnAbout = self._build_toolbar_button(gtk.STOCK_ABOUT, "About",
"About this program",
self.__on_about)
_toolbar.insert(_btnAbout, -1)
_toolbar.insert(gtk.SeparatorToolItem(), -1)
self._score, ti = self._build_toolbar_label('Score: ', '0')
_toolbar.insert(ti, -1)
return _toolbar
def __init__(self):
gobject.threads_init()
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.resize(700, 480)
#self.window.fullscreen()
self.window.maximize()
self.window.set_resizable(True)
self.window.set_title("My Window")
self.window.connect("delete_event", self.delete_event)
self.window.connect("destroy", self.destroy)
self.web_view = webkit.WebView()
self.web_view.open(self.default_site)
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)
refresh_button = gtk.ToolButton(gtk.STOCK_REFRESH)
refresh_button.connect("clicked", self.refresh)
#toolbar.add(self.back_button)
#toolbar.add(self.forward_button)
#toolbar.add(refresh_button)
self.url_bar = gtk.Entry()
#self.url_bar.connect("activate", self.on_active)
self.web_view.connect("load_committed", self.update_buttons)
scroll_window = gtk.ScrolledWindow(None, None)
scroll_window.add(self.web_view)
vbox = gtk.VBox(False, 0)
vbox.pack_start(toolbar, False, True, 0)
#vbox.pack_start(self.url_bar, False, True, 0)
vbox.add(scroll_window)
self.window.add(vbox)
self.window.show_all()
def _buildToolBar(self):
"""
Builds The IDE toolbar
Returns The toolbar.
"""
handlebox = gtk.HandleBox()
self.toolbar = gtk.Toolbar()
self.toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
self.toolbar.set_style(gtk.TOOLBAR_BOTH)
self.toolbar.set_border_width(5)
self._addToolbarStock(self.toolbar,
gtk.STOCK_NEW,
_("New"),
_("Create New File"),
callback=None)
self._addToolbarStock(self.toolbar,
gtk.STOCK_OPEN,
_("Open"),
_("Open File"),
callback=None)
self._addToolbarStock(self.toolbar,
gtk.STOCK_SAVE,
_("Save"),
_("Save File"),
callback=None)
self.toolbar.insert(gtk.SeparatorToolItem(), -1)
self._addToolbarStock(self.toolbar,
gtk.STOCK_EXECUTE,
_("Compile"),
_("Compile"),
callback=None)
self._addToolbarStock(self.toolbar,
gtk.STOCK_GO_UP,
_("Upload"),
_("Upload"),
callback=None)
handlebox.add(self.toolbar)
return handlebox
def __init__(self):
gtk.EventBox.__init__(self)
self.set_border_width(4)
toolbar = gtk.Toolbar()
self.modify_bg(gtk.STATE_NORMAL, get_colors("toolbars"))
toolbar.modify_bg(gtk.STATE_NORMAL, get_colors("toolbars"))
toolbar.modify_fg(gtk.STATE_NORMAL, get_colors("drawingplayer"))
toolbar.insert(get_separador(draw=False, ancho=0, expand=True), -1)
archivo = os.path.join(BASE_PATH, "Iconos", "lista.svg")
boton = get_boton(archivo, flip=False, pixels=45)
boton.set_tooltip_text("Listar Archivos")
boton.connect("clicked", self.__emit_senial, "Configurar")
toolbar.insert(boton, -1)
toolbar.insert(get_separador(draw=False, ancho=3, expand=False), -1)
archivo = os.path.join(BASE_PATH, "Iconos", "rotar.svg")
boton = get_boton(archivo, flip=False, pixels=45)
boton.set_tooltip_text("Izquierda")
boton.connect("clicked", self.__emit_senial, 'Izquierda')
toolbar.insert(boton, -1)
archivo = os.path.join(BASE_PATH, "Iconos", "rotar.svg")
boton = get_boton(archivo, flip=True, pixels=45)
boton.set_tooltip_text("Derecha")
boton.connect("clicked", self.__emit_senial, 'Derecha')
toolbar.insert(boton, -1)
toolbar.insert(get_separador(draw=False, ancho=0, expand=True), -1)
archivo = os.path.join(BASE_PATH, "Iconos", "lista.svg")
boton = get_boton(archivo, flip=False, pixels=45)
boton.set_tooltip_text("Volver al Menú")
boton.connect("clicked", self.__emit_senial, "Salir")
toolbar.insert(boton, -1)
self.add(toolbar)
self.show_all()
def get_widgets(self):
toolbar = gtk.Toolbar()
items = {}
for data in toolbar_data:
label, stock_id, callback, sub_callback = data
cb = make_callback(self.window, callback, sub_callback)
icon = gtk.Image()
icon.set_from_stock(stock_id, gtk.ICON_SIZE_BUTTON)
items[callback] = toolbar.append_item(label, label, None, icon, cb)
toolbar.append_space()
filter_box, entry = self.get_filter_box()
toolbar.append_widget(filter_box, 'Partition name filter', None)
return toolbar, items, entry
def __init__(self, tipo="gnome", proyecto=None):
gtk.Frame.__init__(self)
self.set_label(" Selecciona un Icono para Tu Aplicación ")
self.set_border_width(15)
self.tipo = tipo # FIXME: tipo debe determinar que formato de ico se permite (svg para sugar)
self.proyecto = proyecto
toolbar = gtk.Toolbar()
self.image = gtk.Image()
self.image.set_size_request(50, 50)
boton = get_boton(gtk.STOCK_OPEN, "Buscar Archivo")
self.aceptar = gtk.Button("Construir Instalador")
self.aceptar.set_sensitive(False)
toolbar.insert(get_separador(draw=False, ancho=10, expand=False), -1)
item = gtk.ToolItem()
item.add(self.image)
toolbar.insert(item, -1)
toolbar.insert(get_separador(draw=False, ancho=10, expand=False), -1)
toolbar.insert(boton, -1)
toolbar.insert(get_separador(draw=False, ancho=0, expand=True), -1)
item = gtk.ToolItem()
item.add(self.aceptar)
toolbar.insert(item, -1)
toolbar.insert(get_separador(draw=False, ancho=10, expand=False), -1)
self.add(toolbar)
self.show_all()
boton.connect("clicked", self.__open_filechooser)
self.aceptar.connect("clicked", self.__Construir)
def __init__(self):
gobject.threads_init()
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title('EOQ IDE')
self.window.maximize()
self.window.connect("delete_event", self.delete_event)
self.window.connect("destroy", self.destroy)
self.web_view = webkit.WebView()
self.web_view.open(self.default_site)
toolbar = gtk.Toolbar()
self.home_button = gtk.ToolButton(gtk.STOCK_HOME)
self.home_button.connect("clicked", self.go_home)
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)
execute_button = gtk.ToolButton(gtk.STOCK_EXECUTE)
execute_button.connect("clicked", self.execute)
refresh_button = gtk.ToolButton(gtk.STOCK_REFRESH)
refresh_button.connect("clicked", self.refresh)
toolbar.add(self.home_button)
toolbar.add(self.back_button)
toolbar.add(self.forward_button)
toolbar.add(refresh_button)
toolbar.add(execute_button)
self.web_view.connect("load_committed", self.update_buttons)
scroll_window = gtk.ScrolledWindow(None, None)
scroll_window.add(self.web_view)
vbox = gtk.VBox(False, 0)
vbox.pack_start(toolbar, False, True, 0)
vbox.add(scroll_window)
self.window.add(vbox)
self.window.show_all()
def create_toolbar(self):
'''This function creates a toolbar which is displayed next to the table'''
toolbar = gtk.Toolbar()
toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
toolbar.set_style(gtk.TOOLBAR_ICONS)
toolbar.set_border_width(1)
tooltips = gtk.Tooltips()
for pos, stock, handler, data, tooltip in (
(0, gtk.STOCK_ADD, self.on_add_row, None,
_('Add row')), # T: tooltip on mouse hover
(1, gtk.STOCK_DELETE, self.on_delete_row, None,
_('Remove row')), # T: tooltip on mouse hover
(2, gtk.STOCK_COPY, self.on_clone_row, None,
_('Clone row')), # T: tooltip on mouse hover
(3, None, None, None, None),
(4, gtk.STOCK_GO_UP, self.on_move_row, -1,
_('Row up')), # T: tooltip on mouse hover
(5, gtk.STOCK_GO_DOWN, self.on_move_row, 1,
_('Row down')), # T: tooltip on mouse hover
(6, None, None, None, None),
(7, gtk.STOCK_PREFERENCES, self.on_change_columns, None,
_('Change columns')), # T: tooltip on mouse hover
(8, None, None, None, None),
(9, gtk.STOCK_HELP, self.on_open_help, None,
_('Open help')), # T: tooltip on mouse hover
):
if stock is None:
toolbar.insert(gtk.SeparatorToolItem(), pos)
else:
button = gtk.ToolButton(stock)
if data:
button.connect('clicked', handler, data)
else:
button.connect('clicked', handler)
tooltips.set_tip(button, tooltip)
toolbar.insert(button, pos)
toolbar.set_size_request(300, -1)
toolbar.set_icon_size(gtk.ICON_SIZE_MENU)
return toolbar
def __init__(self, parent=None):
gtk.Window.__init__(self)
try:
self.set_screen(parent.get_screen())
except AttributeError:
self.connect('destroy', lambda *w: gtk.main_quit())
self.set_icon_from_file(ICON_IMAGE)
self.tbbox = gtk.HBox(False)
self.tbbox.set_border_width(12)
self.add(self.tbbox)
self.toolbar = gtk.Toolbar()
self.toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
self.toolbar.set_style(gtk.TOOLBAR_ICONS)
# git button
iconw = gtk.Image() # icon widget
iconw.set_from_file(GIT_IMAGE)
self.git_button = self.toolbar.append_item("git pull",
"get latest version",
"Private", iconw, self.git)
self.git_button.set_size_request(80, 34)
# lights
self.image = gtk.Image()
self.image.set_from_file(BUTTON_GREEN)
self.image.set_tooltip_text("Connected and up to date.")
self.image2 = gtk.Image()
self.image2.set_from_file(BUTTON_ORANGE)
self.image2.set_tooltip_text("Connected and not up to date.")
self.image3 = gtk.Image()
self.image3.set_from_file(BUTTON_RED)
self.image3.set_tooltip_text("Not connected.")
# start with a red light
self.tbbox.pack_end(self.image3, False, False)
self.tbbox.pack_end(self.toolbar, False, False)
self.timer = gobject.timeout_add(1000, self.is_connected)
self.show_all()
def build_size_toolbar(self, toolbox):
size_bar = gtk.Toolbar()
#Horizontal
item1 = gtk.ToolItem()
label1 = gtk.Label()
label1.set_text(' %s ' % _('H'))
item1.add(label1)
size_bar.insert(item1, -1)
item2 = gtk.ToolItem()
self.h_spin = gtk.SpinButton()
self.h_spin.set_range(2, 30)
self.h_spin.set_increments(1, 2)
self.h_spin.props.value = self.game_size[0]
self.h_spin.connect('notify::value', self.h_spin_change)
item2.add(self.h_spin)
size_bar.insert(item2, -1)
#Vertical
item3 = gtk.ToolItem()
label2 = gtk.Label()
label2.set_text(' %s ' % _('V'))
item3.add(label2)
size_bar.insert(item3, -1)
item4 = gtk.ToolItem()
self.v_spin = gtk.SpinButton()
self.v_spin.set_range(2, 20)
self.v_spin.set_increments(1, 2)
self.v_spin.props.value = self.game_size[1]
self.v_spin.connect('notify::value', self.v_spin_change)
item4.add(self.v_spin)
size_bar.insert(item4, -1)
size_bar.show_all()
size_button = ToolbarButton(label=_('Board size'),
page=size_bar,
icon_name='preferences-system')
toolbox.toolbar.insert(size_button, -1)
size_button.show()
def test():
window = gtk.Window()
window.resize(200,100)
window.connect('destroy', gtk.main_quit)
toolbar = gtk.Toolbar()
window.add(toolbar)
menu = gtk.Menu()
menu.append(gtk.MenuItem('menuitem 1'))
menu.append(gtk.MenuItem('menuitem 2'))
menu.append(gtk.MenuItem('menuitem 3'))
menu.append(gtk.MenuItem('menuitem 4'))
menu.append(gtk.MenuItem('menuitem 5'))
menu.show_all()
action = gtk.Action('menu', None, 'Tooltip', None)
action.set_tool_item_type(DropDownMenuToolButton)
toolitem = action.create_tool_item()
print "set arrow"
toolitem.set_arrow()
print "set label"
toolitem.set_label("test")
print "set arrow"
toolitem.set_arrow()
print "set stock id"
toolitem.set_label(None)
toolitem.set_stock_id(gtk.STOCK_SELECT_ALL)
print "set arrow"
toolitem.set_arrow()
print "set icon widget"
arrow = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE)
arrow.show()
toolitem.set_icon_widget(arrow)
print "set arrow"
toolitem.set_arrow()
#
toolitem.set_property('menu', menu)
toolbar.insert(toolitem, 0)
window.show_all()
gtk.main()
def __init__(self):
gtk.EventBox.__init__(self)
toolbar = gtk.Toolbar()
self.modify_bg(gtk.STATE_NORMAL, get_colors("toolbars"))
toolbar.modify_bg(gtk.STATE_NORMAL, get_colors("toolbars"))
toolbar.insert(get_separador(draw=False, ancho=3, expand=False), -1)
archivo = os.path.join(BASE_PATH, "Iconos", "JAMedia.svg")
boton = get_boton(archivo, flip=False, pixels=35)
boton.set_tooltip_text("Creditos")
boton.connect("clicked", self.__show_credits)
toolbar.insert(boton, -1)
archivo = os.path.join(BASE_PATH, "Iconos", "JAMedia-help.svg")
boton = get_boton(archivo, flip=False, pixels=24)
boton.set_tooltip_text("Ayuda")
boton.connect("clicked", self.__show_help)
toolbar.insert(boton, -1)
archivo = os.path.join(BASE_PATH, "Iconos", "configurar.svg")
self.configurar = get_boton(archivo, flip=False, pixels=24)
self.configurar.set_tooltip_text("Configuraciones")
self.configurar.connect("clicked", self.__emit_accion, "show-config")
toolbar.insert(self.configurar, -1)
toolbar.insert(get_separador(draw=False, ancho=0, expand=True), -1)
archivo = os.path.join(BASE_PATH, "Iconos", "button-cancel.svg")
boton = get_boton(archivo, flip=False, pixels=24)
boton.set_tooltip_text("Salir")
boton.connect("clicked", self.__emit_accion, "salir")
toolbar.insert(boton, -1)
toolbar.insert(get_separador(draw=False, ancho=3, expand=False), -1)
self.add(toolbar)
self.show_all()
def __init__(self):
gtk.EventBox.__init__(self)
self.modify_bg(0, gtk.gdk.Color(65000, 65000, 65000))
self.modify_fg(0, gtk.gdk.Color(0, 0, 0))
toolbar = gtk.Toolbar()
toolbar.modify_bg(0, gtk.gdk.Color(65000, 65000, 65000))
toolbar.modify_fg(0, gtk.gdk.Color(0, 0, 0))
self.direccion = None
self.modelo = None
self.iter = None
toolbar.insert(get_separador(draw=False, ancho=0, expand=True), -1)
archivo = os.path.join(ICONOS, "button-cancel.svg")
boton = get_boton(archivo, flip=False, pixels=30)
boton.set_tooltip_text("Cancelar")
boton.connect("clicked", self.cancelar)
toolbar.insert(boton, -1)
item = gtk.ToolItem()
item.set_expand(True)
self.label = gtk.Label("")
self.label.modify_fg(0, gtk.gdk.Color(0, 0, 0))
self.label.show()
item.add(self.label)
toolbar.insert(item, -1)
archivo = os.path.join(ICONOS, "dialog-ok.svg")
boton = get_boton(archivo, flip=False, pixels=30)
boton.set_tooltip_text("Aceptar")
boton.connect("clicked", self.emit_borrar)
toolbar.insert(boton, -1)
toolbar.insert(get_separador(draw=False, ancho=0, expand=True), -1)
self.add(toolbar)
self.show_all()
def __init__(self):
gtk.EventBox.__init__(self)
self.modify_bg(0, gtk.gdk.Color(0, 0, 0))
self.modify_fg(0, gtk.gdk.Color(65000, 65000, 65000))
toolbar = gtk.Toolbar()
toolbar.modify_bg(0, gtk.gdk.Color(0, 0, 0))
toolbar.modify_fg(0, gtk.gdk.Color(65000, 65000, 65000))
toolbar.insert(get_separador(draw=False, ancho=3, expand=False), -1)
imagen = gtk.Image()
icono = os.path.join(ICONOS, "JAMediaExplorer.svg")
pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(icono, -1, 37)
imagen.set_from_pixbuf(pixbuf)
#imagen.modify_bg(0, Gdk.Color(0, 0, 0))
imagen.show()
item = gtk.ToolItem()
item.add(imagen)
toolbar.insert(item, -1)
menu = Menu()
item = gtk.ToolItem()
#item.set_size_request(100, -1)
item.set_expand(True)
item.add(menu)
menu.connect('accion_ver', self.__re_emit_accion_ver)
toolbar.insert(item, -1)
toolbar.insert(get_separador(draw=False, ancho=0, expand=True), -1)
archivo = os.path.join(ICONOS, "button-cancel.svg")
boton = get_boton(archivo, flip=False, pixels=37)
boton.set_tooltip_text("Salir")
boton.connect("clicked", self.emit_salir)
toolbar.insert(boton, -1)
self.add(toolbar)
self.show_all()
def create_visual_elements(self):
# create visual elements
self.toolbar = gtk.Toolbar()
self.toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
self.toolbar.set_style(gtk.TOOLBAR_BOTH)
my_images_button = self.append_toolbar_button(
self.toolbar, "Images", hic.ICON_IMAGES_DISPLAY_FILE,
hic.ICON_IMAGES_HOVER_FILE, "Open previously built images",
self.my_images_button_clicked_cb)
settings_button = self.append_toolbar_button(
self.toolbar, "Settings", hic.ICON_SETTINGS_DISPLAY_FILE,
hic.ICON_SETTINGS_HOVER_FILE, "View additional build settings",
self.settings_button_clicked_cb)
self.config_top_button = self.add_onto_top_bar(self.toolbar)
self.gtable = gtk.Table(40, 40, True)
self.create_config_machine()
self.create_config_baseimg()
self.config_build_button = self.create_config_build_button()
def __init__(self):
gtk.EventBox.__init__(self)
self.set_border_width(4)
toolbar = gtk.Toolbar()
self.modify_bg(gtk.STATE_NORMAL, get_colors("toolbars"))
toolbar.modify_bg(gtk.STATE_NORMAL, get_colors("toolbars"))
toolbar.modify_fg(gtk.STATE_NORMAL, get_colors("drawingplayer"))
toolbar.insert(get_separador(draw=False, ancho=3, expand=False), -1)
archivo = os.path.join(BASE_PATH, "Iconos", "stop.svg")
self.boton_stop = get_boton(archivo, flip=False, pixels=45)
self.boton_stop.set_sensitive(False)
self.boton_stop.set_tooltip_text("Detener")
self.boton_stop.connect("clicked", self.__emit_senial, "Stop")
toolbar.insert(self.boton_stop, -1)
item = gtk.ToolItem()
item.set_expand(True)
self.info = gtk.Label("")
self.info.set_alignment(0.0, 0.5)
self.info.modify_fg(0, get_colors("drawingplayer"))
self.info.show()
item.add(self.info)
toolbar.insert(item, -1)
toolbar.insert(get_separador(draw=False, ancho=0, expand=True), -1)
archivo = os.path.join(BASE_PATH, "Iconos", "lista.svg")
self.boton_menu = get_boton(archivo, flip=False, pixels=45)
self.boton_menu.set_tooltip_text("Volver al Menú")
self.boton_menu.connect("clicked", self.__emit_senial, "Salir")
toolbar.insert(self.boton_menu, -1)
self.add(toolbar)
self.show_all()
def __init__(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("delete_event", self.delete_event)
self.window.connect("destroy", self.destroy)
self.controller = SelectActionWindowController(self.window)
self.toolbar = gtk.Toolbar()
self.toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
self.toolbar.set_style(gtk.TOOLBAR_BOTH)
self.toolbar.append_item(
"Create", "Create a new public key", "",
gtk.image_new_from_stock(gtk.STOCK_NEW,
gtk.ICON_SIZE_LARGE_TOOLBAR),
KeyHelper.show_next_public_key_dialog)
self.toolbar.append_space()
self.toolbar.append_item(
"Sign", "Sign a partially signed transaction", "",
gtk.image_new_from_stock(gtk.STOCK_CONVERT,
gtk.ICON_SIZE_LARGE_TOOLBAR),
self.controller.create_sign_window)
self.toolbar.append_space()
self.toolbar.append_item(
"Scripts", "Manage Redeem Scripts", "",
gtk.image_new_from_file("gui/script-key-icon.png"),
self.controller.create_redeem_script_window)
self.toolbar.append_space()
self.toolbar.append_item("Keys", "Manage keys", "",
gtk.image_new_from_file("gui/encrypted.png"),
self.controller.create_key_window)
self.toolbar.append_space()
self.toolbar.append_item(
"Settings", "Change settings", "",
gtk.image_new_from_stock(gtk.STOCK_PREFERENCES,
gtk.ICON_SIZE_LARGE_TOOLBAR),
self.controller.create_settings_window)
self.window.add(self.toolbar)
self.toolbar.show()
self.window.show()
