def _toolbar(self):
toolbar = gtk.Toolbar()
button = gtk.RadioToolButton(None)
button.set_tooltip_text("Start transition")
button.set_stock_id(gtk.STOCK_GO_FORWARD)
toolbar.add(button)
self.button_run_phase1 = button
button = gtk.RadioToolButton(self.button_run_phase1, None)
button.set_tooltip_text("Start & finish transition")
button.set_stock_id(gtk.STOCK_GOTO_LAST)
toolbar.add(button)
self.button_run_phase12 = button
toolbar.add(gtk.SeparatorToolItem())
button = gtk.ToolButton(None)
button.set_tooltip_text("Receive all packets")
button.set_stock_id(gtk.STOCK_GOTO_BOTTOM)
button.connect("clicked",
lambda w: self.simulation.receive_all(
self.netview.get_perspective().get_process_ids()))
toolbar.add(button)
button = gtk.ToggleToolButton(None)
button.set_tooltip_text(
"Automatically call 'Receive all packets' after any transition action")
button.set_stock_id(gtk.STOCK_EXECUTE)
toolbar.add(button)
self.button_auto_receive = button
return toolbar
def __create_widgets(self):
"""
"""
self.__tbox = BWTable(1, 4)
self.__tbox.bw_set_spacing(0)
self.__vbox = BWVBox()
self.__jump_to = gtk.RadioToolButton(None, gtk.STOCK_JUMP_TO)
try_set_tooltip_text(self.__jump_to, 'Change focus')
self.__jump_to.connect('toggled',
self.__change_pointer,
RadialNet.POINTER_JUMP_TO)
try:
# gtk.STOCK_INFO is available only in PyGTK 2.8 and later.
info_icon = gtk.STOCK_INFO
except AttributeError:
self.__info = gtk.RadioToolButton(self.__jump_to, None)
self.__info.set_label(_("Info"))
else:
self.__info = gtk.RadioToolButton(self.__jump_to, info_icon)
try_set_tooltip_text(self.__info, 'Show information')
self.__info.connect('toggled',
self.__change_pointer,
RadialNet.POINTER_INFO)
self.__group = gtk.RadioToolButton(self.__jump_to, gtk.STOCK_ADD)
try_set_tooltip_text(self.__group, 'Group children')
self.__group.connect('toggled',
self.__change_pointer,
RadialNet.POINTER_GROUP)
self.__region = gtk.RadioToolButton(self.__jump_to,
gtk.STOCK_SELECT_COLOR)
try_set_tooltip_text(self.__region, 'Fill region')
self.__region.connect('toggled',
self.__change_pointer,
RadialNet.POINTER_FILL)
self.__region_color = gtk.combo_box_new_text()
self.__region_color.append_text(_('Red'))
self.__region_color.append_text(_('Yellow'))
self.__region_color.append_text(_('Green'))
self.__region_color.connect('changed', self.__change_region)
self.__region_color.set_active(self.radialnet.get_region_color())
self.__tbox.bw_attach_next(self.__jump_to)
self.__tbox.bw_attach_next(self.__info)
self.__tbox.bw_attach_next(self.__group)
self.__tbox.bw_attach_next(self.__region)
self.__vbox.bw_pack_start_noexpand_nofill(self.__tbox)
self.__vbox.bw_pack_start_noexpand_nofill(self.__region_color)
self.bw_add(self.__vbox)
self.__jump_to.set_active(True)
self.__region_color.set_no_show_all(True)
self.__region_color.hide()
def __create_widgets(self):
"""
"""
self.__tbox = HIGTableRNet(1, 4)
self.__tbox._set_spacing(0)
self.__vbox = HIGVBox()
self.__jump_to = gtk.RadioToolButton(None, gtk.STOCK_JUMP_TO)
self.__jump_to.set_tooltip_text('Change focus')
self.__jump_to.connect('toggled',
self.__change_pointer,
POINTER_JUMP_TO)
self.__info = gtk.RadioToolButton(self.__jump_to, gtk.STOCK_INFO)
self.__info.set_tooltip_text('Show information')
self.__info.connect('toggled',
self.__change_pointer,
POINTER_INFO)
self.__group = gtk.RadioToolButton(self.__jump_to, gtk.STOCK_ADD)
self.__group.set_tooltip_text('Group children')
self.__group.connect('toggled',
self.__change_pointer,
POINTER_GROUP)
self.__region = gtk.RadioToolButton(self.__jump_to,
gtk.STOCK_SELECT_COLOR)
self.__region.set_tooltip_text('Fill region')
self.__region.connect('toggled',
self.__change_pointer,
POINTER_FILL)
self.__region_color = gtk.combo_box_new_text()
self.__region_color.append_text('Red')
self.__region_color.append_text('Yellow')
self.__region_color.append_text('Green')
self.__region_color.connect('changed', self.__change_region)
self.__region_color.set_active(self.radialnet.get_region_color())
self.__tbox._attach_next(self.__jump_to)
self.__tbox._attach_next(self.__info)
self.__tbox._attach_next(self.__group)
self.__tbox._attach_next(self.__region)
self.__vbox._pack_noexpand_nofill(self.__tbox)
self.__vbox._pack_noexpand_nofill(self.__region_color)
self._add(self.__vbox)
self.__jump_to.set_active(True)
self.__region_color.set_no_show_all(True)
self.__region_color.hide()
def __InsertButton(self, Type, TypeDesc, Group):
newIconWidget = gtk.Image()
newIconWidget.set_from_pixbuf(Type.GetIcon())
newIconWidget.show()
newButton = gtk.RadioToolButton(Group, None)
newButton.set_icon_widget(newIconWidget)
newButton.set_tooltip(self.tooltips, Type.GetId())
newButton.connect("toggled", self.on_tbButton_toggled, Type.GetId(), TypeDesc)
newButton.show()
self.tbToolBox.insert(newButton, -1)
def __init__(self):
super(PyApp, self).__init__()
self.set_title("Toolbar Demo")
self.set_default_size(250, 200)
self.set_position(gtk.WIN_POS_CENTER)
toolbar = gtk.Toolbar()
toolbar.set_style(gtk.TOOLBAR_ICONS)
toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
newbtn = gtk.ToolButton(gtk.STOCK_NEW)
newbtn.set_tooltip_text("New")
openbtn = gtk.ToolButton(gtk.STOCK_OPEN)
savebtn = gtk.ToolButton(gtk.STOCK_SAVE)
sep = gtk.SeparatorToolItem()
rb1 = gtk.RadioToolButton(None, gtk.STOCK_JUSTIFY_LEFT)
53
rb2 = gtk.RadioToolButton(rb1, gtk.STOCK_JUSTIFY_RIGHT)
prv = gtk.ToggleToolButton(gtk.STOCK_PRINT_PREVIEW)
quitbtn = gtk.ToolButton(gtk.STOCK_QUIT)
toolbar.insert(newbtn, 0)
toolbar.insert(openbtn, 1)
toolbar.insert(savebtn, 2)
toolbar.insert(sep, 3)
toolbar.insert(rb1, 4)
toolbar.insert(rb2, 5)
toolbar.insert(prv, 6)
toolbar.insert(quitbtn, 7)
quitbtn.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_widgets(self):
"""
"""
self.__tooltips = gtk.Tooltips()
self.__nmap = gtk.RadioToolButton(None, gtk.STOCK_FIND)
self.__nmap.set_label('Nmap')
self.__nmap.set_is_important(True)
self.__nmap.connect('toggled', self.__backend_callback, BACKEND_NMAP)
self.__nmap.set_tooltip(self.__tooltips, _("Nmap as backend"))
self.__nmap.set_active(True)
self.__backend_callback(self.__nmap, BACKEND_NMAP)
self.insert(self.__nmap, 0)
def _create_lessons_toolbar(self):
toolbar = gtk.Toolbar()
for lesson in lessons.THEMES:
button = gtk.RadioToolButton()
button.set_label(lesson.name)
if toolbar.get_n_items():
button.props.group = toolbar.get_nth_item(0)
button.connect('clicked', self.__lesson_clicked_cb, lesson)
toolbar.insert(button, -1)
toolbar.get_nth_item(0).set_active(True)
toolbar.show_all()
return toolbar
def sig_reload(self, widget=None):
self.tree_sc.update()
ids = rpc.session.rpc_exec_auth('/object', 'execute', self.model,
'search', self.domain2)
if self.tree_res.toolbar:
icon_name = 'icon'
wid = self.glade.get_widget('tree_toolbar')
for w in wid.get_children():
wid.remove(w)
c = {}
c.update(rpc.session.context)
res_ids = rpc.session.rpc_exec_auth_try('/object', 'execute',
self.view['model'], 'read',
ids, ['name', icon_name],
c)
rb = None
for r in res_ids:
rb = gtk.RadioToolButton(group=rb)
l = gtk.Label(r['name'])
rb.set_label_widget(l)
icon = gtk.Image()
if icon_name in r:
if hasattr(r[icon_name], 'startswith'
) and r[icon_name].startswith('STOCK_'):
icon.set_from_stock(getattr(gtk, r[icon_name]),
gtk.ICON_SIZE_BUTTON)
else:
try:
icon.set_from_stock(r[icon_name],
gtk.ICON_SIZE_BUTTON)
except:
pass
hb = gtk.HBox(spacing=6)
hb.pack_start(icon)
hb.pack_start(gtk.Label(r['name']))
rb.set_icon_widget(hb)
rb.show_all()
rb.set_data('id', r['id'])
rb.connect('clicked', self.menu_main_clicked)
self.menu_main_clicked(rb)
wid.insert(rb, -1)
else:
self.tree_res.ids = ids
self.tree_res.reload()
wid = self.glade.get_widget('widget_vbox')
wid.hide()
def append_page(self, contentview):
#label = widgets.hyperlink('', icon=contentview.icon)
label = contentview.icon
group = None
if len(self.__buttons):
group = self.__buttons.values()[0]
button = gtk.RadioToolButton(group)
#button.set_icon_widget(label)
#button.set_mode(False)
button.set_active(True)
button.set_icon_widget(label)
button.connect('toggled', self.cb_button_clicked,
contentview.unique_id)
self.__views[contentview.unique_id] = label
self.__buttons[contentview.unique_id] = button
self.pack_start(button, expand=False)
def __init__(self):
dialog = gtk.Dialog()
dialog.connect("delete-event", gtk.main_quit)
dialog.set_size_request(450, -1)
dialog.set_resizable(True)
# to make it nice we'll put the toolbar into the handle box,
# so that it can be detached from the main window
handlebox = gtk.HandleBox()
dialog.vbox.pack_start(handlebox, False, False, 5)
# toolbar will be horizontal, with both icons and text, and
# with 5pxl spaces between items and finally,
# we'll also put it into our handlebox
toolbar = gtk.Toolbar()
toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
toolbar.set_style(gtk.TOOLBAR_BOTH)
toolbar.set_border_width(5)
handlebox.add(toolbar)
self.buttons = []
for a in range(0, 5):
if a == 0:
#first button with none group
widget = None
else:
#additional buttons with belong to the group of the first button
widget = but
but = gtk.RadioToolButton(group=widget, stock_id=gtk.STOCK_APPLY)
but.set_label("button %d" % a)
but.connect("clicked", self.radio_event, a)
toolbar.insert(but, a)
self.buttons.append(but)
dialog.show_all()
def __init__(self, client=None):
super(MainWindow, self).__init__()
if client is None:
client = Client()
def channel_compare_cb(model, a, b):
a, = model.get(a, 0)
b, = model.get(b, 0)
return (cmp(a.title, b.title) or cmp(a.tags, b.tags)
or cmp(a.station.title, b.station.title))
channels = gtk.ListStore(object)
channels.set_sort_func(0, channel_compare_cb)
channels.set_sort_column_id(0, gtk.SORT_ASCENDING)
tag_completion = TagsCompletion(client.get_tags())
self.__current_title = None
def read_wishlist():
filename = get_config_filename('wishlist')
wishlist = []
try:
text = file(filename).read().strip()
wishlist = text and text.split('\n') or []
except IOError:
pass
return dict(zip(wishlist, range(len(wishlist))))
self.__wishlist = read_wishlist()
def channel_added_cb(client, channel):
tree_iter = channels.insert(-1, (channel, ))
tag_completion.add(channel.tags)
if (channel == client.current_channel
or (channel.uri == self.__config.channel_uri
and client.current_channel is None)):
model = tree_view.get_model()
tree_iter = model.convert_child_iter_to_iter(tree_iter)
tree_view.get_selection().select_iter(tree_iter)
def state_changed_cb(client):
if client.is_playing:
self.__config.channel_uri = client.current_channel.uri
self.__play_button.set_active(True)
stream_tags_changed_cb(client)
else:
self.__pause_button.set_active(True)
self.__stream_info.hide()
tree_view.queue_draw()
def stream_tags_changed_cb(client):
self.__current_title = client.stream_tags.get(
'title').strip() or None
org = client.stream_tags.get('organization').strip() or None
markup = []
if self.__current_title:
markup.append('<b>%s</b>' %
glib.markup_escape_text(self.__current_title))
if org:
markup.append('<small>%s</small>' %
glib.markup_escape_text(org))
if markup:
self.__stream_info.set_markup(' - '.join(markup))
self.__stream_info.set_tooltip_markup('\n'.join(markup))
self.__stream_info.show()
else:
self.__stream_info.set_markup('')
self.__stream_info.hide()
self.__favorite_button.set_sensitive(bool(self.__current_title))
self.__favorite_button.set_active(
self.__current_title in self.__wishlist)
self.__client = client
self.__client.connect('channel-added', channel_added_cb)
self.__client.connect('state-changed', state_changed_cb)
self.__client.connect('stream-tags-changed', stream_tags_changed_cb)
self.__client.wait(Client.STATE_STATIONS_LOADED)
self.__filter_timeout = 0
self.__current_tags = []
self.__config = Configuration()
def channel_visible_cb(model, iter):
channel, = model.get(iter, 0)
return channel.matches(self.__current_tags)
matching_channels = gtk.TreeModel.filter_new(channels)
matching_channels.set_visible_func(channel_visible_cb)
self.set_title('WebRadio')
self.set_default_size(500, 400)
self.set_icon_name('rhythmbox')
self.connect('destroy', gtk.main_quit)
vbox = gtk.VBox()
self.add(vbox)
toolbar = gtk.Toolbar()
toolbar.set_show_arrow(False)
vbox.pack_start(toolbar, expand=False)
def play_button_clicked_cb(button):
if not button.get_active():
self.__client.pause()
return
model, tree_iter = tree_view.get_selection().get_selected()
channel = None
if model and tree_iter:
channel, = model.get(tree_iter, 0)
if channel is not None:
if channel == self.__client.current_channel:
self.__client.resume()
else:
self.__client.play(channel)
def favorite_button_clicked_cb(button):
if not self.__current_title:
return
if button.get_active():
self.__wishlist[self.__current_title] = True
else:
self.__wishlist.pop(self.__current_title, False)
wishlist_text = '\n'.join(self.__wishlist.keys()) + '\n'
filename = get_config_filename('wishlist')
file(filename, 'w').write(wishlist_text)
self.__play_button = gtk.RadioToolButton(None, gtk.STOCK_MEDIA_PLAY)
self.__play_button.connect('clicked', play_button_clicked_cb)
self.__play_button.set_is_important(True)
toolbar.insert(self.__play_button, -1)
self.__pause_button = gtk.RadioToolButton(self.__play_button,
gtk.STOCK_MEDIA_PAUSE)
toolbar.insert(self.__pause_button, -1)
self.__favorite_button = gtk.ToggleToolButton(gtk.STOCK_ABOUT)
self.__favorite_button.connect('clicked', favorite_button_clicked_cb)
toolbar.insert(self.__favorite_button, -1)
item = gtk.SeparatorToolItem()
item.set_expand(True)
item.set_draw(False)
toolbar.insert(item, -1)
item = gtk.ToolItem()
toolbar.insert(item, -1)
def filter_timeout_cb(entry):
self.__current_tags = filter(None, entry.get_text().split(' '))
matching_channels.refilter()
self.__filter_timeout = 0
return False
def filter_entry_changed_cb(entry, *args):
if self.__filter_timeout:
glib.source_remove(self.__filter_timeout)
self.__filter_timeout = glib.timeout_add(200, filter_timeout_cb,
entry)
self.__filter_entry = gtk.Entry()
self.__filter_entry.set_width_chars(40)
self.__filter_entry.set_completion(tag_completion)
self.__filter_entry.connect('changed', filter_entry_changed_cb)
item.add(self.__filter_entry)
scrolled = gtk.ScrolledWindow()
scrolled.set_shadow_type(gtk.SHADOW_IN)
scrolled.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
vbox.pack_start(scrolled, expand=True)
def row_activated_cb(view, path, column):
model = view.get_model()
channel, = model.get(model.get_iter(path), 0)
self.__client.play(channel)
tree_view = gtk.TreeView(matching_channels)
tree_view.set_headers_visible(False)
tree_view.connect('row-activated', row_activated_cb)
scrolled.add(tree_view)
def adjustment_cb(adjustment):
model, tree_iter = tree_view.get_selection().get_selected()
if model and tree_iter:
path = model.get_path(tree_iter)
tree_view.scroll_to_cell(path, None, True, 0.5, 0.5)
tree_view.get_vadjustment().connect('changed', adjustment_cb)
def icon_cell_data_cb(column, cell, model, iter):
channel, = model.get(iter, 0)
if channel != self.__client.current_channel:
cell.set_property('stock-id', None)
elif self.__client.is_playing:
cell.set_property('stock-id', gtk.STOCK_MEDIA_PLAY)
else:
cell.set_property('stock-id', gtk.STOCK_MEDIA_PAUSE)
def text_cell_data_cb(column, cell, model, iter):
channel, = model.get(iter, 0)
title, tags = channel.title, channel.tags
tags = [channel.station.id] + list(tags)
details = title, ' '.join(tags), channel.station.title
details = tuple(map(glib.markup_escape_text, details))
markup = '<b>%s</b>\n<small>%s - %s</small>' % details
cell.set_property('markup', markup)
cell = gtk.CellRendererPixbuf()
cell.set_properties(stock_size=gtk.ICON_SIZE_MENU)
column = gtk.TreeViewColumn('Icon', cell)
column.set_cell_data_func(cell, icon_cell_data_cb)
column.set_expand(False)
tree_view.insert_column(column, -1)
cell = gtk.CellRendererText()
cell.set_properties(ellipsize=pango.ELLIPSIZE_END)
column = gtk.TreeViewColumn(None, cell)
column.set_cell_data_func(cell, text_cell_data_cb)
tree_view.insert_column(column, -1)
self.__stream_info = MarqueLabel()
self.__stream_info.set_no_show_all(True)
vbox.pack_start(self.__stream_info, expand=False)
stream_tags_changed_cb(self.__client)
state_changed_cb(self.__client)
tags = (self.__config.tags or '').strip()
self.__filter_entry.grab_focus()
self.__filter_entry.set_text(tags + ' ')
self.__filter_entry.set_position(-1)
for station in self.__client.get_stations():
for channel in station.channels:
channel_added_cb(self.__client, channel)
self.get_child().show_all()
def __init__(self, goocalendar):
super(Toolbar, self).__init__()
self.goocalendar = goocalendar
self.accel_group = Main.get_main().accel_group
today_button = gtk.ToolButton()
today_button.set_label(_('Today'))
today_button.set_homogeneous(False)
today_button.connect("clicked", self.on_today_button_clicked)
today_button.add_accelerator("clicked", self.accel_group,
gtk.keysyms.t, gtk.gdk.MODIFIER_MASK,
gtk.ACCEL_VISIBLE)
self.insert(today_button, -1)
arrow_left = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE)
go_back = gtk.ToolButton()
go_back.set_icon_widget(arrow_left)
go_back.set_label(_("go back"))
go_back.set_expand(False)
go_back.set_homogeneous(False)
go_back.connect("clicked", self.on_go_back_clicked)
self.insert(go_back, -1)
self.current_page_label = gtk.Label("")
self.current_page = gtk.ToggleToolButton()
self.current_page.set_label_widget(self.current_page_label)
self.current_page.connect("clicked", self.on_current_page_clicked)
self.insert(self.current_page, -1)
self.__cal_popup = gtk.Window(gtk.WINDOW_POPUP)
self.__cal_popup.set_events(self.__cal_popup.get_events()
| gtk.gdk.KEY_PRESS_MASK)
self.__cal_popup.set_resizable(False)
self.__cal_popup.connect('delete-event', self.on_cal_popup_closed)
self.__cal_popup.connect('key-press-event',
self.on_cal_popup_key_pressed)
self.__cal_popup.connect('button-press-event',
self.on_cal_popup_button_pressed)
gtkcal = gtk.Calendar()
gtkcal.connect('day-selected', self.on_gtkcal_day_selected)
gtkcal.connect('day-selected-double-click',
self.on_gtkcal_day_selected_double_click)
gtkcal.set_display_options(gtk.CALENDAR_SHOW_HEADING
| gtk.CALENDAR_SHOW_WEEK_NUMBERS
| gtk.CALENDAR_SHOW_DAY_NAMES)
gtkcal.set_no_show_all(True)
self.__cal_popup.add(gtkcal)
gtkcal.show()
self.gtkcal = gtkcal
self.goocalendar.connect('day-selected',
self.on_goocalendar_day_selected)
arrow_right = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE)
go_forward = gtk.ToolButton()
go_forward.set_icon_widget(arrow_right)
go_forward.set_label(_("go forward"))
go_forward.set_expand(False)
go_forward.set_homogeneous(False)
go_forward.connect("clicked", self.on_go_forward_clicked)
self.insert(go_forward, -1)
arrow_left = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE)
previous_year = gtk.ToolButton()
previous_year.set_icon_widget(arrow_left)
previous_year.set_label(_("previous year"))
previous_year.set_expand(False)
previous_year.set_homogeneous(False)
previous_year.connect("clicked", self.on_previous_year_clicked)
self.insert(previous_year, -1)
self.current_year_label = gtk.Label("")
current_year = gtk.ToolItem()
current_year.add(self.current_year_label)
self.insert(current_year, -1)
arrow_right = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE)
next_year = gtk.ToolButton()
next_year.set_icon_widget(arrow_right)
next_year.set_label(_("next year"))
next_year.set_expand(False)
next_year.set_homogeneous(False)
next_year.connect("clicked", self.on_next_year_clicked)
self.insert(next_year, -1)
blank_widget = gtk.ToolItem()
blank_widget.set_expand(True)
self.insert(blank_widget, -1)
week_button = gtk.RadioToolButton()
week_button.set_label(_('Week View'))
week_button.connect("clicked", self.on_week_button_clicked)
week_button.add_accelerator("clicked", self.accel_group, gtk.keysyms.w,
gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE)
self.insert(week_button, -1)
if hasattr(gtk.RadioToolButton, 'new_from_widget'):
month_button = gtk.RadioToolButton.new_from_widget(week_button)
else:
month_button = gtk.RadioToolButton(week_button)
month_button.set_label_widget(gtk.Label(_('Month View')))
month_button.connect("clicked", self.on_month_button_clicked)
month_button.add_accelerator("clicked", self.accel_group,
gtk.keysyms.m, gtk.gdk.MODIFIER_MASK,
gtk.ACCEL_VISIBLE)
self.insert(month_button, -1)
buttons = {'month': month_button, 'week': week_button}
buttons[self.goocalendar.view].set_active(True)
self.update_displayed_date()
self.set_style(gtk.TOOLBAR_ICONS)
def get_toolbar(self):
toolbar = gtk.Toolbar()
toolbar.set_style({
'default': False,
'both': gtk.TOOLBAR_BOTH,
'text': gtk.TOOLBAR_TEXT,
'icons': gtk.TOOLBAR_ICONS}[CONFIG['client.toolbar']])
self.widget.pack_start(toolbar, expand=False, fill=True)
for icon in ['bold', 'italic', 'underline']:
button = gtk.ToggleToolButton('gtk-%s' % icon)
button.connect('toggled', self.toggle_props, icon)
toolbar.insert(button, -1)
self.tag_widgets[icon] = button
toolbar.insert(gtk.SeparatorToolItem(), -1)
for name, options, active in [
('family', FAMILIES, FAMILIES.index('normal')),
('size', SIZES, SIZES.index('4')),
]:
try:
combobox = gtk.ComboBoxText()
except AttributeError:
combobox = gtk.combo_box_new_text()
for option in options:
combobox.append_text(option)
combobox.set_active(active)
combobox.set_focus_on_click(False)
combobox.connect('changed', self.change_props, name)
tool = gtk.ToolItem()
tool.add(combobox)
toolbar.insert(tool, -1)
self.tag_widgets[name] = combobox
toolbar.insert(gtk.SeparatorToolItem(), -1)
button = None
for icon in ['left', 'center', 'right', 'fill']:
name = icon
if icon == 'fill':
name = 'justify'
stock_id = 'gtk-justify-%s' % icon
if hasattr(gtk.RadioToolButton, 'new_with_stock_from_widget'):
button = gtk.RadioToolButton.new_with_stock_from_widget(
button, stock_id)
else:
button = gtk.RadioToolButton(button, stock_id)
button.set_active(icon == 'left')
button.connect('toggled', self.toggle_justification, name)
toolbar.insert(button, -1)
self.tag_widgets[name] = button
toolbar.insert(gtk.SeparatorToolItem(), -1)
for icon, label in [
('foreground', _('Foreground')),
# TODO ('background', _('Background')),
]:
button = gtk.ToolButton('tryton-text-%s' % icon)
button.set_label(label)
button.connect('clicked', self.toggle_color, icon)
toolbar.insert(button, -1)
self.tag_widgets[icon] = button
return toolbar
def __init__(self, goocalendar):
super(Toolbar, self).__init__()
self.goocalendar = goocalendar
self.accel_group = Main.get_main().accel_group
today_label = gtk.Label(_('Today'))
today_button = gtk.ToolButton(today_label)
today_button.set_homogeneous(False)
today_button.connect("clicked", self.on_today_button_clicked)
today_button.add_accelerator("clicked", self.accel_group,
gtk.keysyms.t, gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE)
self.insert(today_button, -1)
arrow_left = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE)
go_back = gtk.ToolButton(arrow_left, "go left")
go_back.set_expand(False)
go_back.set_homogeneous(False)
go_back.connect("clicked", self.on_go_back_clicked)
self.insert(go_back, -1)
self.current_page_label = gtk.Label("")
self.current_page = gtk.ToggleToolButton()
self.current_page.set_icon_widget(self.current_page_label)
self.current_page.connect("clicked", self.on_current_page_clicked)
self.insert(self.current_page, -1)
gtkcal = gtk.Calendar()
gtkcal.connect('day-selected', self.on_gtkcal_day_selected)
gtkcal.set_display_options(
gtk.CALENDAR_SHOW_HEADING |
gtk.CALENDAR_SHOW_WEEK_NUMBERS |
gtk.CALENDAR_SHOW_DAY_NAMES)
gtkcal.set_no_show_all(True)
gtkcal_item = goocanvas.Widget(widget=gtkcal)
gtkcal_item.set_property('visibility', goocanvas.ITEM_INVISIBLE)
goocalendar.get_root_item().add_child(gtkcal_item)
self.gtkcal = gtkcal
self.gtkcal_item = gtkcal_item
self.goocalendar.connect('day-selected',
self.on_goocalendar_day_selected)
arrow_right = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE)
go_forward = gtk.ToolButton(arrow_right, "go right")
go_forward.set_expand(False)
go_forward.set_homogeneous(False)
go_forward.connect("clicked", self.on_go_forward_clicked)
self.insert(go_forward, -1)
arrow_left = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE)
previous_year = gtk.ToolButton(arrow_left, "next year")
previous_year.set_expand(False)
previous_year.set_homogeneous(False)
previous_year.connect("clicked", self.on_previous_year_clicked)
self.insert(previous_year, -1)
self.current_year_label = gtk.Label("")
current_year = gtk.ToolItem()
current_year.add(self.current_year_label)
self.insert(current_year, -1)
arrow_right = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE)
next_year = gtk.ToolButton(arrow_right, "next year")
next_year.set_expand(False)
next_year.set_homogeneous(False)
next_year.connect("clicked", self.on_next_year_clicked)
self.insert(next_year, -1)
blank_widget = gtk.ToolItem()
blank_widget.set_expand(True)
self.insert(blank_widget, -1)
week_button = gtk.RadioToolButton()
week_button.set_label(_('Week View'))
week_button.connect("clicked", self.on_week_button_clicked)
week_button.add_accelerator("clicked", self.accel_group, gtk.keysyms.w,
gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE)
self.insert(week_button, -1)
month_button = gtk.RadioToolButton(week_button)
month_button.set_label(_('Month View'))
month_button.connect("clicked", self.on_month_button_clicked)
month_button.add_accelerator("clicked", self.accel_group,
gtk.keysyms.m, gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE)
month_button.set_active(True)
self.insert(month_button, -1)
self.update_displayed_date()
self.set_style(gtk.TOOLBAR_ICONS)
def __init__(self, theme, ink_canvas):
gtk.Toolbar.__init__(self)
self._inkcanvas = ink_canvas
### paint button
paint_image = gtk.Image()
paint_image.set_from_pixbuf(theme.load_icon('paintbrush', 48, 0))
paint_button = gtk.RadioToolButton()
paint_button.set_icon_widget(paint_image)
paint_button.set_label('Paintbrush')
paint_button.connect('clicked', self.__set_paint)
### eraser button
erase_image = gtk.Image()
erase_image.set_from_pixbuf(theme.load_icon('eraser', 48, 0))
erase_button = gtk.RadioToolButton(paint_button)
erase_button.set_icon_widget(erase_image)
erase_button.set_label('Eraser')
erase_button.connect('clicked', self.__set_eraser)
### Color select
self._color_label = ColorLabel(self._inkcanvas.get_stroke_color())
hbox = gtk.HBox()
hbox.pack_start(self._color_label)
hbox.pack_start(gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_IN))
color_button = gtk.ToolItem()
color_button_t = ColorButton(hbox)
color_button_t.connect('color-set', self.__color_set, paint_button)
color_button.add(color_button_t)
### clear button
imgclear = gtk.Image()
imgclear.set_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_LARGE_TOOLBAR )
clear = gtk.ToolButton(imgclear)
clear.set_label('Clear')
clear.connect( 'clicked', self.__clear_canvas )
main_img = gtk.Image()
main_img.set_from_pixbuf(theme.load_icon('medium_grid', 48, 0))
blank_img = gtk.Image()
blank_img.set_from_pixbuf(theme.load_icon('no_grid', 48, 0) )
small_img = gtk.Image()
small_img.set_from_pixbuf(theme.load_icon('small_grid', 48, 0))
medium_img = gtk.Image()
medium_img.set_from_pixbuf(theme.load_icon('medium_grid', 48, 0))
large_img = gtk.Image()
large_img.set_from_pixbuf(theme.load_icon('large_grid', 48, 0))
### grid button
grid_button_t = GridButton(
main_img, blank_img, small_img, medium_img, large_img,
self._inkcanvas.get_grid_type())
grid_button_t.connect( 'grid-type-set', self.__set_grid_type)
grid_button = gtk.ToolItem()
grid_button.add(grid_button_t)
### undo Button
undo_button = gtk.ToolButton()
undo_button.set_stock_id(gtk.STOCK_UNDO)
undo_button.connect("clicked", self.__undo)
### redo Button
redo_button = gtk.ToolButton()
redo_button.set_stock_id(gtk.STOCK_REDO)
redo_button.connect("clicked", self.__redo)
### size Slider
brushsmall_t = gtk.Image()
brushsmall_t.set_from_pixbuf(theme.load_icon('brush-small', 48, 0))
brushsmall = gtk.ToolItem()
brushsmall.add(brushsmall_t)
brushlarge_t = gtk.Image()
brushlarge_t.set_from_pixbuf(theme.load_icon('brush-large', 48, 0))
brushlarge = gtk.ToolItem()
brushlarge.add(brushlarge_t)
brush_slider_t = gtk.HScale(gtk.Adjustment(value=8, lower=1, upper=20, step_incr=0.5, page_incr=1, page_size=0))
brush_slider_t.set_size_request(130, -1)
brush_slider_t.set_value_pos(gtk.POS_RIGHT)
brush_slider_t.set_digits(0)
brush_slider_t.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
brush_slider_t.connect("value-changed", self.__set_size)
brush_slider = gtk.ToolItem()
brush_slider.add(brush_slider_t)
### toolbar
self.set_show_arrow(True)
self.insert(color_button, -1)
self.insert(gtk.SeparatorToolItem(), -1)
self.insert(paint_button, -1)
self.insert(erase_button, -1)
self.insert(gtk.SeparatorToolItem(), -1)
self.insert(undo_button, -1)
self.insert(redo_button, -1)
self.insert(gtk.SeparatorToolItem(), -1)
self.insert(clear, -1)
self.insert(gtk.SeparatorToolItem(), -1)
self.insert(grid_button, -1)
self.insert(gtk.SeparatorToolItem(), -1)
self.insert(brushsmall, -1)
self.insert(brush_slider, -1)
self.insert(brushlarge, -1)
class Gui(gtk.Window):
def __init__(self, API_KEY):
super(Gui, self).__init__()
self.connect("destroy", self.on_destroy)
self.set_border_width(5)
self.set_size_request(780, 400)
try:
self.set_icon_from_file(
os.path.join(sys.path[0], "images", "youtube.png"))
self.EMPTY_POSTER = gtk.gdk.pixbuf_new_from_file(
os.path.join(sys.path[0], "images", "blank_default.png"))
self.YOUTUBE_PIXBUF = gtk.gdk.pixbuf_new_from_file(
os.path.join(sys.path[0], "images", "youtube_16.png"))
except Exception, e:
print e.message
self.set_title(PROG_NAME)
self.results_title = ""
# Toolbar and it's items
toolbar = gtk.Toolbar()
toolbar.set_style(gtk.TOOLBAR_ICONS)
#TODO: change categories image
btn_categories = gtk.ToggleToolButton(gtk.STOCK_DIRECTORY)
btn_categories.set_tooltip_text("Show/hide categories")
btn_categories.connect("clicked", self.btn_categories_clicked)
toolbar.insert(btn_categories, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
btn_home = gtk.ToolButton(gtk.STOCK_HOME)
btn_home.set_tooltip_text("Get most popular videos for your country")
btn_home.connect("clicked", self.btn_home_clicked)
toolbar.insert(btn_home, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
bookmark_icon = gtk.Image()
bookmark_icon.set_from_file(
os.path.join(sys.path[0], "images", "bookmark_24.png"))
self.btn_saved_items = gtk.ToggleToolButton()
self.btn_saved_items.set_icon_widget(bookmark_icon)
self.btn_saved_items.set_tooltip_text("Show/hide bookmarks")
self.btn_saved_items.set_sensitive(False)
self.btn_saved_items.connect("clicked", self.btn_saved_items_clicked)
toolbar.insert(self.btn_saved_items, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
self.btn_refresh = gtk.ToolButton(gtk.STOCK_REFRESH)
self.btn_refresh.set_tooltip_text("Update results")
self.btn_refresh.connect("clicked", self.btn_refresh_clicked)
self.btn_refresh.set_sensitive(False)
toolbar.insert(self.btn_refresh, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
self.btn_prev = gtk.ToolButton(gtk.STOCK_GO_BACK)
self.btn_prev.connect("clicked", self.btn_prev_clicked)
self.btn_prev.set_sensitive(False)
toolbar.insert(self.btn_prev, -1)
self.btn_next = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
self.btn_next.connect("clicked", self.btn_next_clicked)
self.btn_next.set_sensitive(False)
toolbar.insert(self.btn_next, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
entry_item = gtk.ToolItem()
entry = gtk.Entry()
entry.set_tooltip_text("Search youtube")
entry.connect("activate", self.entry_activated)
entry_item.add(entry)
toolbar.insert(entry_item, -1)
# May use gtk_image_new_from_file
date_icon = gtk.Image()
date_icon.set_from_file(
os.path.join(sys.path[0], "images", "calendar-24.png"))
views_icon = gtk.Image()
views_icon.set_from_file(
os.path.join(sys.path[0], "images", "eye-24.png"))
self.rtb_date = gtk.RadioToolButton()
self.rtb_date.set_icon_widget(date_icon)
self.rtb_date.set_tooltip_text("Sort by date")
self.rtb_views = gtk.RadioToolButton(self.rtb_date)
self.rtb_views.set_icon_widget(views_icon)
self.rtb_views.set_tooltip_text("Sort by views")
toolbar.insert(self.rtb_date, -1)
toolbar.insert(self.rtb_views, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
self.btn_info = gtk.ToggleToolButton(gtk.STOCK_INFO)
self.btn_info.set_tooltip_text("Show/hide info")
self.btn_info.connect("clicked", self.btn_info_clicked)
self.btn_info.set_sensitive(False)
toolbar.insert(self.btn_info, -1)
# Loading indicator
self.sp_results = gtk.Spinner()
self.sp_results.set_size_request(SPINNER_SIZE, SPINNER_SIZE)
# Data
self.iv_results = gtk.IconView()
self.iv_results.set_pixbuf_column(COL_PIXBUF)
self.iv_results.set_text_column(COL_TEXT)
self.iv_results.set_item_width(ICON_VIEW_ITEM_WIDTH)
self.sw_results = self.create_scrolled_window()
self.sw_results.add(self.iv_results)
self.sw_results.show_all()
vadj = self.sw_results.get_vadjustment()
vadj.connect("value-changed", self.on_results_scroll_to_bottom)
self.iv_results.connect("expose-event", self.on_results_draw)
self.iv_results.connect("selection-changed",
self.on_result_selection_changed)
self.iv_results.connect("item-activated",
self.on_result_item_activated)
# Error
btn_results_error = gtk.Button("Repeat")
btn_results_error.connect("clicked", self.btn_results_error_clicked)
btn_results_error.show()
self.hb_results_error = gtk.HBox(False, 1)
self.hb_results_error.pack_start(btn_results_error, True, False, 10)
# No api key label
lb_api_key = gtk.Label(
"No youtube api key found. It should be in the file 'key.txt' in the application directory."
)
lb_api_key.set_line_wrap(True)
self.vb_results = gtk.VBox(False, 1)
self.vb_results.pack_start(self.sw_results, True, True, 1)
self.vb_results.pack_start(self.sp_results, True, False, 1)
self.vb_results.pack_start(self.hb_results_error, True, False, 1)
self.vb_results.pack_start(lb_api_key, True, False, 1)
# Title
self.lb_title = gtk.Label("")
self.lb_title.set_size_request(SIDE_WIDTH, -1)
self.lb_title.set_line_wrap(True)
fr_title = gtk.Frame("Title")
fr_title.add(self.lb_title)
fr_title.show_all()
# Resolutions
self.sp_resolutions = gtk.Spinner()
self.sp_resolutions.set_size_request(SPINNER_SIZE, SPINNER_SIZE)
#TODO: group icons in one place
self.channel_error_icon = gtk.image_new_from_file(
os.path.join(sys.path[0], "images", "box-important-24.png"))
self.btn_resolutions_error = gtk.Button()
self.btn_resolutions_error.set_image(self.channel_error_icon)
self.btn_resolutions_error.connect("clicked",
self.btn_resolutions_error_clicked)
self.tv_resolutions = self.create_tree_view()
self.resolutions_store = gtk.ListStore(gtk.gdk.Pixbuf, str, str)
self.tv_resolutions.set_model(self.resolutions_store)
self.tv_resolutions.connect("row-activated",
self.on_resolution_activated)
self.sw_resolutions = self.create_scrolled_window()
self.sw_resolutions.add(self.tv_resolutions)
self.sw_resolutions.show_all()
vb_resolutions = gtk.VBox(False, 1)
vb_resolutions.pack_start(self.sw_resolutions, True, True, 1)
vb_resolutions.pack_start(self.sp_resolutions, True, False, 1)
vb_resolutions.pack_start(self.btn_resolutions_error, True, False, 1)
vb_resolutions.show()
fr_resolutions = gtk.Frame("Resolutions")
fr_resolutions.add(vb_resolutions)
fr_resolutions.show()
# Save/delete buttons
star_icon = gtk.image_new_from_file(
os.path.join(sys.path[0], "images", "star-24.png"))
star_filled_icon = gtk.image_new_from_file(
os.path.join(sys.path[0], "images", "star-filled-24.png"))
self.btn_save = gtk.Button()
self.btn_save.set_image(star_icon)
self.btn_delete = gtk.Button()
self.btn_delete.set_image(star_filled_icon)
self.btn_save.connect("clicked", self.btn_save_clicked)
self.btn_delete.connect("clicked", self.btn_delete_clicked)
# List related to video id
list_icon = gtk.image_new_from_file(
os.path.join(sys.path[0], "images", "menu-24.png"))
self.btn_list_video_id = gtk.Button()
self.btn_list_video_id.set_image(list_icon)
self.btn_list_video_id.set_tooltip_text("List related to video")
self.btn_list_video_id.connect("clicked",
self.btn_list_video_id_clicked)
self.btn_list_video_id.show()
# List channel videos
self.channel_icon = gtk.image_new_from_file(
os.path.join(sys.path[0], "images", "video-playlist-24.png"))
self.btn_list_channel = gtk.Button()
self.btn_list_channel.set_image(self.channel_icon)
self.btn_list_channel.set_tooltip_text("List channel videos")
self.btn_list_channel.connect("clicked", self.btn_channel_clicked)
self.btn_list_channel.show()
self.sp_channel = gtk.Spinner()
self.sp_channel.set_size_request(SPINNER_SIZE, SPINNER_SIZE)
image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PLAY,
gtk.ICON_SIZE_BUTTON)
self.btn_get_links = gtk.Button()
self.btn_get_links.set_image(image)
self.btn_get_links.set_tooltip_text("Get links")
self.btn_get_links.connect("clicked", self.btn_get_links_clicked)
self.btn_get_links.show()
self.hb_actions = gtk.HBox(False, 1)
self.hb_actions.pack_start(self.btn_list_video_id, True, True, 1)
self.hb_actions.pack_start(self.btn_save, True, True, 1)
self.hb_actions.pack_start(self.btn_delete, True, True, 1)
self.hb_actions.pack_start(self.sp_channel, True, False, 1)
self.hb_actions.pack_start(self.btn_list_channel, True, True, 1)
self.hb_actions.pack_start(self.btn_get_links, True, True, 1)
self.vb_results.pack_end(self.hb_actions, False, False, 1)
# Client frame
self.rb_ytdl = gtk.RadioButton(None, "youtube-dl")
self.rb_ytdl.connect('toggled', self.rb_ytdl_toggled)
self.rb_streamlink = gtk.RadioButton(self.rb_ytdl, "streamlink")
vb_client = gtk.VBox(False, 1)
vb_client.pack_start(self.rb_ytdl, False, False, 1)
vb_client.pack_start(self.rb_streamlink, False, False, 1)
self.fr_client = gtk.Frame("Client")
self.fr_client.add(vb_client)
self.fr_client.show_all()
# Player frame
self.player_init_text = ""
self.lb_player = gtk.Label("")
self.lb_player.set_size_request(SIDE_WIDTH, -1)
self.lb_player.set_line_wrap(True)
self.btn_close_player = gtk.Button()
image = gtk.image_new_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_BUTTON)
self.btn_close_player.set_image(image)
self.btn_close_player.set_tooltip_text("Close player")
self.btn_close_player.connect("clicked", self.btn_close_player_clicked)
hb_player = gtk.HBox(False, 1)
hb_player.pack_start(self.lb_player, True, True, 1)
hb_player.pack_end(self.btn_close_player, False, False, 1)
fr_player = gtk.Frame("Player")
fr_player.add(hb_player)
fr_player.show_all()
self.btn_close_player.hide()
self.vb_right = gtk.VBox(False, 1)
self.vb_right.set_size_request(SIDE_WIDTH, -1)
self.vb_right.pack_start(fr_title, False, False, 1)
self.vb_right.pack_start(fr_resolutions, True, True, 1)
self.vb_right.pack_start(self.fr_client, False, False, 1)
self.vb_right.pack_start(fr_player, False, False, 1)
# Categories
self.sp_categories = gtk.Spinner()
self.sp_categories.set_size_request(SPINNER_SIZE, SPINNER_SIZE)
self.btn_categories_error = gtk.Button("Repeat")
self.btn_categories_error.connect("clicked",
self.btn_categories_error_clicked)
tv_categories = self.create_tree_view()
self.categories_store = gtk.ListStore(gtk.gdk.Pixbuf, str, str)
tv_categories.set_model(self.categories_store)
tv_categories.connect("row-activated", self.on_categories_activated)
self.sw_categories = self.create_scrolled_window()
self.sw_categories.add(tv_categories)
self.sw_categories.show_all()
self.vb_categories = gtk.VBox(False, 1)
self.vb_categories.set_size_request(SIDE_WIDTH, -1)
self.vb_categories.pack_start(self.sp_categories, True, False, 1)
self.vb_categories.pack_start(self.sw_categories, True, True, 1)
self.vb_categories.pack_start(self.btn_categories_error, True, False,
1)
hbox = gtk.HBox(False, 1)
hbox.pack_start(self.vb_categories, False, False, 1)
hbox.pack_start(self.vb_results, True, True, 1)
hbox.pack_start(self.vb_right, False, False, 1)
hbox.show()
vbox = gtk.VBox(False, 1)
vbox.pack_start(toolbar, False, False, 1)
vbox.pack_start(hbox, True, True, 1)
toolbar.show_all()
self.vb_results.show()
self.add(vbox)
vbox.show()
self.show()
self.is_task_started = False
loc = locale.getlocale()
self.search_net = SearchNet(API_KEY, self, loc)
self.categories_net = CategoriesNet(API_KEY, self, loc)
self.images_indices = set()
self.images_cache = {}
self.video_id_processor = VideoIdProcessor(self)
# Setup client radiobuttons if clients detected
is_ytdl = self.video_id_processor.youtube_dl != ""
is_streamlink = self.video_id_processor.player.streamlink != ""
if is_ytdl:
self.rb_ytdl.set_active(True)
elif is_streamlink:
self.rb_streamlink.set_active(True)
else:
self.fr_client.hide()
vb_client.set_sensitive(is_ytdl and is_streamlink)
self.results_store = None
self.results_history = ResultsHistory(self)
self.saved_items = SavedItemsDb(self)
self.channel_net = ChannelNet(API_KEY, self)
self.is_empty = True
if API_KEY == "":
lb_api_key.show()
self.sw_results.hide()
btn_categories.set_sensitive(False)
def __init__(self, field_name, model_name, attrs=None):
super(RichTextBox, self).__init__(field_name, model_name, attrs=attrs)
self.table_tag = gtk.TextTagTable()
self.text_buffer = gtk.TextBuffer(self.table_tag)
self.textview.set_buffer(self.text_buffer)
self.textview.connect_after('move-cursor', self.detect_style)
self.textview.connect('button-release-event', self.detect_style)
self.focus_out = True
tags = ('bold', 'italic', 'underline', 'font_family', 'size', 'left',
'center', 'right', 'fill', 'foreground', 'background',
'markup')
# Build all buttons
self.tools = {}
for tag in tags[:3]:
self.tools[tag] = gtk.ToggleToolButton('gtk-%s' % tag)
self.sizes = map(str, range(6, 33))
fonts = self.textview.get_pango_context().list_families()
self.families = sorted([font.get_name() for font in fonts])
for tag, values in zip(tags[3:5], (self.families, self.sizes)):
self.tools[tag] = gtk.ToolItem()
box = gtk.combo_box_new_text()
for value in values:
box.append_text(value)
box.set_focus_on_click(False)
self.tools[tag].add(box)
group = None
for tag in tags[5:9]:
self.tools[tag] = gtk.RadioToolButton(group,
'gtk-justify-%s' % tag)
if not group:
group = self.tools[tag]
for tag in tags[9:11]:
self.tools[tag] = gtk.ToolButton('tryton-text-%s' % tag)
self.tools['markup'] = gtk.ToggleToolButton('tryton-text-markup')
# Set properties to each button
tag_values = (
('bold', 'weight', pango.WEIGHT_BOLD),
('italic', 'style', pango.STYLE_ITALIC),
('underline', 'underline', pango.UNDERLINE_SINGLE),
('left', 'justification', gtk.JUSTIFY_LEFT),
('center', 'justification', gtk.JUSTIFY_CENTER),
('right', 'justification', gtk.JUSTIFY_RIGHT),
('fill', 'justification', gtk.JUSTIFY_FILL),
)
self.text_tags = {}
for tag, name, prop in tag_values:
self.text_tags[tag] = gtk.TextTag(tag)
self.text_tags[tag].set_property(name, prop)
self.table_tag.add(self.text_tags[tag])
self.font_props = {
'font_family': {},
'size': {},
'foreground': {},
'background': {},
}
font_desc = self.textview.get_pango_context().get_font_description()
self.current_font_prop = {
'foreground': gtk.gdk.Color('#000'),
'background': gtk.gdk.Color('#fff'),
'font_family': font_desc.get_family(),
'size': str(font_desc.get_size() / pango.SCALE),
'justify': 'left',
}
self.tools['size'].child.set_active(
self.sizes.index(self.current_font_prop['size']))
font_family = self.current_font_prop['font_family']
if font_family in self.families:
self.tools['font_family'].child.set_active(
self.families.index(font_family))
self.start_tags = {}
self.end_tags = {}
# Connect events
self.tool_ids = {}
for tag in tags[:3]:
self.tool_ids[tag] = self.tools[tag].connect(
'toggled', self.action_style_font, self.text_tags[tag], tag)
for tag in tags[3:5]:
self.tool_ids[tag] = self.tools[tag].child.connect(
'changed', self.action_prop_font, tag)
for tag in tags[5:9]:
self.tool_ids[tag] = self.tools[tag].connect(
'toggled', self.action_justification, tag)
for tag in tags[9:11]:
self.tool_ids[tag] = self.tools[tag].connect(
'clicked', self.action_prop_font, tag)
self.tool_ids['markup'] = self.tools['markup'].connect(
'toggled', self.edit_text_markup)
self.insert_text_id = self.text_buffer.connect_after(
'insert-text', self.persist_style)
# Tooltip text
self.tools['bold'].set_tooltip_text(_('Change text to bold'))
self.tools['italic'].set_tooltip_text(_('Change text to italic'))
self.tools['underline'].set_tooltip_text(_('Change text to underline'))
self.tools['font_family'].set_tooltip_text(_('Choose font-family'))
self.tools['size'].set_tooltip_text(_('Choose font-size'))
self.tools['left'].set_tooltip_text(_('Justify of line to the left'))
self.tools['center'].set_tooltip_text(
_('Justify of line to the center'))
self.tools['right'].set_tooltip_text(_('Justify of line to the right'))
self.tools['fill'].set_tooltip_text(
_('Justify of line to fill window'))
self.tools['foreground'].set_tooltip_text(
_('Change the foreground text'))
self.tools['background'].set_tooltip_text(
_('Change the background text'))
self.tools['markup'].set_tooltip_text(_('Change the markup text view'))
# Packing widgets
self.tool_bar = gtk.Toolbar()
self.tool_bar.set_style(gtk.TOOLBAR_ICONS)
for tag in tags:
self.tool_bar.insert(self.tools[tag], -1)
separator = gtk.SeparatorToolItem
for local in (3, 6, 11, 14):
self.tool_bar.insert(separator(), local)
self.widget.pack_start(self.tool_bar, False)
def __init__(self, view, attrs):
super(RichTextBox, self).__init__(view, attrs)
self.text_buffer = gtk.TextBuffer()
setup_tags(self.text_buffer)
self.text_buffer.register_serialize_format(MIME, serialize, None)
self.text_buffer.register_deserialize_format(MIME, deserialize, None)
self.text_buffer.connect_after('insert-text', self.insert_text_style)
self.textview.set_buffer(self.text_buffer)
self.textview.connect_after('move-cursor', self.detect_style)
self.textview.connect('button-release-event', self.detect_style)
self.toolbar = gtk.Toolbar()
self.toolbar.set_style({
'default': False,
'both': gtk.TOOLBAR_BOTH,
'text': gtk.TOOLBAR_TEXT,
'icons': gtk.TOOLBAR_ICONS
}[CONFIG['client.toolbar']])
self.widget.pack_start(self.toolbar, expand=False, fill=True)
self.tag_widgets = {}
self.tags = {}
for icon in ['bold', 'italic', 'underline']:
button = gtk.ToggleToolButton('gtk-%s' % icon)
button.connect('toggled', self.toggle_props, icon)
self.toolbar.insert(button, -1)
self.tag_widgets[icon] = button
self.toolbar.insert(gtk.SeparatorToolItem(), -1)
for name, options, active in [
('family', FAMILIES, FAMILIES.index('normal')),
('size', SIZES, SIZES.index('4')),
]:
try:
combobox = gtk.ComboBoxText()
except AttributeError:
combobox = gtk.combo_box_new_text()
for option in options:
combobox.append_text(option)
combobox.set_active(active)
combobox.set_focus_on_click(False)
combobox.connect('changed', self.change_props, name)
tool = gtk.ToolItem()
tool.add(combobox)
self.toolbar.insert(tool, -1)
self.tag_widgets[name] = combobox
self.toolbar.insert(gtk.SeparatorToolItem(), -1)
button = None
for icon in ['left', 'center', 'right', 'fill']:
name = icon
if icon == 'fill':
name = 'justify'
button = gtk.RadioToolButton(button, 'gtk-justify-%s' % icon)
button.set_active(icon == 'left')
button.connect('toggled', self.toggle_justification, name)
self.toolbar.insert(button, -1)
self.tag_widgets[name] = button
self.toolbar.insert(gtk.SeparatorToolItem(), -1)
self.colors = {}
for icon, label in [
('foreground', _('Foreground')),
# TODO ('background', _('Background')),
]:
button = gtk.ToolButton('tryton-text-%s' % icon)
button.set_label(label)
button.connect('clicked', self.toggle_color, icon)
self.toolbar.insert(button, -1)
self.tag_widgets[icon] = button
def __init__(self, uicore, buffer):
super(InteractiveButtons, self).__init__(False, 1)
self.buffer = buffer
self.output_type = 'hexadecimal'
# By default shows hexadecimal so no syntax highlight
self.buffer.set_highlight_syntax(False)
self.uicore = uicore
self.toolbox = self
self.int_tb = gtk.Toolbar()
self.int_tb.set_style(gtk.TOOLBAR_ICONS)
# Previous buffer button
self.prev_ti = gtk.ToolItem()
self.prev_align = gtk.Alignment(yalign=0.5)
self.prev_ti.add(self.prev_align)
self.prev = gtk.ToolButton(gtk.STOCK_GO_UP)
self.prev.set_tooltip_text('Previous buffer')
self.prev.connect("clicked", self.move, 'b')
self.prev.label = 'Previous'
self.prev_align.add(self.prev)
self.int_tb.insert(self.prev_ti, 0)
# Next buffer button
self.next_ti = gtk.ToolItem()
self.next_align = gtk.Alignment(yalign=0.5)
self.next_ti.add(self.next_align)
self.next = gtk.ToolButton(gtk.STOCK_GO_DOWN)
self.next.set_tooltip_text('Next buffer')
self.next.connect("clicked", self.move, 'f')
self.next.label = 'Next'
self.next_align.add(self.next)
self.int_tb.insert(self.next_ti, 1)
# Separator
self.sep = gtk.SeparatorToolItem()
self.int_tb.insert(self.sep, 2)
# Seek to...
self.seek_tb = gtk.ToolItem()
self.seek_label = gtk.Label(' Seek: ')
self.seek_tb.add(self.seek_label)
self.int_tb.insert(self.seek_tb, 3)
self.seek_entry_tb = gtk.ToolItem()
self.seek_entry = gtk.Entry(100)
self.seek_entry.set_icon_from_stock(1, gtk.STOCK_GO_FORWARD)
self.seek_entry.set_icon_tooltip_text(1, 'Seek to')
self.seek_entry.connect("activate", self.seek)
self.seek_entry.connect("icon-press", self.seek)
self.seek_entry_tb.add(self.seek_entry)
self.int_tb.insert(self.seek_entry_tb, 4)
# Separator
self.sep = gtk.SeparatorToolItem()
self.int_tb.insert(self.sep, 5)
# Buffer size
self.buffer_tb = gtk.ToolItem()
self.buffer_label = gtk.Label(' Buffer size: ')
self.buffer_tb.add(self.buffer_label)
self.int_tb.insert(self.buffer_tb, 6)
self.buffer_entry_tb = gtk.ToolItem()
self.buffer_entry = gtk.Entry(100)
self.buffer_entry.set_icon_from_stock(1, gtk.STOCK_APPLY)
self.buffer_entry.set_icon_tooltip_text(1, 'Apply')
self.buffer_entry.connect("activate", self.set_buffer_size)
self.buffer_entry.connect("icon-press", self.set_buffer_size)
self.buffer_entry_tb.add(self.buffer_entry)
self.int_tb.insert(self.buffer_entry_tb, 7)
# Separator
self.sep = gtk.SeparatorToolItem()
self.int_tb.insert(self.sep, 8)
# Radio buttons (output format)
self.hex_ti = gtk.ToolItem()
self.hex_align = gtk.Alignment(yalign=0.5)
self.hex_ti.add(self.hex_align)
self.hex_button = gtk.RadioToolButton(None, None)
self.hex_button.set_label("HEX")
self.hex_button.connect("toggled", self.callback, "Hexadecimal")
self.hex_button.set_active(True)
self.hex_align.add(self.hex_button)
self.int_tb.insert(self.hex_ti, 9)
self.dasm_ti = gtk.ToolItem()
self.dasm_align = gtk.Alignment(yalign=0.5)
self.dasm_ti.add(self.dasm_align)
self.dasm_button = gtk.RadioToolButton(self.hex_button, None)
self.dasm_button.set_label("ASM")
self.dasm_button.connect("toggled", self.callback, "Disassembly")
self.dasm_align.add(self.dasm_button)
self.int_tb.insert(self.dasm_ti, 10)
if 'radare' in self.uicore.backend:
# Separator
self.sep = gtk.SeparatorToolItem()
self.int_tb.insert(self.sep, 11)
self.exec_entry_tb = gtk.ToolItem()
self.exec_entry = gtk.Entry(100)
self.exec_entry.set_icon_from_stock(1, gtk.STOCK_EXECUTE)
self.exec_entry.set_icon_tooltip_text(1, 'Execute')
self.exec_entry.connect("activate", self.r2_exec)
self.exec_entry.connect("icon-press", self.r2_exec)
self.exec_entry_tb.add(self.exec_entry)
self.int_tb.insert(self.exec_entry_tb, 12)
self.pack_start(self.int_tb, True, True)
self.uicore.core.bsize = 512
def _controls(self):
icon_arrow = gtk.image_new_from_file(
os.path.join(paths.ICONS_DIR, "arrow.svg"))
icon_transition = gtk.image_new_from_file(
os.path.join(paths.ICONS_DIR, "transition.svg"))
icon_place = gtk.image_new_from_file(
os.path.join(paths.ICONS_DIR, "place.svg"))
icon_arc = gtk.image_new_from_file(
os.path.join(paths.ICONS_DIR, "arc.svg"))
icon_area = gtk.image_new_from_file(
os.path.join(paths.ICONS_DIR, "area.svg"))
icon_trace = gtk.image_new_from_file(
os.path.join(paths.ICONS_DIR, "trace.svg"))
icon_simrun = gtk.image_new_from_file(
os.path.join(paths.ICONS_DIR, "simrun.svg"))
icon_verif = gtk.image_new_from_file(
os.path.join(paths.ICONS_DIR, "verif.svg"))
toolbar = gtk.Toolbar()
button1 = gtk.RadioToolButton(None)
button1.connect("toggled", lambda w: self.set_mode("edit"))
button1.set_stock_id(gtk.STOCK_EDIT)
toolbar.add(button1)
button2 = gtk.RadioToolButton(button1, None)
button2.connect("toggled", lambda w: self.set_mode("tracing"))
button2.set_icon_widget(icon_trace)
toolbar.add(button2)
button2 = gtk.RadioToolButton(button1, None)
button2.connect("toggled", lambda w: self.set_mode("simrun"))
button2.set_icon_widget(icon_simrun)
toolbar.add(button2)
button2 = gtk.RadioToolButton(button1, None)
button2.connect("toggled", lambda w: self.set_mode("verif"))
button2.set_icon_widget(icon_verif)
toolbar.add(button2)
toolbar.add(gtk.SeparatorToolItem())
self.button_undo = gtk.ToolButton()
self.button_undo.connect("clicked", lambda w: self.undo())
self.button_undo.set_stock_id(gtk.STOCK_UNDO)
self.button_redo = gtk.ToolButton()
self.button_redo.connect("clicked", lambda w: self.redo())
self.button_redo.set_stock_id(gtk.STOCK_REDO)
toolbar.add(self.button_undo)
toolbar.add(self.button_redo)
toolbar.add(gtk.SeparatorToolItem())
button1 = gtk.RadioToolButton(None,None)
button1.connect("toggled", lambda w: self.set_tool("selection"))
button1.set_icon_widget(icon_arrow)
self.button_selection = button1
button2 = gtk.RadioToolButton(button1,None)
button2.connect("toggled", lambda w: self.set_tool("transition"))
button2.set_icon_widget(icon_transition)
button3 = gtk.RadioToolButton(button1,None)
button3.connect("toggled", lambda w: self.set_tool("place"))
button3.set_icon_widget(icon_place)
button4 = gtk.RadioToolButton(button1,None)
button4.connect("toggled", lambda w: self.set_tool("edge"))
button4.set_icon_widget(icon_arc)
button5 = gtk.RadioToolButton(button1,None)
button5.connect("toggled", lambda w: self.set_tool("area"))
button5.set_icon_widget(icon_area)
toolbar.add(button1)
toolbar.add(button2)
toolbar.add(button3)
toolbar.add(button4)
toolbar.add(button5)
toolbar.add(gtk.SeparatorToolItem())
button1 = gtk.ToolButton()
button1.connect("clicked", lambda w: self.canvas.zoom_in())
button1.set_stock_id(gtk.STOCK_ZOOM_IN)
button2 = gtk.ToolButton()
button2.connect("clicked", lambda w: self.canvas.zoom_out())
button2.set_stock_id(gtk.STOCK_ZOOM_OUT)
toolbar.add(button1)
toolbar.add(button2)
vbox = gtk.VBox()
vbox.pack_start(toolbar)
vbox.show_all()
return vbox
def _controls(self):
def add_radio_shortcut(accel_group, widget, key, ctrl=False):
mask = 0
if ctrl:
mask |= gtk.gdk.CONTROL_MASK
accel_group.connect_group(
gtk.gdk.keyval_from_name(key), mask, gtk.ACCEL_VISIBLE,
lambda a, b, c, d: activate_radio(widget))
def activate_radio(widget):
widget.set_active(True)
icon_arrow = gtk.image_new_from_file(
os.path.join(paths.ICONS_DIR, "arrow.svg"))
icon_transition = gtk.image_new_from_file(
os.path.join(paths.ICONS_DIR, "transition.svg"))
icon_place = gtk.image_new_from_file(
os.path.join(paths.ICONS_DIR, "place.svg"))
icon_arc = gtk.image_new_from_file(
os.path.join(paths.ICONS_DIR, "arc.svg"))
icon_area = gtk.image_new_from_file(
os.path.join(paths.ICONS_DIR, "area.svg"))
icon_trace = gtk.image_new_from_file(
os.path.join(paths.ICONS_DIR, "trace.svg"))
icon_simrun = gtk.image_new_from_file(
os.path.join(paths.ICONS_DIR, "simrun.svg"))
icon_verif = gtk.image_new_from_file(
os.path.join(paths.ICONS_DIR, "verif.svg"))
toolbar = gtk.Toolbar()
button1 = gtk.RadioToolButton(None)
button1.connect("toggled", lambda w: self.set_mode("edit"))
button1.set_stock_id(gtk.STOCK_EDIT)
button1.set_tooltip_text("Edit")
toolbar.add(button1)
button2 = gtk.RadioToolButton(button1, None)
button2.connect("toggled", lambda w: self.set_mode("tracing"))
button2.set_tooltip_text("Tracing")
button2.set_icon_widget(icon_trace)
toolbar.add(button2)
button2 = gtk.RadioToolButton(button1, None)
button2.connect("toggled", lambda w: self.set_mode("simrun"))
button2.set_tooltip_text("Simulation")
button2.set_icon_widget(icon_simrun)
toolbar.add(button2)
button2 = gtk.RadioToolButton(button1, None)
button2.connect("toggled", lambda w: self.set_mode("verif"))
button2.set_tooltip_text("Verification")
button2.set_icon_widget(icon_verif)
toolbar.add(button2)
toolbar.add(gtk.SeparatorToolItem())
self.button_undo = gtk.ToolButton()
self.button_undo.connect("clicked", lambda w: self.undo())
self.button_undo.set_tooltip_text("Undo")
self.button_undo.set_stock_id(gtk.STOCK_UNDO)
self.button_redo = gtk.ToolButton()
self.button_redo.connect("clicked", lambda w: self.redo())
self.button_redo.set_tooltip_text("Redo")
self.button_redo.set_stock_id(gtk.STOCK_REDO)
toolbar.add(self.button_undo)
toolbar.add(self.button_redo)
toolbar.add(gtk.SeparatorToolItem())
ag = gtk.AccelGroup()
self.app.window.add_accel_group(ag)
button1 = gtk.RadioToolButton(None, None)
button1.connect("toggled", lambda w: self.set_tool("selection"))
button1.set_tooltip_text("Selection (Ctrl+S)")
button1.set_icon_widget(icon_arrow)
self.button_selection = button1
add_radio_shortcut(ag, button1, "s", ctrl=True)
button2 = gtk.RadioToolButton(button1, None)
button2.connect("toggled", lambda w: self.set_tool("transition"))
button2.set_tooltip_text("Transition (Ctrl+R)")
button2.set_icon_widget(icon_transition)
add_radio_shortcut(ag, button2, "r", ctrl=True)
button3 = gtk.RadioToolButton(button1, None)
button3.connect("toggled", lambda w: self.set_tool("place"))
button3.set_tooltip_text("Place (Ctrl+E)")
button3.set_icon_widget(icon_place)
add_radio_shortcut(ag, button3, "e", ctrl=True)
button4 = gtk.RadioToolButton(button1, None)
button4.connect("toggled", lambda w: self.set_tool("edge"))
button4.set_tooltip_text("Edge (Ctrl+A)")
button4.set_icon_widget(icon_arc)
add_radio_shortcut(ag, button4, "a", ctrl=True)
button5 = gtk.RadioToolButton(button1, None)
button5.connect("toggled", lambda w: self.set_tool("area"))
button5.set_tooltip_text("Area (Ctrl+B)")
button5.set_icon_widget(icon_area)
add_radio_shortcut(ag, button5, "b", ctrl=True)
toolbar.add(button1)
toolbar.add(button2)
toolbar.add(button3)
toolbar.add(button4)
toolbar.add(button5)
toolbar.add(gtk.SeparatorToolItem())
button1 = gtk.ToolButton()
button1.connect("clicked", lambda w: self.canvas.zoom_in())
button1.set_tooltip_text("Zoom in")
button1.set_stock_id(gtk.STOCK_ZOOM_IN)
button2 = gtk.ToolButton()
button2.connect("clicked", lambda w: self.canvas.zoom_out())
button2.set_tooltip_text("Zoom out")
button2.set_stock_id(gtk.STOCK_ZOOM_OUT)
toolbar.add(button1)
toolbar.add(button2)
vbox = gtk.VBox()
vbox.pack_start(toolbar)
vbox.show_all()
return vbox
def __init__(self,num,icon,tooltip,size):
self.num=num
self.icon=icon
self.tooltip=tooltip
self.Item=gtk.RadioToolButton()
self.Item.set_size_request(size,size)
