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