def _build_dialog(self):
if not self._type or not self._buttons:
return
self._dialog = gtk.MessageDialog(type=_mappings[self._type],
buttons=_mappings[self._buttons])
self._dialog.set_position(gtk.WIN_POS_CENTER)
self._dialog.set_skip_taskbar_hint(False)
self._dialog.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_NORMAL)
if self._type == MESSAGE_LOADING:
spinner = gtk.Spinner()
spinner.set_size_request(45, 45)
spinner.start()
self._dialog.set_image(spinner)
if self._title:
self.set_title(self._title)
if self._icon:
self.set_icon(self._icon)
if self._message:
self.set_message(self._message)
if self._message_secondary:
self.set_message_secondary(self._message_secondary)
if self._image_path:
self.set_image(self._image_path)
def _fill_top_hbox(self, hbox):
""" Fill header with service's icon, name, and a spinner
for inidcation of work.
@param hbox: the gtk.HBox to fill
"""
self.image_icon = gtk.Image()
self.image_icon.set_size_request(48, 48)
self.human_name_label = gtk.Label()
self.human_name_label.set_alignment(xalign=0, yalign=0.5)
try:
self.spinner = gtk.Spinner()
except AttributeError:
# worarkound for archlinux: bug #624204
self.spinner = gtk.HBox()
self.spinner.connect("show", self.on_spinner_show)
self.spinner.set_size_request(32, 32)
align_spin = gtk.Alignment(xalign=1, yalign=0)
align_spin.add(self.spinner)
hbox.set_spacing(10)
hbox.pack_start(self.image_icon, False)
hbox.pack_start(self.human_name_label, True)
hbox.pack_start(align_spin, False)
def setup_ui(self, cancelable=True, stoppable=False):
gtk.Table.__init__(self, 3, 3)
self.set_row_spacings(10)
self.set_col_spacings(10)
self.descrlbl = gtk.Label("Status:")
self.descrlbl.show()
self.attach(self.descrlbl, 0, 3, 0, 1, xoptions=gtk.FILL, yoptions=0)
self.spinner = gtk.Spinner()
self.spinner.show()
self.attach(self.spinner, 0, 1, 1, 3, xoptions=0, yoptions=0)
self.label = gtk.Label()
self.label.show()
self.attach(self.label, 1, 2, 1, 3, xoptions=gtk.FILL, yoptions=0)
self.cancel_button = gtk.Button(stock=gtk.STOCK_CANCEL)
self.cancel_button.set_sensitive(False)
self.cancel_button.connect("clicked", self.__cancel_clicked)
if cancelable:
self.attach(self.cancel_button, 2, 3, 1, 2, xoptions=0, yoptions=0)
self.stop_button = gtk.Button(stock=gtk.STOCK_STOP)
self.stop_button.set_sensitive(False)
self.stop_button.connect("clicked", self.__stop_clicked)
if stoppable:
self.attach(self.stop_button, 2, 3, 2, 3, xoptions=0, yoptions=0)
self.set_no_show_all(False)
self.set_visible(True)
self.show_all()
def start(self, splash=False):
if splash:
self.splash_window = gtk.Window()
self.splash_window.set_default_size(200,200)
self.splash_window.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.splash_window.set_decorated(False)
self.splash_window.set_skip_taskbar_hint(True)
self.splash_window.set_skip_pager_hint(True)
self.splash_window.set_urgency_hint(True)
self.splash_window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_SPLASHSCREEN)
vbox = gtk.VBox(spacing=5)
label = gtk.Label('<b>Loading pkgcreator-gtk...</b>')
label.set_use_markup(True)
self.splash_label = gtk.Label('Building GUI...')
spinner = gtk.Spinner()
spinner.start()
vbox.pack_start(label, False)
vbox.pack_start(self.splash_label, False)
vbox.pack_start(spinner, True)
self.splash_window.add(vbox)
self.splash_window.show_all()
while gtk.events_pending():
gtk.main_iteration()
gobject.idle_add(self.__init_gradually)
else:
#Make all GUI preparation at once
self.__init_builder()
self.__init_tabs_handlers()
self.__init_widgets()
self.__init_vte()
self.__config()
self.__show()
gtk.main()
def __init__(self):
gtk.Window.__init__(self)
res = parseSAX('widgets.xml')
if res.layout == 'Table':
table = gtk.Table(int(res.rows), int(res.cols), True)
self.add(table)
for obj in res.widgets:
widget = None
if obj.name == 'Label':
widget = gtk.Label(obj.text)
elif obj.name == 'Button':
widget = gtk.Button(obj.label)
elif obj.name == 'Entry':
widget = gtk.Entry()
widget.set_text(obj.text)
elif obj.name == 'ProgressBar':
widget = gtk.ProgressBar()
widget.set_text(obj.text)
widget.set_fraction(float(obj.fraction))
elif obj.name == 'Spinner':
widget = gtk.Spinner()
if bool(obj.spinning):
widget.start()
if widget:
table.attach(widget, int(obj.colStart), int(obj.colFinish),
int(obj.rowStart), int(obj.rowFinish))
self.connect("delete-event", gtk.main_quit)
self.show_all()
def __init__(self, parent=None, filename="Filename.jpg"):
gtk.Dialog.__init__(self, "Upload2Commons", parent, 0,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OK, gtk.RESPONSE_OK))
if not filename:
filename = "Filename.jpg"
table = gtk.Table(2, 2, True)
self.set_default_size(150, 100)
box = self.get_content_area()
box.set_homogeneous(False)
box.set_spacing(False)
box.add(table)
self.usr_label = gtk.Label("User-Name:\t")
self.usr_entry = gtk.Entry()
table.attach(self.usr_label, 0, 1, 0, 1)
table.attach(self.usr_entry, 1, 2, 0, 1)
self.pw_label = gtk.Label("Password:\t")
self.pw_entry = gtk.Entry()
self.pw_entry.set_visibility(False)
table.attach(self.pw_label, 0, 1, 1, 2)
table.attach(self.pw_entry, 1, 2, 1, 2)
self.filename_entry = gtk.Entry()
self.filename_entry.set_text(filename)
box.add(self.filename_entry)
self.textview = gtk.TextView()
self.textbuffer = self.textview.get_buffer()
self.textview.set_wrap_mode(gtk.WRAP_WORD_CHAR)
self.textbuffer.set_text(DEFAULT_WIKITEXT)
box.add(self.textview)
self.license = gtk.combo_box_new_text()
self.license.append_text(
"{{self|GFDL|cc-by-sa-all|migration=redundant}}")
self.license.append_text("{{self|cc-by-sa-3.0}}")
self.license.append_text("{{self|Cc-zero}}")
self.license.append_text("{{cc-by-sa-3.0}}")
self.license.append_text("{{PD-old-100}}")
self.license.append_text("{{PD-old-70}}")
self.license.append_text("{{PD-Art}}")
box.add(self.license)
self.cat_box = gtk.HBox()
self.cat_label = gtk.Label("Categories:\t")
self.category_entry = gtk.Entry()
self.cat_box.add(self.cat_label)
self.cat_box.add(self.category_entry)
box.add(self.cat_box)
self.feedbackbox = gtk.HBox()
box.add(self.feedbackbox)
self.spinner = gtk.Spinner()
self.show_all()
def __init__(self):
Window.__init__(self)
vbox = gtk.VBox()
self.spinner = gtk.Spinner()
self.status = gtk.Label("Working...")
vbox.pack_start(self.spinner, True, True, 0)
vbox.pack_start(self.status, False, False, 0)
self.margin.add(vbox)
def __init__(self, emma):
super(MainWindow, self).__init__()
self.emma = emma
self.accel_group = gtk.AccelGroup()
self.add_accel_group(self.accel_group)
self.main_notebook = MainNotebook(emma)
self.main_notebook.show()
self.message_notebook = gtk.Notebook()
self.message_notebook.show()
emma.events.on('toggle_message_notebook_visible',
self.on_toggle_message_notebook_visible)
convbox = gtk.VBox(True, 0)
self.connections_tv_container = gtk.ScrolledWindow()
self.connections_tv_container.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.connections_tv_container.show()
self.connections_tv_spinner = gtk.Spinner()
convbox.pack_start(self.connections_tv_spinner, True, True)
convbox.pack_end(self.connections_tv_container, True, True)
convbox.show()
vpaned1 = gtk.VPaned()
vbox1 = gtk.VBox()
vbox1.show()
vbox1.pack_start(MainMenu(emma, self), False, False)
hpaned1 = gtk.HPaned()
hpaned1.pack1(convbox, False, True)
hpaned1.pack2(self.main_notebook, True, True)
hpaned1.set_position(200)
hpaned1.show()
vpaned1.pack1(hpaned1, False, True)
vpaned1.pack2(self.message_notebook, False, True)
vpaned1.set_position(600)
vpaned1.show()
vbox1.pack_start(vpaned1, True, True)
self.status_bar = gtk.Statusbar()
vbox1.pack_end(self.status_bar, False, False)
vbox1.show()
self.add(vbox1)
self.set_position(gtk.WIN_POS_CENTER)
self.resize(1024, 768)
self.show_all()
self.connections_tv_spinner.hide()
def __init__(self, window):
Dialog.__init__(
self,
window,
_('Search'), # T: Dialog title
buttons=gtk.BUTTONS_CLOSE,
help='Help:Searching',
defaultwindowsize=(400, 300))
self.app_window = window
hbox = gtk.HBox(spacing=5)
self.vbox.pack_start(hbox, False)
hbox.pack_start(gtk.Label(_('Search') + ': '), False) # T: input label
self.query_entry = InputEntry()
hbox.add(self.query_entry)
self.search_button = gtk.Button(stock=gtk.STOCK_FIND)
hbox.pack_start(self.search_button, False)
if gtk.gtk_version >= (2, 20) \
and gtk.pygtk_version >= (2, 22): # update in pygtk was later
self.spinner = gtk.Spinner()
hbox.pack_start(self.spinner, False)
else:
self.spinner = None
self.cancel_button = gtk.Button(stock=gtk.STOCK_STOP)
hbox.pack_start(self.cancel_button, False)
self._set_state(self.READY)
help_text = _('For advanced search you can use operators like\n'
'AND, OR and NOT. See the help page for more details.'
) # T: help text for the search dialog
if gtk.gtk_version >= (2, 12) \
and gtk.pygtk_version >= (2, 12):
self.query_entry.set_tooltip_text(help_text)
else:
tooltips = gtk.Tooltips()
tooltips.set_tip(self.query_entry, help_text)
self.namespacecheckbox = gtk.CheckButton(
_('Limit search to the current page and sub-pages'))
# T: checkbox option in search dialog
self.vbox.pack_start(self.namespacecheckbox, False)
# TODO advanced query editor
# TODO checkbox _('Match c_ase')
# TODO checkbox _('Whole _word')
self.results_treeview = SearchResultsTreeView(self.app_window)
self.vbox.add(ScrolledWindow(self.results_treeview))
self.search_button.connect_object('clicked', self.__class__._search,
self)
self.cancel_button.connect_object('clicked', self.__class__._cancel,
self)
self.query_entry.connect_object('activate', self.__class__._search,
self)
def setupSpinner():
if gtk.pygtk_version >= (2, 22, 00):
global spinner
stbox = gui.get_object("statusbox")
spinner = gtk.Spinner()
stbox.pack_start(spinner, False, True)
stbox.reorder_child(spinner, 0)
context = sb.get_context_id("main")
spinner.set_no_show_all(True)
def _update_ui(self):
running_action = self._manager.running_action
self._refresh_btn.set_sensitive(running_action is None)
for name, resource in self._manager.resources.iteritems():
img, lbl, buttonbox = self._widgets[name]
status_stock, _ignored = _status_mapper[resource.status]
img.set_from_stock(status_stock, gtk.ICON_SIZE_LARGE_TOOLBAR)
if resource.reason and resource.reason_long:
text = "<b>%s</b>: %s\n<i>%s</i>" % (
api.escape(resource.label),
api.escape(resource.reason),
api.escape(resource.reason_long))
elif resource.reason:
text = "<b>%s</b>: %s" % (
api.escape(resource.label),
api.escape(resource.reason))
else:
text = _("Status not available...")
for child in buttonbox.get_children():
buttonbox.remove(child)
for action in resource.get_actions():
btn = gtk.Button(action.label)
if running_action is not None:
btn.set_sensitive(False)
if action.admin_only and not self._is_admin:
btn.set_sensitive(False)
btn.set_tooltip_text(
_("Only admins can execute this action"))
# If the action is the running action, add a spinner together
# with the label to indicate that it is running
if action == running_action:
spinner = gtk.Spinner()
hbox = gtk.HBox(spacing=6)
child = btn.get_child()
btn.remove(child)
hbox.add(child)
hbox.add(spinner)
btn.add(hbox)
spinner.start()
hbox.show_all()
btn.show()
btn.connect('clicked', self._on_action_btn__clicked, action)
buttonbox.add(btn)
lbl.set_markup(text)
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_title(self.__class__.__name__)
self.set_border_width(5)
vb = gtk.VBox(spacing=5)
self.add(vb)
#sensitive
hb = gtk.HBox(spacing=5)
self.ss = gtk.Spinner()
hb.add(self.ss)
hb.add(gtk.Entry())
vb.add(hb)
#unsensitive
hb = gtk.HBox(spacing=5)
self.us = gtk.Spinner()
hb.add(self.us)
hb.add(gtk.Entry())
hb.set_sensitive(False)
vb.add(hb)
b = gtk.Button(stock=gtk.STOCK_MEDIA_PLAY)
b.connect("clicked", self._on_play_clicked)
vb.add(b)
b = gtk.Button(stock=gtk.STOCK_MEDIA_STOP)
b.connect("clicked", self._on_stop_clicked)
vb.add(b)
self._on_play_clicked(None)
self.show_all()
def __init__(self):
super(SearchingDialog, self).__init__(
title="",
parent=component.get("MainWindow").window,
flags=(gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT
| gtk.DIALOG_NO_SEPARATOR))
self.set_decorated(False)
hbox = gtk.HBox()
hbox.set_spacing(6)
spinner = gtk.Spinner()
spinner.start()
label = gtk.Label('Searching...')
hbox.pack_start(spinner)
hbox.pack_start(label)
self.get_content_area().pack_start(hbox)
def __init__(self):
super(Spinner, self).__init__()
self.set_size_request(100, 100)
self.set_position(gtk.WIN_POS_CENTER)
icon = gtk.gdk.pixbuf_new_from_file(OUTPUT_ICON_PATH).scale_simple(
48, 48, gtk.gdk.INTERP_HYPER)
self.set_icon(icon)
self.set_decorated(False)
self.set_app_paintable(True)
self.set_colormap(self.get_screen().get_rgba_colormap())
self.connect('expose-event', self.__expose)
self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#ffffff'))
self.set_opacity(0.5)
spinner = gtk.Spinner()
spinner.set_tooltip_text("searching ...")
spinner.start()
self.add(spinner)
self.show_all()
def __init__(self):
super(Window, self).__init__()
self.set_title('MComix')
self.set_border_width(10)
self.set_wmclass('MComix', 'MComix')
self.set_resizable(False)
self.set_deletable(False)
self._displayed = False
vbox = gtk.VBox(spacing=5)
label = gtk.Label(
_('Updating font cache. This may take a few minutes.'))
vbox.pack_start(label)
self._spinner = gtk.Spinner()
vbox.pack_start(self._spinner, expand=False, fill=False)
vbox.show_all()
self.add(vbox)
self.set_geometry_hints(vbox)
gobject.timeout_add(200, self._on_ping)
def __init__(self):
window = gtk.Window()
window.set_default_size(200, 200)
vbox = gtk.VBox(False, 5)
hbox = gtk.HBox(True, 5)
self.spinner = gtk.Spinner()
button_start = gtk.Button("Start")
button_stop = gtk.Button("Stop")
window.connect("destroy", lambda w: gtk.main_quit())
button_start.connect("clicked", self.start_animation)
button_stop.connect("clicked", self.stop_animation)
window.add(vbox)
vbox.pack_start(self.spinner, True, True, 0)
vbox.pack_end(hbox, False, False, 0)
hbox.pack_start(button_start)
hbox.pack_start(button_stop)
window.show_all()
def __init__(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
#self.window.set_position(gtk.WIN_POS_MOUSE)
self.window.set_border_width(10)
self.window.set_position(gtk.WIN_POS_CENTER)
self.window.set_size_request(800, 600)
self.window.set_title("Information Retrieval System")
self.window.set_tooltip_text("This Project has done By:\n Dan Moony & Nazar Al-Wattar\n Supervised By: Professor Yacci Paul")
button = gtk.RadioButton()
self.radioButton1 = gtk.RadioButton(button)
self.radioButton1.connect("toggled", self.callback,'b1')
self.radioButton1.set_active(True)
self.label1 = gtk.Label("Enter Your Text ")
self.label2 = gtk.Label("Search Result are: ")
self.textbox1 = gtk.Entry()
self.textbox1.connect("changed", self.textEntered)
self.radioButton2 = gtk.RadioButton(button)
self.radioButton2.connect("toggled", self.callback,'b2')
self.voicerecordingbutton = gtk.Button("Record Your Voice")
self.voicerecordingbutton.connect("pressed", self.press)
self.voicerecordingbutton.connect("released", self.release)
self.voicerecordingbutton.set_tooltip_text("This Button Will Record Your Voice")
self.textbox1.set_tooltip_text("Enter Your Text Here")
self.spinner = gtk.Spinner()
self.spinner.size(100,100)
self.searchbutton = gtk.Button("Search")
self.searchbutton.connect("clicked", self.mysearchbutton)
self.searchbutton.set_tooltip_text("This Button Will Start Search and return the result to the combobox")
#self.combo = gtk.combo_box_entry_new_text()
#self.combo.connect("changed", self.combo_text)
#self.combo.append_text("This is my first result")
#self.combo.append_text("This is my second result")
self.combo = gtk.TextView()
self.combo.set_size_request(width=250, height=150)
self.combo.set_editable(False)
buffer = gtk.TextBuffer()
buffer.set_text("Test Results here!")
self.combo.set_buffer(buffer)
fixed = gtk.Fixed()
fixed.put(self.radioButton1, 100, 50)
fixed.put(self.label1, 150, 50)
fixed.put(self.label2, 150, 350)
fixed.put(self.textbox1, 550, 50)
fixed.put(self.radioButton2, 100, 150)
fixed.put(self.voicerecordingbutton, 150, 150)
fixed.put(self.spinner, 500, 100)
fixed.put(self.searchbutton, 570, 270)
fixed.put(self.combo, 525, 350)
self.window.add(fixed)
self.window.show_all()
self.hidevoicerecordingbutton(False)
self.hidesearchbutton(True)
self.hidecombobox(True)
def __init__(self, unsaved_clients, delegate):
"""
Displays a window allowing the user to choose which tabs are saved, or if all of them are.
- unsaved_clients must have at least one item within it to ask the user.
- delegate must be not null, it must also respond to the following:
- unsaved_changes_handler_cb(resolution)
"""
assert None != unsaved_clients
assert len(unsaved_clients) > 0
assert None != delegate
super(UnsavedChangesHandler, self).__init__()
self.builder = gtk.Builder()
self.builder.add_from_file(Host.GLADE_PREFIX +
"UnsavedChangesHandler.glade")
self.window = self.builder.get_object("window")
self.button_save_all = self.builder.get_object("buttonSaveAll")
self.button_cancel = self.builder.get_object("buttonCancel")
self.button_dont_save = self.builder.get_object("buttonDontSave")
self.vbox = self.builder.get_object("vbox")
assert None != self.builder
assert None != self.window
assert None != self.button_save_all
assert None != self.button_cancel
assert None != self.button_dont_save
assert None != self.vbox
self.__unsaved_clients = unsaved_clients
self.delegate = delegate
self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
self.window.set_deletable(False)
self.window.set_title("Save Changes?")
for client in self.__unsaved_clients:
# We need to make a manual save row for the client.
client.__unsaved_hbox = gtk.HBox(spacing=10)
assert None != client.__unsaved_hbox
client.__unsaved_spinner = gtk.Spinner()
client.__unsaved_spinner.start()
client.__unsaved_spinner.set_size_request(22, 22)
assert None != client.__unsaved_spinner
client.__unsaved_image_save = gtk.image_new_from_stock(
gtk.STOCK_FLOPPY, gtk.ICON_SIZE_BUTTON)
client.__unsaved_image_save.set_size_request(22, 22)
assert None != client.__unsaved_image_save
client.__unsaved_image_saved = gtk.image_new_from_stock(
gtk.STOCK_APPLY, gtk.ICON_SIZE_BUTTON)
client.__unsaved_image_saved.set_size_request(22, 22)
assert None != client.__unsaved_image_saved
client.__unsaved_image_no_save = gtk.image_new_from_stock(
gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_BUTTON)
client.__unsaved_image_no_save.set_size_request(22, 22)
assert None != client.__unsaved_image_no_save
client.__unsaved_label = gtk.Label("NO LABEL SET")
client.__unsaved_label.set_justify(gtk.JUSTIFY_LEFT)
client.__unsaved_label.set_alignment(0, 0.5)
client.__unsaved_label.set_ellipsize(pango.ELLIPSIZE_END)
client.__unsaved_label.set_line_wrap(False)
client.__unsaved_label.set_selectable(True)
assert None != client.__unsaved_label
client.__unsaved_button_dontsave = gtk.Button("Don't Save")
client.__unsaved_button_dontsave.connect(
"clicked", self.__cb_dont_save_specific_client, client)
client.__unsaved_button_dontsave.set_size_request(100, -1)
assert None != client.__unsaved_button_dontsave
client.__unsaved_button_save = gtk.Button("Save")
client.__unsaved_button_save.connect(
"clicked", self.__cb_save_specific_client, client)
client.__unsaved_button_save.set_size_request(100, -1)
assert None != client.__unsaved_button_save
client.__unsaved_button_save_as = gtk.Button("Save As...")
#client.__unsaved_button_save_as.connect("clicked",self.__cb_saveas_specific_client,client)
client.__unsaved_button_save_as.set_size_request(100, -1)
assert None != client.__unsaved_button_save_as
client.__unsaved_button_cant_save = gtk.Button("Not Savable")
client.__unsaved_button_cant_save.set_size_request(210, -1)
client.__unsaved_button_cant_save.set_sensitive(False)
assert None != client.__unsaved_button_cant_save
client.__unsaved_hbox.pack_start(client.__unsaved_spinner,
expand=False)
client.__unsaved_hbox.pack_start(client.__unsaved_image_save,
expand=False)
client.__unsaved_hbox.pack_start(client.__unsaved_image_saved,
expand=False)
client.__unsaved_hbox.pack_start(client.__unsaved_image_no_save,
expand=False)
client.__unsaved_hbox.pack_start(client.__unsaved_label)
client.__unsaved_hbox.pack_start(client.__unsaved_button_dontsave,
expand=False)
client.__unsaved_hbox.pack_start(client.__unsaved_button_save,
expand=False)
client.__unsaved_hbox.pack_start(client.__unsaved_button_save_as,
expand=False)
client.__unsaved_hbox.pack_start(client.__unsaved_button_cant_save,
expand=False)
self.vbox.pack_start(client.__unsaved_hbox, expand=False)
description = client.GetDescription()
assert None != description
description = description.replace("&", "&")
assert None != description
client.__unsaved_label.set_markup(description)
client.__unsaved_hbox.show()
client.__unsaved_label.show()
self.__update_client_status_visibility(client)
self.button_save_all.connect("clicked", self.__cb_save_all)
self.button_cancel.connect("clicked", self.__cb_cancel)
self.button_dont_save.connect("clicked", self.__cb_dont_save_all)
def __init__(self, parent, track, search=None):
"""
Expects the parent control, a track, an an optional search string
"""
gobject.GObject.__init__(self)
self.parent = parent
self.builder = gtk.Builder()
self.builder.add_from_file(xdg.get_data_path('ui/coverchooser.ui'))
self.builder.connect_signals(self)
self.window = self.builder.get_object('CoverChooser')
self.window.set_title(_("Cover options for %(artist)s - %(album)s") % {
'artist': track.get_tag_display('artist'),
'album': track.get_tag_display('album')
})
self.window.set_transient_for(parent)
self.message = dialogs.MessageBar(
parent=self.builder.get_object('main_container'),
buttons=gtk.BUTTONS_CLOSE
)
self.message.connect('response', self.on_message_response)
self.track = track
self.covers = []
self.current = 0
self.cover = guiutil.ScalableImageWidget()
self.cover.set_image_size(350, 350)
self.cover_image_box = self.builder.get_object('cover_image_box')
self.loading_indicator = gtk.Alignment()
self.loading_indicator.props.xalign = 0.5
self.loading_indicator.props.yalign = 0.5
self.loading_indicator.set_size_request(350, 350)
self.cover_image_box.pack_start(self.loading_indicator)
try:
spinner = gtk.Spinner()
spinner.set_size_request(100, 100)
spinner.start()
self.loading_indicator.add(spinner)
except AttributeError: # Older than GTK 2.20 and PyGTK 2.22
self.loading_indicator.add(gtk.Label(_('Loading...')))
self.size_label = self.builder.get_object('size_label')
self.source_label = self.builder.get_object('source_label')
self.covers_model = self.builder.get_object('covers_model')
self.previews_box = self.builder.get_object('previews_box')
self.previews_box.set_no_show_all(True)
self.previews_box.hide()
self.previews_box.set_model(None)
self.set_button = self.builder.get_object('set_button')
self.set_button.set_sensitive(False)
self.window.show_all()
self.stopper = threading.Event()
self.fetcher_thread = threading.Thread(target=self.fetch_cover, name='Coverfetcher')
self.fetcher_thread.start()
def __init__(self, parent, window):
GioExtension.__init__(self, parent, window)
# create user interface
list_container = gtk.ScrolledWindow()
list_container.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
list_container.set_shadow_type(gtk.SHADOW_IN)
self._store = gtk.ListStore(str, str, int, str, str, bool, str)
self._list = gtk.TreeView(model=self._store)
cell_name = gtk.CellRendererText()
cell_uri = gtk.CellRendererText()
col_name = gtk.TreeViewColumn(_('Name'),
cell_name,
text=DavColumn.NAME)
col_uri = gtk.TreeViewColumn(_('URI'), cell_uri, text=DavColumn.URI)
col_name.set_expand(True)
self._list.append_column(col_name)
self._list.append_column(col_uri)
# create controls
image_add = gtk.Image()
image_add.set_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_BUTTON)
button_add = gtk.Button()
button_add.set_image(image_add)
button_add.connect('clicked', self._add_mount)
image_edit = gtk.Image()
image_edit.set_from_stock(gtk.STOCK_EDIT, gtk.ICON_SIZE_BUTTON)
button_edit = gtk.Button()
button_edit.set_image(image_edit)
button_edit.connect('clicked', self._edit_mount)
image_delete = gtk.Image()
image_delete.set_from_stock(gtk.STOCK_DELETE, gtk.ICON_SIZE_BUTTON)
button_delete = gtk.Button()
button_delete.set_image(image_delete)
button_delete.connect('clicked', self._delete_mount)
button_mount = gtk.Button(_('Mount'))
button_mount.connect('clicked', self._mount_selected)
button_unmount = gtk.Button(_('Unmount'))
button_unmount.connect('clicked', self._unmount_selected)
# use spinner if possible to denote busy operation
if hasattr(gtk, 'Spinner'):
self._spinner = gtk.Spinner()
self._spinner.set_size_request(20, 20)
self._spinner.set_property('no-show-all', True)
else:
self._spinner = None
# pack user interface
list_container.add(self._list)
self._container.pack_start(list_container, True, True, 0)
self._controls.pack_start(button_add, False, False, 0)
self._controls.pack_start(button_edit, False, False, 0)
self._controls.pack_start(button_delete, False, False, 0)
if self._spinner is not None:
self._controls.pack_start(self._spinner, False, False, 0)
self._controls.pack_end(button_unmount, False, False, 0)
self._controls.pack_end(button_mount, False, False, 0)
# load entries from config file
self.__populate_list()
def __init__(self, folder):
'''
Конструктор
:param folder: Папка, в которой будет осуществляться поиск
:type folder: string
'''
gtk.gdk.threads_init()
if os.path.exists(folder):
self.folder = folder
gtk.Window.__init__(self)
self.set_title(_('File search'))
self.set_position(gtk.WIN_POS_CENTER)
self.set_default_size(800,500)
vbox = gtk.VBox(False, 10)
#main params
mainParamsVBox = gtk.VBox(False,10)
hbox1 = gtk.HBox(False,0)
self.label1 = gtk.Label(_('File name'))
self.label1.set_alignment(0,0.5)
self.fileNameEntry = gtk.Entry()
self.exactCB = gtk.CheckButton(_('Exact'))
self.caseCB = gtk.CheckButton(_('Case sensitive'))
self.regexCB = gtk.CheckButton(_('Regex'))
self.fileTypeCombo = gtk.combo_box_new_text()
self.fileTypeCombo.append_text(_('Files and folders'))
self.fileTypeCombo.append_text(_('Files only'))
self.fileTypeCombo.append_text(_('Folders only'))
self.fileTypeCombo.set_active(0)
hbox1.pack_start(self.label1, False, False, 10)
hbox1.pack_start(self.fileNameEntry, True, True)
hbox1.pack_start(self.fileTypeCombo, False, False,10)
hbox1.pack_start(self.exactCB, False, False,10)
hbox1.pack_start(self.caseCB, False, False,10)
hbox1.pack_start(self.regexCB, False, False,10)
self.regexCB.connect('clicked',self.regexCBClick)
hbox2 = gtk.HBox(False,0)
self.label2 = gtk.Label(_('Search in folder'))
self.label2.set_alignment(0,0.5)
self.fileChooser = gtk.FileChooserButton(_('Select folder'))
self.fileChooser.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
if self.folder:
self.fileChooser.set_current_folder(self.folder)
self.folderRecursiveCB = gtk.CheckButton(_('Recursive'))
self.folderRecursiveCB.set_active(True)
hbox2.pack_start(self.label2, False, False, 10)
hbox2.pack_start(self.fileChooser, True, True)
hbox2.pack_start(self.folderRecursiveCB, False, False, 10)
hbox3 = gtk.HBox(False,0)
self.label3 = gtk.Label(_('Search for text'))
self.label3.set_alignment(0,0.5)
self.textEntry = gtk.Entry()
self.textCaseCB = gtk.CheckButton(_('Case sensitive'))
self.textRegexCB = gtk.CheckButton(_('Regex'))
hbox3.pack_start(self.label3, False, False, 10)
hbox3.pack_start(self.textEntry, True, True)
hbox3.pack_start(self.textCaseCB, False, False, 10)
hbox3.pack_start(self.textRegexCB, False, False, 10)
mainParamsVBox.pack_start(hbox1)
mainParamsVBox.pack_start(hbox2)
mainParamsVBox.pack_start(hbox3)
#additional params
addParamsExpander = gtk.Expander(_('Additional parameters'))
addParamsHBox = gtk.HBox()
addParamsVBox1 = gtk.VBox()
self.useLocateCB = gtk.CheckButton(_('Use UNIX \'locate\' command'))
self.useLocateCB.set_active(True)
self.useLocateCB.set_tooltip_text('Possibly slow for text search')
self.hiddenCB = gtk.CheckButton(_('Process hidden files and folders'))
self.linksCB = gtk.CheckButton(_('Follow simlinks'))
self.linksCB.set_tooltip_text('Attention! Dead locks possible! ')
self.linksCB.set_active(True)
addParamsVBox1.pack_start(self.useLocateCB, False, False)
addParamsVBox1.pack_start(self.hiddenCB, False, False)
addParamsVBox1.pack_start(self.linksCB, False, False)
addParamsHBox.pack_start(addParamsVBox1,False, False, 10)
addParamsExpander.add(addParamsHBox)
#treeview
self.treeview = gtk.TreeView()
r = gtk.CellRendererText()
self.treeview.insert_column_with_attributes(-1, "File name", r, text=0)
#status box
self.statusBox = gtk.HBox(False,10)
self.spinner = gtk.Spinner()
#self.spinner.set_sensitive(0)
self.statusLabel = gtk.Label('')
# statusLabel.set_justify(gtk.JUSTIFY_LEFT)
self.statusLabel.set_alignment(0,0)
self.statusLabel.set_width_chars(120)
self.statusBox.pack_start(self.spinner,False,False,10)
self.statusBox.pack_start(self.statusLabel, False, False,10)
#button box
buttonBox = gtk.HButtonBox()
buttonBox.set_layout(gtk.BUTTONBOX_END)
buttonBox.set_spacing(10)
buttonBox.set_border_width(10)
self.buttonStart = gtk.Button(_('Start search'),gtk.STOCK_FIND)
self.buttonStop = gtk.Button(_('Stop search'), gtk.STOCK_STOP)
self.imagePause = gtk.Image()
self.imagePause.set_from_stock(gtk.STOCK_MEDIA_PAUSE, gtk.ICON_SIZE_BUTTON)
self.imageContinue = gtk.Image()
self.imageContinue.set_from_stock(gtk.STOCK_MEDIA_PLAY, gtk.ICON_SIZE_BUTTON)
self.buttonPause = gtk.ToggleButton(_('Pause search'))
self.buttonPause.set_image(self.imagePause)
self.buttonPause.set_mode(True)
self.buttonClose = gtk.Button(_('Close'), gtk.STOCK_CLOSE)
buttonBox.add(self.buttonStart)
buttonBox.add(self.buttonStop)
buttonBox.add(self.buttonPause)
buttonBox.add(self.buttonClose)
self.buttonClose.connect('clicked', self.closeSearch)
self.buttonStart.connect('clicked', self.startSearch)
self.buttonStop.connect('clicked', self.stopSearch)
self.buttonPause.connect('clicked',self.pauseSearch)
self.buttonStop.set_sensitive(0)
self.buttonPause.set_sensitive(0)
vbox.pack_start(mainParamsVBox, False, True, 10)
vbox.pack_start(addParamsExpander, False, True, 0)
scrolled = gtk.ScrolledWindow()
scrolled.add(self.treeview)
vbox.pack_start(scrolled, True, True, 0)
vbox.pack_start(self.statusBox, False, True, 0)
vbox.pack_start(buttonBox, False, True, 0)
self.add(vbox)
#self.connect('destroy', self.closeSearch)
self.connect('delete-event', self.closeSearch)
class Gui(gtk.Window):
def __init__(self):
super(Gui, self).__init__()
SPINNER_SIZE = 32
LIST_SIZE = 210
self.LABEL_NO_INFO = 'No info'
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", "city-64.png"))
self.COUNTRY_ICON = gtk.gdk.pixbuf_new_from_file(
os.path.join(sys.path[0], "images", "countries-16.png"))
self.CITY_ICON = gtk.gdk.pixbuf_new_from_file(
os.path.join(sys.path[0], "images", "city-16.png"))
except Exception, e:
print e.message
self.set_title("Cities info")
self.sp_countries = gtk.Spinner()
self.sp_countries.set_size_request(SPINNER_SIZE, SPINNER_SIZE)
self.countries_store = gtk.ListStore(gtk.gdk.Pixbuf, str, int)
self.cb_countries = self.create_combo_box(self.countries_store)
self.cb_countries.connect("changed", self.cb_countries_changed)
self.cb_countries.show()
self.btn_countries_error = gtk.Button("Retry")
self.btn_countries_error.connect("clicked", self.btn_countries_error_clicked)
vb_countries = gtk.VBox(False, 1)
vb_countries.pack_start(self.sp_countries, False, False, 1)
vb_countries.pack_start(self.cb_countries, False, False, 1)
vb_countries.pack_start(self.btn_countries_error, False, False, 1)
vb_countries.show()
fr_countries = gtk.Frame("Countries")
fr_countries.add(vb_countries)
fr_countries.show()
self.cities_store = gtk.ListStore(gtk.gdk.Pixbuf, str)
tv_cities = self.create_tree_view()
tv_cities.set_model(self.cities_store)
tv_cities.connect("row-activated", self.on_cities_activated)
sw_cities = self.create_scrolled_window()
sw_cities.add(tv_cities)
fr_cities = gtk.Frame("Cities")
fr_cities.add(sw_cities)
fr_cities.show_all()
vb_left = gtk.VBox(False, 1)
vb_left.set_size_request(LIST_SIZE, -1)
vb_left.pack_start(fr_countries, False, False, 1)
vb_left.pack_start(fr_cities, True, True, 1)
vb_left.show()
self.sp_info = gtk.Spinner()
self.sp_info.set_size_request(SPINNER_SIZE, SPINNER_SIZE)
self.lb_info = gtk.Label(self.LABEL_NO_INFO)
self.lb_info.set_line_wrap(True)
self.lb_info.show()
btn_info_error = gtk.Button("Retry")
btn_info_error.connect("clicked", self.btn_info_error_clicked)
btn_info_error.show()
self.hb_info_error = gtk.HBox(False, 1)
self.hb_info_error.pack_start(btn_info_error, True, False, 1)
self.im_info = gtk.Image()
vb_info = gtk.VBox(False, 1)
vb_info.pack_start(self.sp_info, True, False, 1)
vb_info.pack_start(self.im_info, True, False, 1)
vb_info.pack_start(self.lb_info, True, False, 1)
vb_info.pack_start(self.hb_info_error, True, False, 1)
vb_info.show()
fr_info = gtk.Frame("Info")
fr_info.add(vb_info)
fr_info.show()
hbox = gtk.HBox(False, 1)
hbox.pack_start(vb_left, False, False, 1)
hbox.pack_start(fr_info, True, True, 1)
self.add(hbox)
hbox.show()
self.show()
self.db_loader = DbLoader(self)
self.load_countries()
self.info_loader = InfoLoader(self)
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, parent, window):
MountManagerExtension.__init__(self, parent, window)
self._store = gtk.ListStore(str, str, str, str, bool, object)
self._volumes = {}
# create interface
container = gtk.ScrolledWindow()
container.set_shadow_type(gtk.SHADOW_IN)
container.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self._list = gtk.TreeView(model=self._store)
self._list.set_show_expanders(True)
self._list.set_search_column(MountsColumn.NAME)
cell_icon = gtk.CellRendererPixbuf()
cell_name = gtk.CellRendererText()
cell_mounted = gtk.CellRendererToggle()
cell_mounted.connect('toggled', self._mount_toggled)
col_name = gtk.TreeViewColumn(_('Name'))
col_name.pack_start(cell_icon, False)
col_name.pack_start(cell_name, True)
col_name.set_expand(True)
col_name.add_attribute(cell_icon, 'icon-name', VolumesColumn.ICON)
col_name.add_attribute(cell_name, 'text', VolumesColumn.NAME)
col_mounted = gtk.TreeViewColumn(_('Mounted'),
cell_mounted,
active=VolumesColumn.MOUNTED)
self._list.append_column(col_name)
self._list.append_column(col_mounted)
# create buttons
button_mount = gtk.Button()
button_mount.set_label(_('Mount'))
button_mount.connect('clicked', self._mount_volume)
button_unmount = gtk.Button()
button_unmount.set_label(_('Unmount'))
button_unmount.connect('clicked', self._unmount_volume)
# use spinner if possible to denote busy operation
if hasattr(gtk, 'Spinner'):
self._spinner = gtk.Spinner()
self._spinner.set_size_request(20, 20)
self._spinner.set_property('no-show-all', True)
else:
self._spinner = None
# pack interface
container.add(self._list)
if self._spinner is not None:
self._controls.pack_start(self._spinner, False, False, 0)
self._controls.pack_end(button_unmount, False, False, 0)
self._controls.pack_end(button_mount, False, False, 0)
self._container.pack_start(container, True, True, 0)
def __init__(self, parent, window):
MountManagerExtension.__init__(self, parent, window)
# create store for mounts
self._store = gtk.ListStore(str, str, str, str, object, bool)
self._mounts = {}
# create interface
container = gtk.ScrolledWindow()
container.set_shadow_type(gtk.SHADOW_IN)
container.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self._list = gtk.TreeView(model=self._store)
self._list.set_show_expanders(True)
self._list.set_search_column(MountsColumn.NAME)
cell_icon = gtk.CellRendererPixbuf()
cell_name = gtk.CellRendererText()
cell_system = gtk.CellRendererToggle()
# try to set icon size
try:
cell_icon.props.stock_size = gtk.ICON_SIZE_LARGE_TOOLBAR
except:
pass
col_name = gtk.TreeViewColumn(_('Name'))
col_name.pack_start(cell_icon, False)
col_name.pack_start(cell_name, True)
col_name.set_expand(True)
col_name.add_attribute(cell_icon, 'icon-name', MountsColumn.ICON)
col_name.add_attribute(cell_name, 'markup', MountsColumn.MARKUP_NAME)
col_system = gtk.TreeViewColumn(_('Systemwide'),
cell_system,
active=MountsColumn.SYSTEM_WIDE)
self._list.append_column(col_name)
self._list.append_column(col_system)
# create controls
image_jump = gtk.Image()
image_jump.set_from_icon_name(gtk.STOCK_OPEN, gtk.ICON_SIZE_BUTTON)
button_jump = gtk.Button()
button_jump.set_image(image_jump)
button_jump.set_label(_('Open'))
button_jump.connect('clicked', self._open_selected, False)
try:
button_jump.set_can_default(True)
except AttributeError:
button_jump.set_property('can-default', True)
image_new_tab = gtk.Image()
image_new_tab.set_from_icon_name('tab-new', gtk.ICON_SIZE_BUTTON)
button_new_tab = gtk.Button()
button_new_tab.set_image(image_new_tab)
button_new_tab.set_label(_('Open in tab'))
button_new_tab.set_tooltip_text(_('Open selected URI in new tab'))
button_new_tab.connect('clicked', self._open_selected, True)
button_unmount = gtk.Button()
button_unmount.set_label(_('Unmount'))
button_unmount.connect('clicked', self._unmount_selected)
# use spinner if possible to denote busy operation
if hasattr(gtk, 'Spinner'):
self._spinner = gtk.Spinner()
self._spinner.set_size_request(20, 20)
self._spinner.set_property('no-show-all', True)
else:
self._spinner = None
# pack interface
container.add(self._list)
self._controls.pack_start(button_jump, False, False, 0)
self._controls.pack_start(button_new_tab, False, False, 0)
self._controls.pack_end(button_unmount, False, False, 0)
self._container.pack_start(container, True, True, 0)
def __init__(self, application, parent):
self._application = application
self._parent = parent
self._radius = 3
self._control_count = 0
self._state = gtk.STATE_NORMAL
self._mode = Mode.NORMAL
self._menu = None
self._style = None
self._toolbar_style = None
self._box_spacing = 1
self._box_border_width = 4
self._super_user_colors = None
self._breadcrumbs = None
# get options
options = self._application.options
self._ubuntu_coloring = options.get('ubuntu_coloring')
self._superuser_notification = options.get('superuser_notification')
self._button_relief = options.get('button_relief')
# determine whether we need to show breadcrumbs
from plugin_base.item_list import ItemList
section = options.section('item_list')
is_list = isinstance(parent, ItemList)
self._breadcrumb_type = section.get('breadcrumbs')
self._show_breadcrumbs = self._breadcrumb_type != Breadcrumbs.TYPE_NONE and is_list
# create container box
self._hbox = gtk.HBox(homogeneous=False, spacing=self._box_spacing)
# configure title bar
self._hbox.set_border_width(self._box_border_width)
self._container = gtk.EventBox()
self._container.set_app_paintable(True)
self._container.add_events(gtk.gdk.BUTTON_RELEASE_MASK)
# connect signals
self._container.connect('realize', self.__realize_event)
self._container.connect('button-release-event', self.__button_release_event)
self._hbox.connect('expose-event', self.__expose_event)
# top folder icon as default
self._icon = gtk.Image()
# create plugin main menu button
style = gtk.RcStyle()
style.xthickness = 0
style.ythickness = 0
self._button_menu = gtk.Button()
self._button_menu.add(self._icon)
if not self._button_relief:
self._button_menu.set_relief(gtk.RELIEF_NONE)
self._button_menu.modify_style(style)
self._button_menu.set_focus_on_click(False)
self._button_menu.set_tooltip_text(_('Context menu'))
self._button_menu.connect('clicked', self.show_menu)
# create title box
vbox = gtk.VBox(False, 1)
if self._show_breadcrumbs:
self._breadcrumbs = Breadcrumbs(self)
vbox.pack_start(self._breadcrumbs, True, True, 0)
else:
self._title_label = gtk.Label()
self._title_label.set_alignment(0, 0.5)
self._title_label.set_use_markup(True)
self._title_label.set_ellipsize(pango.ELLIPSIZE_MIDDLE)
vbox.pack_start(self._title_label, True, True, 0)
font = pango.FontDescription('8')
self._subtitle_label = gtk.Label()
self._subtitle_label.set_alignment(0, 0.5)
self._subtitle_label.set_use_markup(False)
self._subtitle_label.modify_font(font)
# create spinner control if it exists
self._spinner_counter = 0
if hasattr(gtk, 'Spinner'):
self._spinner = gtk.Spinner()
self._spinner.set_size_request(20, 20)
self._spinner.set_property('no-show-all', True)
else:
self._spinner = None
# pack interface
vbox.pack_start(self._subtitle_label, False, False, 0)
self._hbox.pack_start(self._button_menu, False, False, 0)
self._hbox.pack_start(vbox, True, True, 4)
if self._spinner is not None:
self._hbox.pack_start(self._spinner, False, False, 5)
self._container.add(self._hbox)
def StartGUI(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("delete_event", gtk.main_quit)
self.window.set_border_width(10)
self.window.set_default_size(400, 800)
self.window.set_title("Reference Model Builder")
self.vbox = gtk.VBox() # this is the main container
#################################################################################
# --- PDB file selection ---
# checking for pdb files in reference directory
referenceFiles = []
for files in glob.glob(
os.path.join(self.reference_directory, '*-ground-state.pdb')):
pdbFile = files[files.rfind('/') + 1:]
referenceFiles.append(pdbFile)
frame = gtk.Frame(label='Select PDB file')
hbox = gtk.HBox()
self.cb_select_pdb = gtk.combo_box_new_text()
# self.cb_select_pdb.connect("changed", self.set_selection_mode)
for pdbFile in referenceFiles:
self.cb_select_pdb.append_text(pdbFile)
hbox.add(self.cb_select_pdb)
frame.add(hbox)
self.vbox.pack_start(frame)
self.load_pdb_file_button = gtk.Button(label="Load")
# self.load_pdb_file_button.connect("clicked",self.get_samples_to_look_at)
self.load_pdb_file_button.connect("clicked", self.load_pdb_file)
hbox.add(self.load_pdb_file_button)
frame.add(hbox)
self.vbox.pack_start(frame)
# SPACER
self.vbox.add(gtk.Label(' '))
frame = gtk.Frame(label='MTZ file to refine against')
hbox = gtk.HBox()
self.mtzFree = ''
self.mtzFree_label = gtk.Label()
hbox.add(self.mtzFree_label)
frame.add(hbox)
self.vbox.pack_start(frame)
# SPACER
self.vbox.add(gtk.Label(' '))
frame = gtk.Frame(label='MTZ file after refinement')
hbox = gtk.HBox()
self.mtzRefine_label = gtk.Label()
hbox.add(self.mtzRefine_label)
frame.add(hbox)
self.vbox.pack_start(frame)
# SPACER
self.vbox.add(gtk.Label(' \n '))
#################################################################################
# --- ground state mean map ---
# checking for ground state mean map in reference folder
# self.meanMaps = {}
# for dirs in glob.glob(os.path.join(self.reference_directory,'pandda_*')):
# panddaDir=dirs.split('/')[len(dirs.split('/'))-1]
# for files in glob.glob(os.path.join(dirs,'processed_datasets','*','*ground-state-mean-map.native.ccp4')):
# if os.path.isfile(files):
# self.meanMaps[panddaDir]=files
# break
# frame = gtk.Frame(label='Load ground-state-mean-map files')
# hbox=gtk.HBox()
# self.cb_select_mean_map = gtk.combo_box_new_text()
# for item in self.meanMaps:
# self.cb_select_mean_map.append_text(item)
# hbox.add(self.cb_select_mean_map)
# self.load_ground_state_map_button = gtk.Button(label="Load")
# self.load_ground_state_map_button.connect("clicked",self.load_ground_state_map)
# hbox.add(self.load_ground_state_map_button)
# frame.add(hbox)
# self.vbox.pack_start(frame)
# frame = gtk.Frame()
# hbox=gtk.HBox()
# self.cb_select_mean_map_by_resolution = gtk.combo_box_new_text()
# self.cb_select_mean_map_by_resolution.connect("changed", self.show_selected_mean_map)
# hbox.add(self.cb_select_mean_map_by_resolution)
## self.show_highres_ground_state_map_button = gtk.Button(label="Show Highest\nResolution Map")
## self.show_highres_ground_state_map_button.connect("clicked",self.show_highres_ground_state_map)
## hbox.add(self.show_highres_ground_state_map_button)
## self.show_all_ground_state_map_button = gtk.Button(label="Show All Maps")
## self.show_all_ground_state_map_button.connect("clicked",self.show_all_ground_state_map)
## hbox.add(self.show_all_ground_state_map_button)
# frame.add(hbox)
# self.vbox.pack_start(frame)
# SPACER
# self.vbox.add(gtk.Label(' \n '))
#################################################################################
# --- Refinement History ---
frame = gtk.Frame(label='Refinement History')
self.hbox_for_info_graphics = gtk.HBox()
self.canvas = FigureCanvas(self.update_plot([0], [0], [0]))
self.canvas.set_size_request(190, 190)
self.hbox_for_info_graphics.add(self.canvas)
frame.add(self.hbox_for_info_graphics)
self.vbox.pack_start(frame)
#################################################################################
# --- status window ---
frame = gtk.Frame(label='Status')
vbox = gtk.VBox()
self.spinnerBox = gtk.VBox()
self.refinementRunning = gtk.Spinner()
vbox.add(self.spinnerBox)
# hbox.add(self.refinementRunning)
self.status_label = gtk.Label()
vbox.add(self.status_label)
frame.add(vbox)
self.status_label.set_text('idle')
# frame.add(self.status_label)
self.vbox.pack_start(frame)
#################################################################################
# --- Refinement Statistics ---
# next comes a section which displays some global quality indicators
# a combination of labels and textview widgets, arranged in a table
RRfreeLabel_frame = gtk.Frame()
self.RRfreeLabel = gtk.Label('R/Rfree')
RRfreeLabel_frame.add(self.RRfreeLabel)
self.RRfreeValue = gtk.Label(self.QualityIndicators['Rcryst'] + '/' +
self.QualityIndicators['Rfree'])
RRfreeBox_frame = gtk.Frame()
self.RRfreeBox = gtk.EventBox()
self.RRfreeBox.add(self.RRfreeValue)
RRfreeBox_frame.add(self.RRfreeBox)
ResolutionLabel_frame = gtk.Frame()
self.ResolutionLabel = gtk.Label('Resolution')
ResolutionLabel_frame.add(self.ResolutionLabel)
self.ResolutionValue = gtk.Label(
self.QualityIndicators['ResolutionHigh'])
ResolutionBox_frame = gtk.Frame()
self.ResolutionBox = gtk.EventBox()
self.ResolutionBox.add(self.ResolutionValue)
ResolutionBox_frame.add(self.ResolutionBox)
MolprobityScoreLabel_frame = gtk.Frame()
self.MolprobityScoreLabel = gtk.Label('MolprobityScore')
MolprobityScoreLabel_frame.add(self.MolprobityScoreLabel)
self.MolprobityScoreValue = gtk.Label(
self.QualityIndicators['MolprobityScore'])
MolprobityScoreBox_frame = gtk.Frame()
self.MolprobityScoreBox = gtk.EventBox()
self.MolprobityScoreBox.add(self.MolprobityScoreValue)
MolprobityScoreBox_frame.add(self.MolprobityScoreBox)
RamachandranOutliersLabel_frame = gtk.Frame()
self.RamachandranOutliersLabel = gtk.Label('Rama Outliers')
RamachandranOutliersLabel_frame.add(self.RamachandranOutliersLabel)
self.RamachandranOutliersValue = gtk.Label(
self.QualityIndicators['RamachandranOutliers'])
RamachandranOutliersBox_frame = gtk.Frame()
self.RamachandranOutliersBox = gtk.EventBox()
self.RamachandranOutliersBox.add(self.RamachandranOutliersValue)
RamachandranOutliersBox_frame.add(self.RamachandranOutliersBox)
RamachandranFavoredLabel_frame = gtk.Frame()
self.RamachandranFavoredLabel = gtk.Label('Rama Favored')
RamachandranFavoredLabel_frame.add(self.RamachandranFavoredLabel)
self.RamachandranFavoredValue = gtk.Label(
self.QualityIndicators['RamachandranFavoredColor'])
RamachandranFavoredBox_frame = gtk.Frame()
self.RamachandranFavoredBox = gtk.EventBox()
self.RamachandranFavoredBox.add(self.RamachandranFavoredValue)
RamachandranFavoredBox_frame.add(self.RamachandranFavoredBox)
rmsdBondsLabel_frame = gtk.Frame()
self.rmsdBondsLabel = gtk.Label('rmsd(Bonds)')
rmsdBondsLabel_frame.add(self.rmsdBondsLabel)
self.rmsdBondsValue = gtk.Label(self.QualityIndicators['rmsdBonds'])
rmsdBondsBox_frame = gtk.Frame()
self.rmsdBondsBox = gtk.EventBox()
self.rmsdBondsBox.add(self.rmsdBondsValue)
rmsdBondsBox_frame.add(self.rmsdBondsBox)
rmsdAnglesLabel_frame = gtk.Frame()
self.rmsdAnglesLabel = gtk.Label('rmsd(Angles)')
rmsdAnglesLabel_frame.add(self.rmsdAnglesLabel)
self.rmsdAnglesValue = gtk.Label(self.QualityIndicators['rmsdAngles'])
rmsdAnglesBox_frame = gtk.Frame()
self.rmsdAnglesBox = gtk.EventBox()
self.rmsdAnglesBox.add(self.rmsdAnglesValue)
rmsdAnglesBox_frame.add(self.rmsdAnglesBox)
MatrixWeightLabel_frame = gtk.Frame()
self.MatrixWeightLabel = gtk.Label('Matrix Weight')
MatrixWeightLabel_frame.add(self.MatrixWeightLabel)
self.MatrixWeightValue = gtk.Label(
self.QualityIndicators['MatrixWeight'])
MatrixWeightBox_frame = gtk.Frame()
self.MatrixWeightBox = gtk.EventBox()
self.MatrixWeightBox.add(self.MatrixWeightValue)
MatrixWeightBox_frame.add(self.MatrixWeightBox)
outer_frame = gtk.Frame()
hbox = gtk.HBox()
frame = gtk.Frame()
self.table_left = gtk.Table(8, 2, False)
self.table_left.attach(RRfreeLabel_frame, 0, 1, 0, 1)
self.table_left.attach(ResolutionLabel_frame, 0, 1, 1, 2)
self.table_left.attach(MolprobityScoreLabel_frame, 0, 1, 2, 3)
self.table_left.attach(RamachandranOutliersLabel_frame, 0, 1, 3, 4)
self.table_left.attach(RamachandranFavoredLabel_frame, 0, 1, 4, 5)
self.table_left.attach(rmsdBondsLabel_frame, 0, 1, 5, 6)
self.table_left.attach(rmsdAnglesLabel_frame, 0, 1, 6, 7)
self.table_left.attach(MatrixWeightLabel_frame, 0, 1, 7, 8)
self.table_left.attach(RRfreeBox_frame, 1, 2, 0, 1)
self.table_left.attach(ResolutionBox_frame, 1, 2, 1, 2)
self.table_left.attach(MolprobityScoreBox_frame, 1, 2, 2, 3)
self.table_left.attach(RamachandranOutliersBox_frame, 1, 2, 3, 4)
self.table_left.attach(RamachandranFavoredBox_frame, 1, 2, 4, 5)
self.table_left.attach(rmsdBondsBox_frame, 1, 2, 5, 6)
self.table_left.attach(rmsdAnglesBox_frame, 1, 2, 6, 7)
self.table_left.attach(MatrixWeightBox_frame, 1, 2, 7, 8)
frame.add(self.table_left)
hbox.add(frame)
outer_frame.add(hbox)
self.vbox.add(outer_frame)
button = gtk.Button(label="Show MolProbity to-do list")
button.connect("clicked", self.show_molprobity_to_do)
self.vbox.add(button)
self.vbox.pack_start(frame)
# SPACER
self.vbox.add(gtk.Label(' '))
# --- refinement & options ---
self.hbox_for_refinement = gtk.HBox()
self.REFINEbutton = gtk.Button(label="Refine")
self.RefinementParamsButton = gtk.Button(label="refinement parameters")
self.REFINEbutton.connect("clicked", self.REFINE)
self.hbox_for_refinement.add(self.REFINEbutton)
self.RefinementParamsButton.connect("clicked", self.RefinementParams)
self.hbox_for_refinement.add(self.RefinementParamsButton)
self.vbox.add(self.hbox_for_refinement)
# --- CANCEL button ---
self.CANCELbutton = gtk.Button(label="CANCEL")
self.CANCELbutton.connect("clicked", self.CANCEL)
self.vbox.add(self.CANCELbutton)
self.window.add(self.vbox)
self.window.show_all()
def create_ui(self):
mainvbox = gtk.VBox()
hbox = gtk.HBox()
self.adapterlist = gtk.combo_box_new_text()
self.adapterlist.connect("changed", self.adapter_changed)
self.initialtuning = gtk.combo_box_new_text()
self.find_adapters_and_fill_list()
hbox.add(self.adapterlist)
hbox.add(self.initialtuning)
scanbutton = gtk.Button("Scan")
scanbutton.connect("clicked", self.scan_button_clicked)
hbox.add(scanbutton)
mainvbox.pack_start(hbox, fill=False, expand=False)
scanvbox = gtk.VBox()
self.label = gtk.Label("")
self.progressbar = gtk.ProgressBar()
scanvbox.pack_start(self.label, True, True, 3)
scanvbox.pack_start(self.progressbar, True, True, 3)
mainvbox.pack_start(scanvbox, fill=False, expand=False)
self.channelstore = gtk.ListStore(str, int, int, int)
self.channelstore.set_sort_column_id(2, gtk.SORT_ASCENDING)
self.channelview = gtk.TreeView(self.channelstore)
self.channelview.set_headers_visible(True)
self.channelview.set_sensitive(True)
namecol = gtk.TreeViewColumn("Channel", gtk.CellRendererText(), text=0)
self.channelview.append_column(namecol)
self.channelview.connect("row-activated", self.play_channel)
channelscroll = gtk.ScrolledWindow()
channelscroll.add(self.channelview)
label = gtk.Label("Current Program:")
eitscroll = gtk.ScrolledWindow()
textview = gtk.TextView()
textview.set_wrap_mode(gtk.WRAP_WORD)
self.eittextbuffer = textview.get_buffer()
eitscroll.add(textview)
eitscroll.show()
textview.show()
channelvbox = gtk.VBox()
channelvbox.pack_start(channelscroll)
channelvbox.pack_start(label, False, False, 3)
channelvbox.pack_start(eitscroll)
playervbox = gtk.VBox()
self.videowidget = VideoWidget()
playervbox.pack_start(self.videowidget)
hbox = gtk.HBox()
playervbox.pack_start(hbox, fill=False, expand=False)
self.pause_image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PAUSE,
gtk.ICON_SIZE_BUTTON)
self.pause_image.show()
self.play_image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PLAY,
gtk.ICON_SIZE_BUTTON)
self.play_image.show()
self.playbutton = button = gtk.Button()
button.add(self.play_image)
button.set_property('can-default', True)
button.set_focus_on_click(False)
button.set_size_request(40, 40)
button.show()
hbox.pack_start(button, False, False, 3)
button.set_property('has-default', False)
button.connect('clicked', lambda *args: self.play_toggled())
image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_NEXT,
gtk.ICON_SIZE_BUTTON)
image.show()
button = gtk.Button()
button.add(image)
button.set_property('can-default', True)
button.set_focus_on_click(False)
button.set_size_request(40, 40)
button.show()
hbox.pack_start(button, False, False, 3)
button.set_property('has-default', False)
button.connect('clicked', lambda *args: self.seek_end_toggled())
self.adjustment = gtk.Adjustment(0.0, 0.00, 100.0, 0.1, 1.0, 1.0)
hscale = gtk.HScale(self.adjustment)
hscale.set_digits(2)
hscale.set_update_policy(gtk.UPDATE_CONTINUOUS)
hscale.connect('button-press-event', self.scale_button_press_cb)
hscale.connect('button-release-event', self.scale_button_release_cb)
hscale.connect('format-value', self.scale_format_value_cb)
hbox.pack_start(hscale, True, True, 3)
self.hscale = hscale
image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_RECORD,
gtk.ICON_SIZE_BUTTON)
image.show()
self.recordbutton = button = gtk.ToggleButton()
button.add(image)
button.set_focus_on_click(False)
button.set_size_request(40, 40)
button.show()
hbox.pack_start(button, False, False, 3)
button.connect('clicked', lambda *args: self.recording_toggled())
self.spinner = spinner = gtk.Spinner()
spinner.show()
spinner.size(32, 32)
hbox.pack_start(spinner, False, True, 3)
hbox = gtk.HBox()
hbox.add(channelvbox)
hbox.add(playervbox)
mainvbox.add(hbox)
# add widgets to window
self.add(mainvbox)
def __init__(self, label):
super(MyThread, self).__init__()
self.label = label
self.quit = False
def update_label(self, counter):
self.label.start()
return False
def run(self):
counter = 0
while True:
counter += 1
gobject.idle_add(self.update_label, counter)
time.sleep(5)
print 'done'
self.label.stop()
break
w = gtk.Window()
#l = gtk.Label()
h = gtk.Spinner()
#w.add(l)
w.add(h)
w.show_all()
w.connect("destroy", lambda _: gtk.main_quit())
t = MyThread(h)
t.start()
gtk.main()
t.quit = True
