def update_info(self, app): port = app.info # Clear for child in port.get_children(): port.remove(child) # Alignment align = gtk.Alignment(0, 0, 1, 1) align.set_padding(4, 4, 4, 4) port.add(align) # Vertical box vbox = gtk.VBox() align.add(vbox) for category in self.info: name = category[0] category = category[1:] # Frame frame = gtk.Frame('<b>%s</b>' % name) frame.set_shadow_type(gtk.SHADOW_ETCHED_IN) frame.get_label_widget().set_use_markup(True) vbox.pack_start(frame, False) # Alignment align = gtk.Alignment(0, 0, 1, 1) align.set_padding(0, 0, 12, 0) frame.add(align) # Table table = gtk.Table(len(category), 2) table.set_col_spacing(0, 5) align.add(table) row = 0 for name, value in category: # Name label = gtk.Label('<b>%s</b>' % name) label.set_use_markup(True) label.set_alignment(1, 0.5) table.attach(label, 0, 1, row, row + 1, gtk.FILL, gtk.FILL) # Value if value.startswith('http://'): label = gtk.LinkButton(value, value) label.set_relief(gtk.RELIEF_NONE) label.set_property('can-focus', False) else: label = gtk.Label(value) label.set_alignment(0, 0.5) label.modify_font(app.mono_font) table.attach(label, 1, 2, row, row + 1, yoptions=gtk.FILL) row += 1 port.realize() port.show_all()
def __init__(self, controller): '''Constructor''' gtk.HBox.__init__(self) self.controller = controller self.theme = controller.theme self.config = controller.config self.set_border_width(2) self.smileysCache = {} self.hasSmilies = True self.tNick = gtk.Entry(max=129) self.tNick.set_text(self.controller.msn.nick.replace('\n', ' ')) self.tNick.set_no_show_all(True) self.lNick = SmileyLabel('', self.controller.widget_style) self.lNick.set_ellipsize(pango.ELLIPSIZE_END) self.bNick = gtk.Button() self.bNick.set_relief(gtk.RELIEF_NONE) self.bNick.set_alignment(0, 0) self.bNick.add(self.lNick) iconMail = self.theme.getSmiley("(e)") #email icon self.mailButton = ImageButton(iconMail, '(0)') self.mailButton.set_relief(gtk.RELIEF_NONE) self.mailButton.set_tooltip_text(_('Click here to access your mail')) i = self.controller.contacts.get_status() status = self.controller.status_ordered[0][i] self.statusIcon = self.theme.statusToPixbuf(status) self.statusButton = ImageButton(self.statusIcon) self.statusButton.set_relief(gtk.RELIEF_NONE) self.statusButton.set_tooltip_text( _('Click here to change your status')) self.statusMenu = StatusMenu.StatusMenu(self.controller) self.tPersonalMessage = gtk.Entry(max=129) self.tPersonalMessage.set_text(self.controller.contacts.get_message()) self.tPersonalMessage.set_no_show_all(True) self.lPersonalMessage = SmileyLabel('', self.controller.widget_style) self.lPersonalMessage.set_ellipsize(pango.ELLIPSIZE_END) self.bPersonalMessage = gtk.Button() self.bPersonalMessage.set_relief(gtk.RELIEF_NONE) self.bPersonalMessage.set_alignment(0, 0) self.bPersonalMessage.add(self.lPersonalMessage) mediaIcon = self.theme.getSmiley("(8)") #media icon # at the bottom is the code to handle starting toggled self.mediaButton = ImageToggleButton(mediaIcon) self.mediaButton.set_relief(gtk.RELIEF_NONE) try: # why, oh why, gtk must be so angry? self.mediaButton.set_tooltip_text( _('Toggle sending current playing song')) except: pass self.lMedia = gtk.Label(_("No media playing")) self.lMedia.set_ellipsize(pango.ELLIPSIZE_END) self.bMedia = gtk.Button() self.bMedia.set_relief(gtk.RELIEF_NONE) self.bMedia.set_alignment(0, 0) self.bMedia.add(self.lMedia) self.bMedia.connect('clicked', self.onMediaClicked) self.lMedia.set_no_show_all(True) self.bMedia.set_no_show_all(True) self.bNick.set_tooltip_text(_('Click here to set your nick name')) self.bPersonalMessage.set_tooltip_text( _('Click here to set your personal message')) self.bMedia.set_tooltip_text(_('Your current media')) self.image = Widgets.avatarHolder(cellDimention=48) self.imageEventBox = gtk.EventBox() self.imageEventBox.set_events(gtk.gdk.BUTTON_PRESS_MASK) self.imageEventBox.connect('button-press-event', self.avatarClicked) self.imageEventBox.add(self.image) self.imageEventBox.set_tooltip_text(_('Click here to set your avatar')) #frame = gtk.AspectFrame() #frame.add(self.imageEventBox) if self.controller.avatar: self.image.set_from_pixbuf(self.controller.avatar.getThumb()) else: self.pixbuf = self.controller.theme.getImage('userPanel') self.image.set_from_pixbuf(self.pixbuf) self.tNick.connect('activate', self.on_nick_changed) self.tNick.connect('focus-out-event', self.on_nick_changed) self.bNick.connect('clicked', self.on_nick_clicked) self.tPersonalMessage.connect('activate', self.on_pm_changed) self.tPersonalMessage.connect('focus-out-event', self.on_pm_changed) self.bPersonalMessage.connect('clicked', self.on_pm_clicked) self.mediaButton.connect("toggled", self.onToggleMedia) self.mailButton.connect('clicked', self.onMaiButtonClicked) self.controller.msn.connect('self-personal-message-changed', self.personalMessageChanged) self.controller.msn.connect('self-nick-changed', self.selfNickChanged) self.controller.msn.connect('self-current-media-changed', self.currentMediaChanged) self.mailButton.setText('(' + str(self.controller.getUnreadMails()) + ')') self.controller.msn.connect('initial-mail-notification', self.updateMailCount) self.controller.msn.connect('new-mail-notification', self.updateMailCount) self.controller.msn.connect('mail-movement-notification', self.updateMailCount) self.statusButton.connect('button-press-event', self.pop_up_status_menu) self.controller.msn.connect('self-status-changed',\ self.update_status_icon) self.hbox = gtk.HBox() self.pack_start(self.imageEventBox, False, False) self.vbox1 = gtk.VBox() self.vbox2 = gtk.VBox(True) self.hbox1 = gtk.HBox() self.hbox2 = gtk.HBox() self.hbox1.pack_start(self.tNick, True, True) self.hbox1.pack_start(self.bNick, True, True) self.hbox2.pack_start(self.tPersonalMessage, True, True) self.hbox2.pack_start(self.bPersonalMessage, True, True) self.hbox2.pack_start(self.bMedia, True, True) self.vbox2h1 = gtk.HBox() self.vbox2h1.pack_end(self.mailButton, True, False) self.vbox2h1aligned = gtk.Alignment(1, 0, 0, 0) self.vbox2h1aligned.add(self.vbox2h1) self.vbox2h2 = gtk.HBox() self.vbox2h2.pack_start(self.mediaButton, True, False) self.vbox2h2.pack_end(self.statusButton, True, False) self.vbox2h2aligned = gtk.Alignment(1, 0, 0, 0) self.vbox2h2aligned.add(self.vbox2h2) self.vbox2.pack_start(self.vbox2h1aligned, True, False) self.vbox2.pack_start(self.vbox2h2aligned, True, False) self.vbox1.pack_start(self.hbox1, True, False, 1) self.vbox1.pack_start(self.hbox2, True, False, 1) self.hbox.pack_start(self.vbox1, True, True) self.hbox.pack_start(self.vbox2, False, False) self.pack_start(self.hbox) self.show_all() # if in the config is active we activate it emitting the toggled signal if controller.config.user['mediaEnabled']: self.mediaButton.set_active(True) self.mediaButton.hide() try: if not DOMAIN_REGEXP.match( self.controller.userEmail.split("@")[1]): self.mailButton.hide() except Exception, e: print "error! " + str(e)
def __init__(self): gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL) self.set_border_width(6) self.set_resizable(False) self.set_title('') # defaults to center location self.set_position(gtk.WIN_POS_CENTER) self.connect("delete-event", self.__on_close) # main container main = gtk.VBox(spacing=12) main.set_spacing(12) main.set_border_width(6) main.show() self.add(main) # primary text alg = gtk.Alignment() alg.set_padding(0, 6, 0, 0) alg.show() main.pack_start(alg, False, False) lbl = hig_label() lbl.set_selectable(False) lbl.show() self.__primary_label = lbl alg.add(lbl) # secondary text lbl = hig_label() lbl.set_selectable(False) lbl.show() main.pack_start(lbl, False, False) self.__secondary_label = lbl # Progress bar vbox = gtk.VBox() vbox.show() main.pack_start(vbox, False, False) prog = gtk.ProgressBar() prog.show() self.__progress_bar = prog vbox.pack_start(prog, expand=False) lbl = hig_label() lbl.set_selectable(False) lbl.show() self.__sub_progress_label = lbl vbox.pack_start(lbl, False, False) # Buttons box bbox = gtk.HButtonBox() bbox.set_layout(gtk.BUTTONBOX_END) bbox.show() # Cancel Button cancel = gtk.Button(gtk.STOCK_CANCEL) cancel.set_use_stock(True) cancel.show() self.__cancel = cancel bbox.add(cancel) main.add(bbox) # Close button, which is hidden by default close = gtk.Button(gtk.STOCK_CLOSE) close.set_use_stock(True) close.hide() bbox.add(close) self.__close = close
def set_widget_gravity(widget, gravity=(0, 0, 0, 0), paddings=(0, 0, 0, 0)): align = gtk.Alignment() align.set(*gravity) align.set_padding(*paddings) align.add(widget) return align
def __init__(self, appInfo, switchStatus, downloadQueue, entryDetailCallback, sendVoteCallback, index, getSelectIndex, setSelectIndex, selectPkgCallback, unselectPkgCallback, getSelectStatusCallback, addIgnorePkgCallback): '''Init for application item.''' DownloadItem.__init__(self, appInfo, switchStatus, downloadQueue) self.appInfo = appInfo self.entryDetailCallback = entryDetailCallback self.sendVoteCallback = sendVoteCallback self.selectPkgCallback = selectPkgCallback self.unselectPkgCallback = unselectPkgCallback self.getSelectStatusCallback = getSelectStatusCallback self.addIgnorePkgCallback = addIgnorePkgCallback self.checkButton = None self.index = index self.setSelectIndex = setSelectIndex # Widget that status will change. self.upgradingProgressbar = None self.upgradingFeedbackLabel = None # Init. self.itemBox = gtk.HBox() self.itemEventBox = gtk.EventBox() self.itemEventBox.connect("button-press-event", self.clickItem) self.itemEventBox.add(self.itemBox) drawListItem(self.itemEventBox, index, getSelectIndex) self.itemFrame = gtk.Alignment() self.itemFrame.set(0.0, 0.5, 1.0, 1.0) self.itemFrame.add(self.itemEventBox) # Add check box. checkPaddingLeft = 20 checkPaddingRight = 15 checkPaddingY = 10 self.checkButton = gtk.CheckButton() self.checkButton.set_active( self.getSelectStatusCallback(utils.getPkgName(self.appInfo.pkg))) self.checkButton.connect("toggled", lambda w: self.toggleSelectStatus()) checkButtonSetBackground( self.checkButton, False, False, "cell/select.png", "cell/selected.png", ) self.checkAlign = gtk.Alignment() self.checkAlign.set(0.5, 0.5, 0.0, 0.0) self.checkAlign.set_padding(checkPaddingY, checkPaddingY, checkPaddingLeft, checkPaddingRight) self.checkAlign.add(self.checkButton) self.itemBox.pack_start(self.checkAlign, False, False) self.appBasicView = AppBasicView(self.appInfo, 300 + APP_BASIC_WIDTH_ADJUST, self.itemBox, self.entryDetailView) self.itemBox.pack_start(self.appBasicView.align, True, True) self.appAdditionBox = gtk.HBox() self.appAdditionAlign = gtk.Alignment() self.appAdditionAlign.set(1.0, 0.5, 0.0, 0.0) self.appAdditionAlign.add(self.appAdditionBox) self.itemBox.pack_start(self.appAdditionAlign, False, False) self.initAdditionStatus() self.itemFrame.show_all()
def __init__(self, filename=""): ''' init share @param filename: the file to share ''' self.upload_image = filename self.thumb_width = 188 self.thumb_height = 168 self.MAX_CHAR = 140 #self.__text_frame_color = (0.76, 0.76, 0.76) self.__win_width = 602 open(COOKIE_FILE,'wb').close() self.window = DialogBox(_("share to web"), close_callback=gtk.main_quit) self.window.set_keep_above(True) self.window.set_size_request(self.__win_width+20, 288) self.window.set_resizable(False) self.window.titlebar.connect("expose-event", self.__expose_top_and_bottome) self.window.button_box.connect("expose-event", self.__expose_top_and_bottome) # create slider self.slider = HSlider() self.slider_list = [] self.share_box = gtk.VBox(False, 2) # first page, input context self.web_box = gtk.VBox(False, 10) # second page, login self.result_box = gtk.VBox(False, 10) # third page, share result share_align = gtk.Alignment() share_align.set(0.5, 0.5, 0, 0) share_align.add(self.share_box) share_align.connect("expose-event", self.__slider_expose) # go back button web_left_button = ImageButton( app_theme.get_pixbuf("share/back_normal.png"), app_theme.get_pixbuf("share/back_hover.png"), app_theme.get_pixbuf("share/back_press.png")) web_left_button.connect("clicked", lambda w: self.set_slide_index(0)) web_left_button.set_can_focus(False) utils.set_clickable_cursor(web_left_button) # show url entry self.web_url_entry = InputEntry() self.web_url_entry.set_editable(False) self.web_url_entry.set_size(555, 20) self.web_url_entry.entry.right_menu_visible_flag = False # alig url entry web_navigate_vbox = gtk.VBox(False) web_navigate_vbox.pack_start(self.web_url_entry) web_navigate_t_align = gtk.Alignment() web_navigate_t_align.set(0.0, 0.5, 0, 0) web_navigate_t_align.add(web_navigate_vbox) # pack back button and url entry web_navigate_box = gtk.HBox(False, 7) web_navigate_box.pack_start(web_left_button, False, False) web_navigate_box.pack_start(web_navigate_t_align) web_navigate_align = gtk.Alignment() web_navigate_align.set(0.5, 0.5, 0, 0) web_navigate_align.set_padding(4, 0, 11, 13) web_navigate_align.add(web_navigate_box) # create a webkit self.web_view = WebView(COOKIE_FILE) self.web_view.connect("notify::load-status", self.web_view_load_status) self.web_view.connect("load-error", self.web_view_load_error) self.web_scrolled_window = ScrolledWindow() self.web_scrolled_window.add(self.web_view) self.web_scrolled_window.set_size_request(590, 228) self.web_box.pack_start(web_navigate_align, False, False) self.web_box.pack_start(self.web_scrolled_window) #self.web_box.set_size_request(-1, 258) web_align = gtk.Alignment() web_align.set(0.5, 0.0, 0, 1) web_align.add(self.web_box) web_align.connect("expose-event", self.__slider_expose) res_align = gtk.Alignment() res_align.set(0.5, 0.5, 0, 0) res_align.add(self.result_box) res_align.connect("expose-event", self.__slider_expose) self.slider.set_to_page(share_align) self.slider_list.append(share_align) self.slider_list.append(web_align) self.slider_list.append(res_align) self.__weibo_list = [] self.sina = weibo.Sina(self.web_view) self.qq = weibo.Tencent(self.web_view) self.__weibo_list.append(self.sina) self.__weibo_list.append(self.qq) if default_locale != 'zh_CN': self.twitter = weibo.Twitter(self.web_view) self.__weibo_list.append(self.twitter) self.__current_weibo = None self.window.body_box.pack_start(self.slider, True, True) self.init_share_box()
def create_upper_align(paddings=None): align = gtk.Alignment() if paddings: align.set_padding(*paddings) align.set(1, 0, 0, 0) return align
def mpd_tab(self, cbs=None): """Construct and layout the MPD tab""" mpdlabel = ui.label(markup='<b>' + _('MPD Connection') + '</b>') frame = gtk.Frame() frame.set_label_widget(mpdlabel) frame.set_shadow_type(gtk.SHADOW_NONE) controlbox = gtk.HBox() profiles = ui.combo() add_profile = ui.button(img=ui.image(stock=gtk.STOCK_ADD)) remove_profile = ui.button(img=ui.image(stock=gtk.STOCK_REMOVE)) self._populate_profile_combo(profiles, self.config.profile_num, remove_profile) controlbox.pack_start(profiles, False, False, 2) controlbox.pack_start(remove_profile, False, False, 2) controlbox.pack_start(add_profile, False, False, 2) namelabel = ui.label(textmn=_("_Name:")) nameentry = ui.entry() namelabel.set_mnemonic_widget(nameentry) hostlabel = ui.label(textmn=_("_Host:")) hostentry = ui.entry() hostlabel.set_mnemonic_widget(hostentry) portlabel = ui.label(textmn=_("_Port:")) portentry = gtk.SpinButton(gtk.Adjustment(0, 0, 65535, 1), 1) portentry.set_numeric(True) portlabel.set_mnemonic_widget(portentry) dirlabel = ui.label(textmn=_("_Music dir:")) direntry = gtk.FileChooserButton(_('Select a Music Directory')) self.direntry = direntry direntry.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER) direntry.connect('selection-changed', self._direntry_changed, profiles) dirlabel.set_mnemonic_widget(direntry) passwordlabel = ui.label(textmn=_("Pa_ssword:")) passwordentry = ui.entry(password=True) passwordlabel.set_mnemonic_widget(passwordentry) passwordentry.set_tooltip_text( _("Leave blank if no password is required.")) autoconnect = gtk.CheckButton(_("_Autoconnect on start")) autoconnect.set_active(self.config.autoconnect) autoconnect.connect('toggled', self._config_widget_active, 'autoconnect') # Fill in entries with current profile: self._profile_chosen(profiles, nameentry, hostentry, portentry, passwordentry, direntry) # Update display if $MPD_HOST or $MPD_PORT is set: host, port, password = misc.mpd_env_vars() if host or port: self.using_mpd_env_vars = True if not host: host = "" if not port: port = 0 if not password: password = "" hostentry.set_text(str(host)) portentry.set_value(port) passwordentry.set_text(str(password)) nameentry.set_text(_("Using MPD_HOST/PORT")) for widget in [ hostentry, portentry, passwordentry, nameentry, profiles, add_profile, remove_profile ]: widget.set_sensitive(False) else: self.using_mpd_env_vars = False nameentry.connect('changed', self._nameentry_changed, profiles, remove_profile) hostentry.connect('changed', self._hostentry_changed, profiles) portentry.connect('value-changed', self._portentry_changed, profiles) passwordentry.connect('changed', self._passwordentry_changed, profiles) profiles.connect('changed', self._profile_chosen, nameentry, hostentry, portentry, passwordentry, direntry) add_profile.connect('clicked', self._add_profile, nameentry, profiles, remove_profile) remove_profile.connect('clicked', self._remove_profile, profiles, remove_profile) rows = [(namelabel, nameentry), (hostlabel, hostentry), (portlabel, portentry), (passwordlabel, passwordentry), (dirlabel, direntry)] connection_table = gtk.Table(len(rows), 2) connection_table.set_col_spacings(12) for i, (label, entry) in enumerate(rows): connection_table.attach(label, 0, 1, i, i + 1, gtk.FILL, gtk.FILL) connection_table.attach(entry, 1, 2, i, i + 1, gtk.FILL | gtk.EXPAND, gtk.FILL) connection_alignment = gtk.Alignment(0.5, 0.5, 1.0, 1.0) connection_alignment.set_padding(12, 12, 12, 12) connection_alignment.add(connection_table) connection_frame = gtk.Frame() connection_frame.set_label_widget(controlbox) connection_frame.add(connection_alignment) table = gtk.Table(2, 1) table.set_row_spacings(12) table.attach(connection_frame, 0, 1, 0, 1, gtk.FILL | gtk.EXPAND, gtk.FILL) table.attach(autoconnect, 0, 1, 1, 2, gtk.FILL | gtk.EXPAND, gtk.FILL) alignment = gtk.Alignment(0.5, 0.5, 1.0, 1.0) alignment.set_padding(12, 0, 12, 0) alignment.add(table) frame.add(alignment) tab = gtk.Alignment(0.5, 0.5, 1.0, 1.0) tab.set_padding(12, 12, 12, 12) tab.add(frame) return tab
def extras_tab(self, cbs): """Construct and layout the extras tab""" if not self.scrobbler.imported(): self.config.as_enabled = False extraslabel = ui.label(markup='<b>' + _('Extras') + '</b>') frame = gtk.Frame() frame.set_label_widget(extraslabel) frame.set_shadow_type(gtk.SHADOW_NONE) as_checkbox = gtk.CheckButton(_("_Audioscrobbling (Last.fm)")) as_checkbox.set_active(self.config.as_enabled) as_user_label = ui.label(textmn=_("_Username:"******"_Password:"******"Popup _notification on song changes")) display_notification.set_active(self.config.show_notification) time_names = [ "%s %s" % (i, gettext.ngettext('second', 'seconds', int(i))) for i in cbs.popuptimes if i != _('Entire song') ] time_names.append(_('Entire song')) notification_options = ui.combo(items=time_names, active=self.config.popup_option, changed_cb=self._notiftime_changed) notification_locs = ui.combo( items=cbs.popuplocations, active=self.config.traytips_notifications_location, changed_cb=self._notiflocation_changed) notifhbox = gtk.HBox(spacing=6) notifhbox.pack_end(notification_locs, False, False) notifhbox.pack_end(notification_options, False, False) display_notification.connect('toggled', cbs.notif_toggled, notifhbox) if not self.config.show_notification: notifhbox.set_sensitive(False) crossfadespin = gtk.SpinButton() crossfadespin.set_range(1, 30) crossfadespin.set_value(self.config.xfade) crossfadespin.set_numeric(True) crossfadespin.set_increments(1, 5) crossfadespin.connect('value-changed', cbs.crossfade_changed) crossfadelabel2 = ui.label(textmn=_("_Fade length:")) crossfadelabel2.set_mnemonic_widget(crossfadespin) crossfadelabel3 = ui.label(text=_("sec")) crossfadebox = gtk.HBox(spacing=12) crossfadebox.pack_end(crossfadelabel3, False, False) crossfadebox.pack_end(crossfadespin, False, False) crossfadebox.pack_end(crossfadelabel2, False, False) crossfadecheck = gtk.CheckButton(_("C_rossfade")) crossfadecheck.connect('toggled', self._crossfadecheck_toggled, crossfadespin, crossfadelabel2, crossfadelabel3) crossfadecheck.connect('toggled', cbs.crossfade_toggled, crossfadespin) crossfadecheck.set_active(self.config.xfade_enabled) crossfadecheck.toggled() # Force the toggled callback widgets = (as_checkbox, as_entries, display_notification, notifhbox, crossfadecheck, crossfadebox) table = gtk.Table(len(widgets), 1) table.set_col_spacings(12) table.set_row_spacings(6) for i, widget in enumerate(widgets): table.attach(widget, 0, 1, i, i + 1, gtk.FILL | gtk.EXPAND, gtk.FILL) alignment = gtk.Alignment(0.5, 0.5, 1.0, 1.0) alignment.set_padding(12, 0, 12, 0) alignment.add(table) frame.add(alignment) tab = gtk.Alignment(0.5, 0.5, 1.0, 1.0) tab.set_padding(12, 12, 12, 12) tab.add(frame) as_checkbox.connect('toggled', self._as_enabled_toggled, as_user_entry, as_pass_entry, as_user_label, as_pass_label) if not self.config.as_enabled or not self.scrobbler.imported(): for widget in (as_user_entry, as_pass_entry, as_user_label, as_pass_label): widget.set_sensitive(False) return tab
def __init__(self, appInfo, switchStatus, downloadQueue, entryDetailCallback, index, getSelectIndex, setSelectIndex, launchApplicationCallback): '''Init for application item.''' DownloadItem.__init__(self, appInfo, switchStatus, downloadQueue) self.appInfo = appInfo self.entryDetailCallback = entryDetailCallback self.index = index self.setSelectIndex = setSelectIndex self.launchApplicationCallback = launchApplicationCallback # Widget that status will change. self.installingProgressbar = None self.installingFeedbackLabel = None self.upgradingProgressbar = None self.upgradingFeedbackLabel = None # Init. itemPaddingX = 3 self.itemBox = gtk.HBox() self.itemAlign = gtk.Alignment() self.itemAlign.set(0.5, 0.5, 0.0, 0.0) self.itemAlign.set_padding(0, 0, itemPaddingX, itemPaddingX) self.itemAlign.add(self.itemBox) self.itemEventBox = gtk.EventBox() self.itemEventBox.connect("button-press-event", lambda w, e: clickItem(w, e, entryDetailCallback, appInfo)) drawRecommendItem(self.itemEventBox, index, getSelectIndex) self.itemFrame = gtk.Alignment() self.itemFrame.set(0.0, 0.5, 0.0, 0.0) self.appLeftBox = gtk.VBox() self.appLeftAlign = gtk.Alignment() self.appLeftAlign.set(0.0, 0.5, 0.0, 0.0) self.appLeftAlign.add(self.appLeftBox) self.itemBox.pack_start(self.appLeftAlign) self.appBasicView = gtk.HBox() self.appLeftBox.pack_start(self.appBasicView, False, False) self.appIconBox = gtk.VBox() self.appBasicView.pack_start(self.appIconBox, False, False) self.appAdditionBox = gtk.VBox() self.appAdditionAlign = gtk.Alignment() self.appAdditionAlign.set(0.5, 0.5, 0.0, 0.0) self.appAdditionAlign.add(self.appAdditionBox) self.appBasicView.pack_start(self.appAdditionAlign, False, False) self.appTopBox = gtk.HBox() self.appAdditionBox.pack_start(self.appTopBox, False, False) self.appNameBox = gtk.VBox() self.appTopBox.pack_start(self.appNameBox, False, False) self.appFeedbackBox = gtk.VBox() self.appTopBox.pack_start(self.appFeedbackBox, False, False) self.appStatusBox = gtk.VBox() self.appAdditionBox.pack_start(self.appStatusBox, False, False) self.appSummaryBox = gtk.VBox() self.appActionBox = gtk.VBox() self.appActionBox.set_size_request(self.ACTION_WIDTH, -1) self.appActionAlign = gtk.Alignment() self.appActionAlign.set(0.5, 0.5, 0.0, 0.0) self.appActionAlign.add(self.appActionBox) self.itemBox.pack_start(self.appActionAlign, False, False) self.initBasicBox() self.initAdditionStatus() self.itemEventBox.add(self.itemAlign) self.itemFrame.add(self.itemEventBox) self.itemFrame.show_all()
def createRecommendList(self, itemName, showMore, appList): '''Create recommend list.''' # Init. alignX = 4 alignY = 10 box = gtk.VBox() boxAlign = gtk.Alignment() boxAlign.set_padding(0, alignY, alignX, alignX) boxAlign.add(box) recommendNum = 5 # default is 5 recommendIndex = 0 # Add category name. nameBox = gtk.EventBox() nameBox.set_visible_window(False) drawTitlebar(nameBox) box.pack_start(nameBox, False, False) nameLabelBox = gtk.HBox() nameBox.add(nameLabelBox) nameLabelPaddingLeft = 20 nameLabelAlign = gtk.Alignment() nameDLabel = DynamicSimpleLabel( nameLabelAlign, itemName, appTheme.getDynamicColor("recommendTitle"), LABEL_FONT_LARGE_SIZE, ) nameLabel = nameDLabel.getLabel() nameLabelAlign.set(0.0, 0.5, 0.0, 0.0) nameLabelAlign.set_padding(0, 0, nameLabelPaddingLeft, 0) nameLabelAlign.add(nameLabel) nameLabelBox.pack_start(nameLabelAlign) # Show more label. if showMore: (moreLabel, moreLabelEventBox) = setDefaultClickableDynamicLabel( __("More >>"), "recommendMore", LABEL_FONT_MEDIUM_SIZE, ) moreLabelPaddingRight = 15 moreLabelAlign = gtk.Alignment() moreLabelAlign.set(1.0, 0.5, 0.0, 0.0) moreLabelAlign.set_padding(0, 0, 0, moreLabelPaddingRight) moreLabelAlign.add(moreLabelEventBox) nameLabelBox.pack_start(moreLabelAlign) # Switch to repository page and select category. categoryIndex = (map (lambda (k, _): k, CLASSIFY_LIST)).index(itemName) moreLabelEventBox.connect( "button-press-event", lambda w, e: self.selectCategoryCallback(itemName, categoryIndex)) # Content box. contentBox = gtk.HBox() box.pack_start(contentBox, False, False) leftLine = gtk.Image() drawLine(leftLine, appTheme.getDynamicColor("recommendFrame"), 1, True, LINE_LEFT) contentBox.pack_start(leftLine, False, False) middleBox = gtk.VBox() contentBox.pack_start(middleBox, False, False) rightLine = gtk.Image() drawLine(rightLine, appTheme.getDynamicColor("recommendFrame"), 1, True, LINE_RIGHT) contentBox.pack_start(rightLine, False, False) # Add application information's. for appName in appList: # You can set appList longer than 5, but those code just use first 5 that exist in local cache. # Longer list for protected software center won't crash if some package not exist in local cache. if recommendIndex < recommendNum and self.repoCache.cache.has_key(appName): appInfo = self.repoCache.cache[appName] recommendItem = RecommendItem( appInfo, self.switchStatus, self.downloadQueue, self.entryDetailCallback, self.ticker, self.getSelectIndex, self.setSelectIndex, self.launchApplicationCallback) self.ticker = self.ticker + 1 middleBox.pack_start(recommendItem.itemFrame) self.itemDict[appName] = recommendItem recommendIndex += 1 else: print "%s not in repoCache, skip it." % (appName) # Bottom line. bottomLine = gtk.Image() drawLine(bottomLine, appTheme.getDynamicColor("recommendFrame"), 1, False, LINE_BOTTOM) box.pack_start(bottomLine, False, False) return boxAlign
def initDownloadPauseStatus(self): '''Init download pause status.''' # Clean summary box first. utils.containerRemoveAll(self.appStatusBox) # Create status box. statusPaddingY = 5 statusBox = gtk.HBox() statusAlign = gtk.Alignment() statusAlign.set(0.0, 0.5, 0.0, 0.0) statusAlign.set_padding(statusPaddingY, 0, 0, 0) statusAlign.add(statusBox) self.appStatusBox.pack_start(statusAlign) # Add progressbar. progress = self.appInfo.downloadingProgress progressbar = drawProgressbar(self.PROGRESS_WIDTH) progressbar.setProgress(progress) statusBox.pack_start(progressbar.box) self.downloadingProgressbar = progressbar # Add action box. utils.containerRemoveAll(self.appActionBox) actionBox = gtk.VBox() actionAlign = gtk.Alignment() actionAlign.set(0.5, 0.5, 0.0, 0.0) actionAlign.add(actionBox) self.appActionBox.pack_start(actionAlign) # Add pause icon. buttonPaddingY = 8 buttonBox = gtk.HBox() buttonAlign = gtk.Alignment() buttonAlign.set(0.5, 0.0, 0.0, 0.0) buttonAlign.set_padding(buttonPaddingY, 0, 0, 0) buttonAlign.add(buttonBox) actionBox.pack_start(buttonAlign, False, False) continueIcon = gtk.Button() drawSimpleButton(continueIcon, "continue") continueIcon.connect("button-release-event", lambda widget, event: self.switchToDownloading()) buttonBox.pack_start(continueIcon, False, False, self.BUTTON_PADDING_X) # Add stop icon. stopIcon = gtk.Button() drawSimpleButton(stopIcon, "stop") stopIcon.connect("button-release-event", lambda widget, event: self.switchToNormal()) buttonBox.pack_start(stopIcon, False, False, self.BUTTON_PADDING_X) # Add feedback label. feedbackPaddingY = 5 feedbackLabel = gtk.Label() feedbackLabel.set_markup("<span size='%s'>%s</span>" % (LABEL_FONT_SIZE, self.appInfo.downloadingFeedback)) feedbackLabel.set_size_request(self.STATUS_WIDTH, -1) feedbackAlign = gtk.Alignment() feedbackAlign.set(1.0, 0.0, 0.0, 0.0) feedbackAlign.set_padding(feedbackPaddingY, 0, 0, 0) feedbackAlign.add(feedbackLabel) self.downloadingFeedbackLabel = feedbackLabel actionBox.pack_start(feedbackAlign)
# Init application. application = Application() # Set application default size. application.set_default_size(DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT) # Set application icon. application.set_icon(os.path.join(get_current_dir(__file__), "icon.ico")) # Set application preview pixbuf. application.set_skin_preview(os.path.join(get_current_dir(__file__), "frame.png")) # Add titlebar. application.add_titlebar( ["theme", "max", "min", "close"], os.path.join(get_current_dir(__file__), "logo.png"), "DateTime demo", "DateTime demo", ) datetime = DateTimeHTCStyle(sec_visible = True) datetime.set_is_24hour(False) #datetime = DateTime() align = gtk.Alignment() align.set(0, 0, 0, 0) align.set_padding(10, 10, 10, 10) align.add(datetime) application.main_box.pack_start(align) application.run()
def __init__(self, param, scope=None, name=None, ident=None): debug.mainthreadTest() self.ident = ident or param.ident self.lastFile = {} # last file selected in each directory self.fileNames = [] # files in the current directory self.dirHier = [] # directories in the current hierarchy self.dirHistory = ringbuffer.RingBuffer(50) parameterwidgets.ParameterWidget.__init__(self, gtk.Frame(), scope, name, expandable=True) vbox = gtk.VBox() self.gtk.add(vbox) # Directory selector hbox = gtk.HBox() vbox.pack_start(hbox, expand=False, fill=False) hbox.pack_start(gtk.Label("Directory:"), expand=False, fill=False) self.dirWidget = chooser.ChooserComboWidget([], callback=self.dirChangedCB, name="Directory") hbox.pack_start(self.dirWidget.gtk, expand=True, fill=True) # Directory selection buttons hbox = gtk.HBox(homogeneous=False) vbox.pack_start(hbox, expand=False, fill=False) self.backbutton = gtkutils.StockButton(gtk.STOCK_GO_BACK, "Back", align=0.0) gtklogger.setWidgetName(self.backbutton, "Back") gtklogger.connect(self.backbutton, 'clicked', self.backCB) hbox.pack_start(self.backbutton, expand=True, fill=True) self.addDirButtons(hbox) homebutton = gtkutils.StockButton(gtk.STOCK_HOME) gtklogger.setWidgetName(homebutton, "Home") gtklogger.connect(homebutton, 'clicked', self.homeCB) hbox.pack_start(homebutton, expand=False, fill=True) self.nextbutton = gtkutils.StockButton(gtk.STOCK_GO_FORWARD, "Next", reverse=True, align=1.0) gtklogger.setWidgetName(self.nextbutton, "Next") gtklogger.connect(self.nextbutton, 'clicked', self.nextCB) hbox.pack_start(self.nextbutton, expand=True, fill=True) # File list self.fileList = chooser.ScrolledChooserListWidget( name="FileList", callback=self.fileListCB, dbcallback=self.fileListDoubleCB, markup=True) self.fileList.gtk.set_size_request(-1, 100) vbox.pack_start(self.fileList.gtk, expand=True, fill=True) # Set the comparison function used when typing in the file # list. _filename_cmp matches the beginnings of file names, # ignoring the markup added to directories and escaped # characters. if use_markup: self.fileList.treeview.set_search_equal_func(_filename_cmp, None) align = gtk.Alignment(xalign=1.0) vbox.pack_start(align, expand=False, fill=False) hbox = gtk.HBox() align.add(hbox) hbox.pack_start(gtk.Label("show hidden files"), expand=False, fill=False) self.hiddenButton = gtk.CheckButton() hbox.pack_start(self.hiddenButton, expand=False, fill=False) gtklogger.setWidgetName(self.hiddenButton, "ShowHidden") gtklogger.connect(self.hiddenButton, 'clicked', self.showHiddenCB) # Include additional widgets required by subclasses. self.addMoreWidgets(vbox) # Set initial state. if param.value is not None: directory, phile = os.path.split(param.value) # param.value might not have a directory component, # especially if the last value was set by a script or # command line argument. if not directory or not os.path.isdir(directory): directory = _last_dir.get(self.ident, os.path.abspath(os.getcwd())) else: directory = _last_dir.get(self.ident, os.path.abspath(os.getcwd())) phile = _last_file.get(self.ident, None) self.hiddenButton.set_active(_last_hid.get(self.ident, False)) directory = endSlash(directory) self.lastFile[directory] = phile self.dirHistory.push(directory) self.dirWidget.suppress_signals() self.dirHier = getDirectoryHierarchy(directory) self.dirWidget.update(self.dirHier) self.dirWidget.set_state(directory) self.dirWidget.allow_signals() self.fileList.suppress_signals() self.updateFiles(directory) if phile: self.fileList.set_selection(phile) self.fileList.allow_signals() self.initializeExtras(directory, phile) self.sensitize() self.widgetChanged(self.checkValidity(), interactive=False)
def init_share_box(self): '''get weibo info, and create button''' self.to_share_weibo = {} self.to_share_weibo_res = {} self.deepin_info = {} self.is_get_user_info = {} self.__weibo_check_button_list = [] self.__weibo_image_button_list = [] # create Thumbnail if exists(self.upload_image): pixbuf = gtk.gdk.pixbuf_new_from_file(self.upload_image) pix_w = pixbuf.get_width() pix_h = pixbuf.get_height() if pix_w > pix_h: pix_s_w = self.thumb_width pix_s_h = int(pix_h / (float(pix_w) / self.thumb_width)) else: pix_s_h = self.thumb_height pix_s_w = int(pix_w / (float(pix_h) / self.thumb_height)) pixbuf = pixbuf.scale_simple(pix_s_w, pix_s_h, gtk.gdk.INTERP_TILES) thumb = gtk.image_new_from_pixbuf(pixbuf) else: thumb = gtk.Image() thumb.set_size_request(self.thumb_width, self.thumb_height) # weibo context input text_box = gtk.HBox(False, 2) text_vbox = gtk.VBox(False, 2) text_bg_vbox = gtk.VBox(False) text_bg_align = gtk.Alignment() text_bg_align.set(0.5, 0.5, 0, 0) text_bg_align.set_padding(5, 5, 16, 5) text_bg_align.connect("expose-event", self.text_view_bg_expose) text_scrolled_win = ScrolledWindow() text_scrolled_win.set_size_request(340, 157) text_view = gtk.TextView() text_view.set_left_margin(10) text_view.set_right_margin(10) text_view.set_pixels_above_lines(5) text_view.set_pixels_below_lines(5) text_view.set_wrap_mode(gtk.WRAP_WORD| gtk.WRAP_CHAR) text_view.connect("expose-event", self.text_view_expose) buf = text_view.get_buffer() text_scrolled_win.add(text_view) text_bg_vbox.pack_start(text_scrolled_win) text_bg_align.add(text_bg_vbox) text_align = gtk.Alignment() text_align.set(0.5, 0.5, 0, 0) text_align.set_padding(25, 30, 10, 10) text_box.pack_start(thumb, False, False, 10) text_box.pack_start(text_bg_align) text_vbox.pack_start(text_box, False, False, 10) text_align.add(text_vbox) #tmp_align = gtk.Alignment() #tmp_align.set(0.5, 0, 0, 1) #self.share_box.pack_start(tmp_align, False, False) self.share_box.pack_start(text_align, False, False) # dialog button box left_box = self.window.left_button_box right_box = self.window.right_button_box # input tip label self.input_num_label = Label("%d" % self.MAX_CHAR, text_size=16, text_x_align=pango.ALIGN_CENTER, label_width=50, enable_select=False) self.input_num_label.text_color = app_theme.get_color("left_char_num") # login box #weibo_box = gtk.HBox(False, 1) #weibo_box.set_size_request(-1, 50) weibo_box_list = [] self.loading_label = Label("%s..." % _("loading"), text_size=12, label_width=70, enable_select=False) weibo_box_list.append(self.loading_label) for weibo in self.__weibo_list: box = gtk.HBox(False, 2) weibo.set_box(box) weibo_box_list.append(box) left_box.set_buttons(weibo_box_list) # share button button = Button(_("Tweet")) #button.set_size_request(75, 25) button.connect("clicked", self.share_button_clicked, text_view) buf.connect("changed", self.text_view_changed, button) # check char num tmp_vbox = gtk.VBox(False) tmp_align = gtk.Alignment() tmp_align.set(0.5, 0.5, 0, 0) tmp_vbox.pack_start(button, False, False) #tmp_vbox.pack_start(tmp_align) tmp_align.add(tmp_vbox) right_box.set_buttons([self.input_num_label, tmp_align]) # at first, set widget insensitive button.set_sensitive(False) text_view.set_editable(False) t = threading.Thread(target=self.init_user_info_thread, args=(button, text_view)) t.setDaemon(True) t.start()
def display_tab(self, cbs): """Construct and layout the display tab""" displaylabel = ui.label(markup='<b>' + _('Display') + '</b>') frame = gtk.Frame() frame.set_label_widget(displaylabel) frame.set_shadow_type(gtk.SHADOW_NONE) art = gtk.CheckButton(_("_Album art")) art.set_active(self.config.show_covers) stylized_combo = ui.combo(items=[_("Standard"), _("Stylized")], active=self.config.covers_type, changed_cb=cbs.stylized_toggled) stylized_hbox = gtk.HBox(spacing=12) stylized_hbox.pack_end(stylized_combo, False, False) stylized_hbox.pack_end(ui.label(text=_("Artwork style:")), False, False) stylized_hbox.set_sensitive(self.config.show_covers) art_combo = ui.combo(items=[_("Local only"), _("Local and remote")], active=self.config.covers_pref) art_combo.connect('changed', self._config_widget_active, 'covers_pref') orderart_label = ui.label(text=_("Search locations:")) art_hbox = gtk.HBox(spacing=12) art_hbox.pack_end(art_combo, False, False) art_hbox.pack_end(orderart_label, False, False) art_hbox.set_sensitive(self.config.show_covers) art_paths = ["~/.covers/"] art_paths += ("%s/%s" % (_("SONG_DIR"), item) for item in ("cover.jpg", "album.jpg", "folder.jpg", _("custom"))) art_location = ui.combo(items=art_paths, active=self.config.art_location, changed_cb=self._art_location_changed) art_location_hbox = gtk.HBox(spacing=12) art_location_hbox.pack_end(art_location, False, False) art_location_hbox.pack_end(ui.label(text=_("Save art to:")), False, False) art_location_hbox.set_sensitive(self.config.show_covers) art.connect('toggled', cbs.art_toggled, art_hbox, art_location_hbox, stylized_hbox) playback = gtk.CheckButton(_("_Playback/volume buttons")) playback.set_active(self.config.show_playback) playback.connect('toggled', cbs.playback_toggled) progress = gtk.CheckButton(_("Pr_ogressbar")) progress.set_active(self.config.show_progress) progress.connect('toggled', cbs.progress_toggled) statusbar = gtk.CheckButton(_("_Statusbar")) statusbar.set_active(self.config.show_statusbar) statusbar.connect('toggled', cbs.statusbar_toggled) lyrics = gtk.CheckButton(_("Song Ly_rics")) lyrics.set_active(self.config.show_lyrics) savelyrics_label = ui.label(text=_("Save lyrics to:"), x=1) lyrics_location = ui.combo(items=["~/.lyrics/", _("SONG_DIR") + "/"], active=self.config.lyrics_location, changed_cb=self._lyrics_location_changed) lyrics_location_hbox = gtk.HBox(spacing=12) lyrics_location_hbox.pack_end(lyrics_location, False, False) lyrics_location_hbox.pack_end(savelyrics_label, False, False) lyrics_location_hbox.set_sensitive(self.config.show_lyrics) lyrics.connect('toggled', cbs.lyrics_toggled, lyrics_location_hbox) trayicon = gtk.CheckButton(_("System _tray icon")) self.display_trayicon = trayicon trayicon.set_active(self.config.show_trayicon) trayicon.set_sensitive(cbs.trayicon_available) widgets = (playback, progress, statusbar, trayicon, lyrics, lyrics_location_hbox, art, stylized_hbox, art_hbox, art_location_hbox) table = gtk.Table(len(widgets), 1, False) for i, widget in enumerate(widgets): table.attach(widget, 0, 1, i, i + 1, gtk.FILL | gtk.EXPAND, gtk.FILL) alignment = gtk.Alignment(0.5, 0.5, 1.0, 1.0) alignment.set_padding(12, 0, 12, 0) alignment.add(table) frame.add(alignment) tab = gtk.Alignment(0.5, 0.5, 1.0, 1.0) tab.set_padding(12, 12, 12, 12) tab.add(frame) return tab
def share_to_weibo_result(self): '''result of share to weibo''' font_color = app_theme.get_color("share_result_text") res_hbox = gtk.HBox(False) res_hbox.set_size_request(-1, 240) res_left_box = DialogLeftButtonBox() res_right_box = DialogRightButtonBox() res_left_box.button_align.set(0.5, 0.0, 0, 1) res_right_box.button_align.set(0.5, 0.0, 0, 1) res_left_box.button_align.set_padding(5, 9, 19, 0) res_right_box.button_align.set_padding(30, 0, 0, 0) res_left_box.set_size_request(405, -1) res_right_box.set_size_request(195, -1) res_hbox.pack_start(res_left_box) res_hbox.pack_start( VSeparator(app_theme.get_shadow_color("VSeparator").get_color_info(), 0, 0)) res_hbox.pack_start(res_right_box) res_vbox = gtk.VBox(False) follow_vbox = gtk.VBox(False) tmp_img = gtk.Image() # only use as a placeholder tmp_img.set_size_request(-1, 50) res_vbox.pack_start(tmp_img, False, False) follow_tip_hbox = gtk.HBox(False) img = gtk.image_new_from_file(app_theme.get_theme_file_path("image/share/deepin_logo.png")) follow_tip_hbox.pack_start(img, False, False, 5) follow_tip_hbox.pack_start( Label("%s %s" % (_("Follow"), "Linux Deepin"), text_color=app_theme_get_dynamic_color("#5f5f5f"), text_size=12, enable_select=False), False, False) follow_vbox.pack_start(follow_tip_hbox, False, False, 13) for weibo in self.to_share_weibo_res: vbox = gtk.VBox(False, 1) tip_box = gtk.HBox() error_box = gtk.HBox() vbox.pack_start(tip_box, False, False) vbox.pack_start(error_box, False, False) if self.to_share_weibo_res[weibo][0]: # upload succeed img = gtk.image_new_from_file(app_theme.get_theme_file_path("image/share/share_succeed.png")) #link = LinkButton(_(weibo.t_type), text_size=13, self.to_share_weibo_res[weibo][1]) link = Label(_(weibo.t_type), text_size=12, text_color=app_theme.get_color("link_text")) #, enable_gaussian=True, gaussian_radious=1, border_radious=0) link.add_events(gtk.gdk.BUTTON_PRESS_MASK) link.connect("enter-notify-event", lambda w, e: self.__draw_under_line(w)) link.connect("leave-notify-event", lambda w, e: w.queue_draw()) link.connect("button-press-event", self.goto_weibo_button_clicked, weibo) link_box = gtk.HBox(False) link_box.pack_start(link, False, False) utils.set_clickable_cursor(link) text = _("upload to") label = Label(text, text_size=12, text_color=font_color, enable_select=False) text = _("successful") label1 = Label(text, text_size=12, text_color=font_color, enable_select=False) tip_box.pack_start(img, False, False, 15) tip_box.pack_start(label, False, False, 3) tip_box.pack_start(link_box, False, False, 3) tip_box.pack_start(label1, False, False) # only use as a placeholder img = gtk.Image() img.set_size_request(20, 1) error_box.pack_start(img, False, False, 16) tmp = Label(" ", text_size=9, label_width=200) tmp.set_size_request(200, 1) error_box.pack_start(tmp, False, False) #print text else: # upload failed img = gtk.image_new_from_file(app_theme.get_theme_file_path("image/share/share_failed.png")) #text = "% %s %s." % (_(weibo.t_type), _("upload failed")) text = _("upload to") label1 = Label(text, text_size=12, text_color=font_color, enable_select=False) label2 = Label(_(weibo.t_type), text_size=12, text_color=font_color, enable_select=False) text = _("failed") label3 = Label(text, text_size=12, text_color=font_color, enable_select=False) if weibo.curl.error: error = "(%s)" % _(weibo.curl.error) elif weibo.get_error_msg(): error = "(%s)" % _(weibo.get_error_msg()) else: error = "(%s)" % _("Unknow reason") #print "%s: %s" % (weibo.t_type, error) #print "%s: %s" % (weibo.t_type, weibo.get_error_msg()) label = Label(text, text_size=12, text_color=font_color, enable_select=False) tip_box.pack_start(img, False, False, 15) tip_box.pack_start(label1, False, False, 3) tip_box.pack_start(label2, False, False, 3) tip_box.pack_start(label3, False, False) img = gtk.Image() # only use as a placeholder img.set_size_request(20, 20) error_box.pack_start(img, False, False, 16) error_box.pack_start(Label(error, text_size=9, label_width=200, text_color=font_color, enable_select=False), False, False) #print text res_vbox.pack_start(vbox, False, False, 10) for weibo in self.deepin_info: box = gtk.HBox(False, 15) # followed img = gtk.image_new_from_pixbuf(app_theme.get_pixbuf("share/"+weibo.t_type+".png").get_pixbuf()) box.pack_start(img, False, False) if self.deepin_info[weibo] is not None and self.deepin_info[weibo][3]: if not default_locale.startswith("zh_"): button = gtk.image_new_from_pixbuf( app_theme.get_pixbuf("share/followed_en.png").get_pixbuf()) else: button = gtk.image_new_from_pixbuf( app_theme.get_pixbuf("share/followed.png").get_pixbuf()) else: # to follow if not default_locale.startswith("zh_"): button = ImageButton( app_theme.get_pixbuf("share/follow_normal_en.png"), app_theme.get_pixbuf("share/follow_hover_en.png"), app_theme.get_pixbuf("share/follow_press_en.png")) else: button = ImageButton( app_theme.get_pixbuf("share/follow_normal.png"), app_theme.get_pixbuf("share/follow_hover.png"), app_theme.get_pixbuf("share/follow_press.png")) button.connect("clicked", self.friendships_add_button_clicked, weibo, box) box.pack_start(button, False, False) align = gtk.Alignment() align.set(0.0, 0.5, 0, 0) align.set_padding(0, 0, 30, 0) align.add(box) follow_vbox.pack_start(align, False, False, 8) res_left_box.set_buttons([res_vbox]) res_right_box.set_buttons([follow_vbox]) self.result_box.pack_start(res_hbox, False, False) self.result_box.show_all() self.set_slide_index(2)
def behavior_tab(self, cbs): """Construct and layout the behavior tab""" windowlabel = ui.label(markup='<b>' + _('Window Behavior') + '</b>') frame = gtk.Frame() frame.set_label_widget(windowlabel) frame.set_shadow_type(gtk.SHADOW_NONE) sticky = gtk.CheckButton(_("_Show window on all workspaces")) sticky.set_active(self.config.sticky) sticky.connect('toggled', cbs.sticky_toggled) ontop = gtk.CheckButton(_("_Keep window above other windows")) ontop.set_active(self.config.ontop) ontop.connect('toggled', cbs.ontop_toggled) decor = gtk.CheckButton(_("_Hide window titlebar")) decor.set_active(not self.config.decorated) decor.connect('toggled', cbs.decorated_toggled, self.prefswindow) minimize = gtk.CheckButton( _("_Minimize to system tray on close/escape")) minimize.set_active(self.config.minimize_to_systray) minimize.set_tooltip_text( _("If enabled, closing Sonata will minimize it to the system tray. Note that it's currently impossible to detect if there actually is a system tray, so only check this if you have one." )) minimize.connect('toggled', self._config_widget_active, 'minimize_to_systray') self.display_trayicon.connect('toggled', cbs.trayicon_toggled, minimize) minimize.set_sensitive(cbs.trayicon_in_use) widgets = (sticky, ontop, decor, minimize) table = gtk.Table(len(widgets), 1) for i, widget in enumerate(widgets): table.attach(widget, 0, 1, i, i + 1, gtk.FILL | gtk.EXPAND, gtk.FILL) alignment = gtk.Alignment() alignment.set_padding(12, 0, 12, 0) alignment.add(table) frame.add(alignment) misclabel = ui.label(markup='<b>' + _('Miscellaneous') + '</b>') misc_frame = gtk.Frame() misc_frame.set_label_widget(misclabel) misc_frame.set_shadow_type(gtk.SHADOW_NONE) update_start = gtk.CheckButton(_("_Update MPD library on start")) update_start.set_active(self.config.update_on_start) update_start.set_tooltip_text( _("If enabled, Sonata will automatically update your MPD library when it starts up." )) update_start.connect('toggled', self._config_widget_active, 'update_on_start') exit_stop = gtk.CheckButton(_("S_top playback on exit")) exit_stop.set_active(self.config.stop_on_exit) exit_stop.set_tooltip_text( _("MPD allows playback even when the client is not open. If enabled, Sonata will behave like a more conventional music player and, instead, stop playback upon exit." )) exit_stop.connect('toggled', self._config_widget_active, 'stop_on_exit') infofile_usage = gtk.CheckButton(_("_Write status file:")) infofile_usage.set_active(self.config.use_infofile) infofile_usage.set_tooltip_text( _("If enabled, Sonata will create a xmms-infopipe like file containing information about the current song. Many applications support the xmms-info file (Instant Messengers, IRC Clients...)" )) infopath_options = ui.entry(text=self.config.infofile_path) infopath_options.set_tooltip_text( _("If enabled, Sonata will create a xmms-infopipe like file containing information about the current song. Many applications support the xmms-info file (Instant Messengers, IRC Clients...)" )) infopath_options.connect('focus_out_event', cbs.infofile_changed) infopath_options.connect('activate', cbs.infofile_changed, None) if not self.config.use_infofile: infopath_options.set_sensitive(False) infofile_usage.connect('toggled', self._infofile_toggled, infopath_options) infofilebox = gtk.HBox(spacing=6) infofilebox.pack_start(infofile_usage, False, False) infofilebox.pack_start(infopath_options, True, True) widgets = (update_start, exit_stop, infofilebox) misc_table = gtk.Table(len(widgets), 1) for i, widget in enumerate(widgets): misc_table.attach(widget, 0, 1, i, i + 1, gtk.FILL | gtk.EXPAND, gtk.FILL) misc_alignment = gtk.Alignment() misc_alignment.set_padding(12, 0, 12, 0) misc_alignment.add(misc_table) misc_frame.add(misc_alignment) table = gtk.Table(2, 1) table.set_row_spacings(12) table.attach(frame, 0, 1, 0, 1, gtk.FILL | gtk.EXPAND, gtk.FILL) table.attach(misc_frame, 0, 1, 1, 2, gtk.FILL | gtk.EXPAND, gtk.FILL) tab = gtk.Alignment() tab.set_padding(12, 12, 12, 12) tab.add(table) return tab
def create_right_align(paddings=None): align = gtk.Alignment() if paddings: align.set_padding(*paddings) align.set(0, 0, 0, 1) return align
def format_tab(self, cbs): """Construct and layout the format tab""" formatlabel = ui.label(markup='<b>' + _('Song Formatting') + '</b>') frame = gtk.Frame() frame.set_label_widget(formatlabel) frame.set_shadow_type(gtk.SHADOW_NONE) rows = [(_("C_urrent playlist:"), self.config.currentformat), (_("_Library:"), self.config.libraryformat), (_("_Window title:"), self.config.titleformat), (_("Current _song line 1:"), self.config.currsongformat1), (_("Current s_ong line 2:"), self.config.currsongformat2)] labels = [] entries = [] for label_text, entry_text in rows: label = ui.label(textmn=label_text) entry = ui.entry(text=entry_text) label.set_mnemonic_widget(entry) labels.append(label) entries.append(entry) entry_cbs = (cbs.currentoptions_changed, cbs.libraryoptions_changed, cbs.titleoptions_changed, cbs.currsongoptions1_changed, cbs.currsongoptions2_changed) for entry, cb, next in zip(entries, entry_cbs, entries[1:] + entries[:1]): entry.connect('focus_out_event', cb) entry.connect('activate', lambda _, n: n.grab_focus(), next) availableheading = ui.label(markup='<small>' + _('Available options') + ':</small>') availablevbox = gtk.VBox() availableformatbox = gtk.HBox() formatcodes = formatting.formatcodes for codes in [ formatcodes[:(len(formatcodes) + 1) / 2], formatcodes[(len(formatcodes) + 1) / 2:] ]: rows = '\n'.join('<tt>%%%s</tt> - %s' % (code.code, code.description) for code in codes) markup = '<small>' + rows + '</small>' formattinghelp = ui.label(markup=markup) availableformatbox.pack_start(formattinghelp) availablevbox.pack_start(availableformatbox, False, False, 0) additionalinfo = ui.label( markup='<small><tt>{ }</tt> - ' + _('Info displayed only if all enclosed tags are defined') + '\n<tt>|</tt> - ' + _('Creates columns in the current playlist') + '</small>') availablevbox.pack_start(additionalinfo, False, False, 4) num_rows = len(rows) + 2 table = gtk.Table(num_rows, 2) table.set_col_spacings(12) label_entries = enumerate(zip(labels, entries)) for i, (label, entry) in label_entries: table.attach(label, 0, 1, i, i + 1, gtk.FILL) table.attach(entry, 1, 2, i, i + 1) table.attach(availableheading, 0, 2, num_rows - 2, num_rows - 1, gtk.FILL | gtk.EXPAND, gtk.FILL | gtk.EXPAND, 0, 6) table.attach(availablevbox, 0, 2, num_rows - 1, num_rows) alignment = gtk.Alignment(0.5, 0.5, 1.0, 1.0) alignment.set_padding(12, 0, 12, 0) alignment.add(table) frame.add(alignment) tab = gtk.Alignment(0.5, 0.5, 1.0, 1.0) tab.set_padding(12, 12, 12, 12) tab.add(frame) return tab
def create_bottom_align(paddings=None): align = gtk.Alignment() if paddings: align.set_padding(paddings=None) align.set(0, 1, 0, 0) return align
def __init__(self, parent): gtk.Window.__init__(self) self.what = _('What is happening?') self.blocked = False self.mainwin = parent #self.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG) self.set_title(_('Update status')) self.set_resizable(False) #self.set_default_size(500, 120) self.set_size_request(500, 150) self.set_transient_for(parent) #self.set_modal(True) self.set_position(gtk.WIN_POS_CENTER_ON_PARENT) self.label = gtk.Label() self.label.set_use_markup(True) self.label.set_alignment(0, 0.5) self.label.set_markup('<span size="medium"><b>%s</b></span>' % self.what) self.label.set_justify(gtk.JUSTIFY_LEFT) self.num_chars = gtk.Label() self.num_chars.set_use_markup(True) self.num_chars.set_markup( '<span size="14000" foreground="#999"><b>140</b></span>') self.update_text = MessageTextView() self.update_text.set_border_width(2) self.update_text.set_left_margin(2) self.update_text.set_right_margin(2) self.update_text.set_wrap_mode(gtk.WRAP_WORD) buffer = self.update_text.get_buffer() scroll = gtk.ScrolledWindow() scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) scroll.set_shadow_type(gtk.SHADOW_IN) scroll.add(self.update_text) updatebox = gtk.HBox(False) updatebox.pack_start(scroll, True, True, 3) self.url = gtk.Entry() self.url.connect('changed', self.__on_url_changed) self.btn_url = gtk.Button(_('Shorten URL')) self.btn_url.set_tooltip_text(_('Shorten URL')) tools = gtk.HBox(False) tools.pack_start(self.url, True, True, 3) tools.pack_start(self.btn_url, False, False) self.toolbox = gtk.Expander() self.toolbox.set_label(_('Options')) self.toolbox.set_expanded(False) self.toolbox.add(tools) self.btn_clr = gtk.Button() self.btn_clr.set_image(self.mainwin.load_image('action-clear.png')) self.btn_clr.set_tooltip_text(_('Clear all') + ' (Ctrl+L)') self.btn_clr.set_relief(gtk.RELIEF_NONE) self.btn_frn = gtk.Button() self.btn_frn.set_image( self.mainwin.load_image('action-add-friends.png')) self.btn_frn.set_tooltip_text(_('Add friends') + ' (Ctrl+F)') self.btn_frn.set_relief(gtk.RELIEF_NONE) self.btn_upd = gtk.Button(_('Tweet')) self.btn_upd.set_tooltip_text(_('Update your status') + ' (Ctrl+T)') chk_short = gtk.CheckButton(_('Autoshort URLs')) chk_short.set_sensitive(False) top = gtk.HBox(False) top.pack_start(self.label, True, True, 5) top.pack_start(self.num_chars, False, False, 5) self.waiting = CairoWaiting(parent) self.lblerror = gtk.Label() self.lblerror.set_use_markup(True) error_align = gtk.Alignment(xalign=0.0) error_align.add(self.lblerror) buttonbox = gtk.HBox(False) #buttonbox.pack_start(chk_short, False, False, 0) buttonbox.pack_start(self.btn_frn, False, False, 0) buttonbox.pack_start(self.btn_clr, False, False, 0) buttonbox.pack_start(gtk.HSeparator(), False, False, 2) buttonbox.pack_start(self.btn_upd, False, False, 0) abuttonbox = gtk.Alignment(1, 0.5) abuttonbox.add(buttonbox) bottom = gtk.HBox(False) bottom.pack_start(self.waiting, False, False, 5) bottom.pack_start(error_align, True, True, 4) bottom.pack_start(abuttonbox, True, True, 5) vbox = gtk.VBox(False) vbox.pack_start(top, False, False, 2) vbox.pack_start(updatebox, True, True, 2) vbox.pack_start(bottom, False, False, 2) vbox.pack_start(self.toolbox, False, False, 2) self.add(vbox) self.connect('key-press-event', self.__detect_shortcut) self.connect('delete-event', self.__unclose) buffer.connect('changed', self.count_chars) self.btn_frn.connect('clicked', self.show_friend_dialog) self.btn_clr.connect('clicked', self.clear) self.btn_upd.connect('clicked', self.update) self.btn_url.connect('clicked', self.short_url) self.btn_url.set_sensitive(False) self.toolbox.connect('activate', self.show_options) self.update_text.connect('mykeypress', self.__on_key_pressed) if SPELLING: try: self.spell = gtkspell.Spell(self.update_text) except Exception, e_msg: # FIXME: Usar el log print 'DEBUG:UI:Can\'t load gtkspell -> %s' % e_msg
def show(self, scrollToTop=True): '''Show application view.''' # Remove child widgets first. utils.containerRemoveAll(self.box) self.itemDict.clear() # If i don't re-connect self.eventbox and self.box, # update view will show nothing. # I still can't understand why? # Maybe this is bug of GtkEventBox? utils.containerRemoveAll(self.eventbox) self.eventbox.add(self.box) if self.appNum == 0: if (getDefaultLanguage() == "default"): paddingX = 10 else: paddingX = 0 notifyBox = gtk.VBox() notifyAlign = gtk.Alignment() notifyAlign.set(0.5, 0.5, 0.0, 0.0) notifyAlign.add(notifyBox) self.box.pack_start(notifyAlign) tipImage = gtk.image_new_from_pixbuf( gtk.gdk.pixbuf_new_from_file("../icon/tips/%s/updateTip.png" % (getDefaultLanguage()))) tipAlign = gtk.Alignment() tipAlign.set_padding(0, 0, paddingX, 0) tipAlign.add(tipImage) notifyBox.pack_start(tipAlign) penguinImage = gtk.image_new_from_pixbuf( gtk.gdk.pixbuf_new_from_file("../icon/tips/penguin.png")) penguinAlign = gtk.Alignment() penguinAlign.set_padding(0, 0, 0, paddingX) penguinAlign.add(penguinImage) notifyBox.pack_start(penguinAlign) self.box.show_all() else: # Get application list. appList = self.getListFunc((self.pageIndex - 1) * self.defaultRows, min(self.pageIndex * self.defaultRows, self.appNum)) # Create application view. self.box.pack_start(self.createAppList(appList)) # Create index view. indexbar = self.createIndexbar() if not indexbar == None: self.box.pack_start(indexbar) self.box.show_all() # Request vote data. self.fetchVoteCallback( PAGE_UPGRADE, map(lambda appInfo: utils.getPkgName(appInfo.pkg), appList)) # Scroll ScrolledWindow to top after render. if scrollToTop: utils.scrollToTop(self.scrolledwindow)
#win = gtk.Window() #win.connect("destroy", gtk.main_quit) #win.set_size_request(400, 250) app = dtk.ui.application.Application() app.set_default_size(400, 250) app.add_titlebar( ["theme", "menu", "max", "min", "close"], None, "深度图形库", "/home/andy/deepin-ui/loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooony.py", ) slider = dtk.ui.slider.HSlider() label = dtk.ui.label.Label("Slider Demo") label_align = gtk.Alignment(0.5, 0.5, 0, 0) label_align.add(label) slider.to_page_now(label_align) widget1 = gtk.Alignment(0.5, 0.5, 0, 0) button1 = dtk.ui.button.Button() button1.set_size_request(200, 22) widget1.add(button1) widget2 = gtk.Alignment(0.5, 0.5, 0, 0) button2 = gtk.Button("Button2") widget2.add(button2) widget3 = gtk.Alignment(0.5, 0.5, 0, 0) text_entry = dtk.ui.entry.InputEntry() text_entry.set_size(100, 22)
def __init__(self, label=None): gtk.Frame.__init__(self) self.set_shadow_type(gtk.SHADOW_NONE) self._flabel = gtk.Label() self._set_label(label) self.set_label_widget(self._flabel) def _set_label(self, label): self._flabel.set_markup("<b>%s</b>" % label) # Demo if __name__ == "__main__": w = gtk.Window() hframe = HIGFrame("Sample HIGFrame") aalign = gtk.Alignment(0, 0, 0, 0) aalign.set_padding(12, 0, 24, 0) abox = gtk.VBox() aalign.add(abox) hframe.add(aalign) w.add(hframe) for i in xrange(5): abox.pack_start(gtk.Label("Sample %d" % i), False, False, 3) w.connect('destroy', lambda d: gtk.main_quit()) w.show_all() gtk.main()
def __adjust_widget(self): MID_SPACING = 10 self.alignment_widgets["main_hbox"].add( self.container_widgets["main_hbox"]) self.alignment_widgets["main_hbox"].set(0, 0, 1, 1) self.alignment_widgets["main_hbox"].set_padding( TEXT_WINDOW_TOP_PADDING - 25, 0, TEXT_WINDOW_LEFT_PADDING - 40, TEXT_WINDOW_RIGHT_WIDGET_PADDING) self.container_widgets["main_hbox"].set_spacing(MID_SPACING) self.container_widgets["main_hbox"].pack_start( self.container_widgets["left_vbox"]) #self.container_widgets["main_hbox"].pack_start(self.alignment_widgets["right_vbox"]) self.container_widgets["left_vbox"].pack_start( self.image_widgets["logo"], False, False) #self.container_widgets["left_vbox"].pack_start(self.alignment_widgets["logo"]) self.container_widgets["left_vbox"].pack_start( self.alignment_widgets["right_vbox"]) #self.alignment_widgets["logo"].set(0, 0, 1, 1) self.alignment_widgets["right_vbox"].set(0, 0, 1, 1) self.alignment_widgets["right_vbox"].set_padding(0, 0, 100, 0) self.alignment_widgets["right_vbox"].add( self.container_widgets["right_vbox"]) self.container_widgets["right_vbox"].set_spacing(BETWEEN_SPACING) self.container_widgets["right_vbox"].pack_start( self.container_widgets["info_vbox"], False, False) self.container_widgets["right_vbox"].pack_start( self.container_widgets["info_table"], False, False) self.container_widgets["right_vbox"].pack_start( gtk.Alignment(0, 0, 1, 1)) # #self.container_widgets["info_vbox"].pack_start( #self.__make_align(self.label_widgets["version"]), False, False) self.container_widgets["info_vbox"].pack_start( self.__make_align(self.label_widgets["copyright"]), False, False) label_widgets = self.label_widgets label_width = max(label_widgets["cpu"].size_request()[0], label_widgets["version"].size_request()[0], label_widgets["mem"].size_request()[0], label_widgets["arch"].size_request()[0], label_widgets["disk"].size_request()[0]) + 2 #label_widgets["cpu"].set_size_request(label_width, WIDGET_HEIGHT) #label_widgets["mem"].set_size_request(label_width, WIDGET_HEIGHT) #label_widgets["arch"].set_size_request(label_width, WIDGET_HEIGHT) #label_widgets["disk"].set_size_request(label_width, WIDGET_HEIGHT) # table attach self.container_widgets["info_table"].attach( self.__make_align(self.label_widgets['version'], width=label_width), 0, 1, 0, 1, 4) self.container_widgets["info_table"].attach( self.__make_align(self.label_widgets['cpu'], width=label_width), 0, 1, 1, 2, 4) self.container_widgets["info_table"].attach( self.__make_align(self.label_widgets['mem'], width=label_width), 0, 1, 2, 3, 4) self.container_widgets["info_table"].attach( self.__make_align(self.label_widgets['arch'], width=label_width), 0, 1, 3, 4, 4) self.container_widgets["info_table"].attach( self.__make_align(self.label_widgets['disk'], width=label_width), 0, 1, 4, 5, 4) self.container_widgets["info_table"].attach( self.__make_align(self.label_widgets['version_info']), 1, 2, 0, 1, 5) self.container_widgets["info_table"].attach( self.__make_align(self.label_widgets['cpu_info']), 1, 2, 1, 2, 5) self.container_widgets["info_table"].attach( self.__make_align(self.label_widgets['mem_info']), 1, 2, 2, 3, 5) self.container_widgets["info_table"].attach( self.__make_align(self.label_widgets['arch_info']), 1, 2, 3, 4, 5) self.container_widgets["info_table"].attach( self.__make_align(self.label_widgets['disk_info']), 1, 2, 4, 5, 5) self.container_widgets["info_table"].set_col_spacings(WIDGET_SPACING) # show sysinfo self.label_widgets["version_info"].set_text("%s" % settings.get_os_version()) self.label_widgets["cpu_info"].set_text("%s" % settings.get_cpu_info()) self.label_widgets["mem_info"].set_text("%.1fGB" % settings.get_mem_info()) self.label_widgets["arch_info"].set_text( "%s%s" % (settings.get_os_arch(), _("bit"))) disk_size = settings.get_disk_size() if disk_size: self.label_widgets["disk_info"].set_text("%.2fGB" % disk_size) else: self.label_widgets["disk_info"].set_text("--")
class ImagesDemo(gtk.Window): pixbuf_loader = None load_timeout = None image_stream = None 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.connect("destroy", self.cleanup_callback) self.set_title(self.__class__.__name__) self.set_border_width(8) vbox = gtk.VBox(False, 8) vbox.set_border_width(8) self.add(vbox) label = gtk.Label() label.set_markup("<u>Image loaded from a file</u>") vbox.pack_start(label, False, False, 0) frame = gtk.Frame() frame.set_shadow_type(gtk.SHADOW_IN) # The alignment keeps the frame from growing when users resize # the window align = gtk.Alignment(0.5, 0.5, 0, 0) align.add(frame) vbox.pack_start(align, False, False, 0) image = gtk.Image() # use the current directory for the file try: pixbuf = gtk.gdk.pixbuf_new_from_file(GTKLOGO_IMAGE) image.set_from_pixbuf(pixbuf) except gobject.GError, error: # This code shows off error handling. You can just use # gtk_image_new_from_file() instead if you don't want to report # errors to the user. If the file doesn't load when using # gtk_image_new_from_file(), a "missing image" icon will # be displayed instead. dialog = gtk.MessageDialog( self, gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, "Unable to open image file 'gtk-logo-rgb.gif': \n%s" % error) dialog.connect("response", lambda dlg, resp: dlg.destroy()) dialog.show() frame.add(image) # Animation label = gtk.Label() label.set_markup("<u>Animation loaded from a file</u>") vbox.pack_start(label, False, False, 0) frame = gtk.Frame() frame.set_shadow_type(gtk.SHADOW_IN) # The alignment keeps the frame from growing when users resize # the window align = gtk.Alignment(0.5, 0.5, 0, 0) align.add(frame) vbox.pack_start(align, False, False, 0) image = gtk.Image() image.set_from_file(BUDDY_IMAGE) frame.add(image) # Progressive label = gtk.Label() label.set_markup("<u>Progressive image loading</u>") vbox.pack_start(label, False, False, 0) frame = gtk.Frame() frame.set_shadow_type(gtk.SHADOW_IN) # The alignment keeps the frame from growing when users resize # the window align = gtk.Alignment(0.5, 0.5, 0, 0) align.add(frame) vbox.pack_start(align, False, False, 0) # Create an empty image for now; the progressive loader # will create the pixbuf and fill it in. image = gtk.Image() image.set_from_pixbuf(None) frame.add(image) self.start_progressive_loading(image) # Sensitivity control button = gtk.ToggleButton("_Insensitive") vbox.pack_start(button, False, False, 0) button.connect("toggled", self.on_sensitivity_toggled, vbox) self.show_all()
def get_user_info(self, weibo): '''get weibo user info''' info = weibo.get_user_name() gtk.gdk.threads_enter() #self.get_user_error_text = "" weibo_hbox = weibo.get_box() hbox = gtk.HBox(False) vbox = gtk.VBox(False) weibo_hbox.pack_start(vbox, False, False) vbox.pack_start(hbox) #print weibo.t_type, info if info: self.is_get_user_info[weibo] = 1 label = Label(text=info, label_width=70, enable_select=False) check = CheckButton() #check = gtk.CheckButton() check.connect("toggled", self.weibo_check_toggle, weibo) check.set_active(True) check_vbox = gtk.VBox(False) check_align = gtk.Alignment(0.5, 0.5, 0, 0) check_align.add(check_vbox) check_vbox.pack_start(check, False, False) button = ImageButton( app_theme.get_pixbuf("share/" + weibo.t_type + ".png"), app_theme.get_pixbuf("share/" + weibo.t_type + ".png"), app_theme.get_pixbuf("share/" + weibo.t_type + ".png")) utils.set_clickable_cursor(button) button.connect("enter-notify-event", self.show_tooltip, _("click to switch user")) hbox.pack_start(check_align, False, False) hbox.pack_start(button, False, False, 5) hbox.pack_start(label, False, False) else: self.is_get_user_info[weibo] = 0 check = CheckButton() #check = gtk.CheckButton() check.set_sensitive(False) check_vbox = gtk.VBox(False) check_align = gtk.Alignment(0.5, 0.5, 0, 0) check_align.add(check_vbox) check_vbox.pack_start(check, False, False) button = ImageButton( app_theme.get_pixbuf("share/" + weibo.t_type + "_no.png"), app_theme.get_pixbuf("share/" + weibo.t_type + "_no.png"), app_theme.get_pixbuf("share/" + weibo.t_type + "_no.png")) utils.set_clickable_cursor(button) button.connect("enter-notify-event", self.show_tooltip, _("click to login")) hbox.pack_start(check_align, False, False) hbox.pack_start(button, False, False, 5) # curl time out info_error = weibo.get_curl_error() if info_error: #self.get_user_error_text += "%s:%s." % (weibo.t_type, _(info_error)) hbox.pack_start( Label(text="(%s)" % _(info_error), label_width=70,enable_select=False, text_color = app_theme.get_color("left_char_num1")), False, False) button.connect("clicked", self.weibo_login, weibo) self.__weibo_check_button_list.append(check) self.__weibo_image_button_list.append(button) gtk.gdk.threads_leave() return weibo_hbox
def __init__(self, parent, application): SettingsPage.__init__(self, parent, application, 'view_and_edit', _('View & Edit')) # viewer options frame_view = gtk.Frame(_('View')) label_not_implemented = gtk.Label( 'This option is not implemented yet.') label_not_implemented.set_sensitive(False) # editor options frame_edit = gtk.Frame(_('Edit')) vbox_edit = gtk.VBox(False, 0) vbox_edit.set_border_width(5) # installed application self._radio_application = gtk.RadioButton( label=_('Use installed application')) self._radio_application.connect('toggled', self._parent.enable_save) align_application = gtk.Alignment(xscale=1) align_application.set_padding(0, 10, 15, 15) vbox_application = gtk.VBox(False, 0) vbox_application.set_border_width(5) self._store = gtk.ListStore(str, str, str) self._combobox_application = gtk.ComboBox(model=self._store) self._combobox_application.connect('changed', self._parent.enable_save) cell_icon = gtk.CellRendererPixbuf() cell_name = gtk.CellRendererText() self._combobox_application.pack_start(cell_icon, False) self._combobox_application.pack_start(cell_name, True) self._combobox_application.add_attribute(cell_icon, 'icon-name', Column.ICON) self._combobox_application.add_attribute(cell_name, 'text', Column.NAME) # external options self._radio_external = gtk.RadioButton(group=self._radio_application, label=_('Use external command')) self._radio_external.connect('toggled', self._parent.enable_save) align_external = gtk.Alignment(xscale=1) align_external.set_padding(0, 10, 15, 15) vbox_external = gtk.VBox(False, 0) vbox_external.set_border_width(5) label_editor = gtk.Label(_('Command line:')) label_editor.set_alignment(0, 0.5) label_editor.set_use_markup(True) self._entry_editor = gtk.Entry() self._entry_editor.connect('changed', self._parent.enable_save) self._checkbox_terminal_command = gtk.CheckButton( _('Execute command in terminal tab')) self._checkbox_terminal_command.connect('toggled', self._parent.enable_save) # pack ui vbox_application.pack_start(self._combobox_application, False, False, 0) align_application.add(vbox_application) vbox_external.pack_start(label_editor, False, False, 0) vbox_external.pack_start(self._entry_editor, False, False, 0) vbox_external.pack_start(self._checkbox_terminal_command, False, False, 0) align_external.add(vbox_external) vbox_edit.pack_start(self._radio_application, False, False, 0) vbox_edit.pack_start(align_application, False, False, 0) vbox_edit.pack_start(self._radio_external, False, False, 0) vbox_edit.pack_start(align_external, False, False, 0) frame_view.add(label_not_implemented) frame_edit.add(vbox_edit) self.pack_start(frame_view, False, False, 0) self.pack_start(frame_edit, False, False, 0)
def __init__(self, application): gtk.HPaned.__init__(self) from ui.canvas import Canvas self.canvas = Canvas(application) self.properties = Properties(application) self.canvas.connect("select", self.select) self.canvas.connect("finalize", self.finalize) self.canvas.connect("edit-child", self.edit_child) self.canvas.connect("scroll-event", self.wheel) box = gtk.VBox() self.notification = Notification() code_editor = None if '--source-editor-test' in sys.argv: while True: try: from ui.code_editor import CodeEditor except: self.notification.notificate( _("No module GtkSourceView installed"), ERROR) self.pack1(box, True, False) break panel = gtk.VPaned() panel.pack1(box, True, False) code_editor = CodeEditor(application) code_editor.editor.set_language("sql") panel.pack2(code_editor, False, True) self.pack1(panel, True, False) break else: self.pack1(box, True, False) self.pack2(self.properties, False, True) top = gtk.HBox() box.pack_start(top, False, False) top.pack_start(self.notification, False, False) layer_selector = LayerSelector() alignment = gtk.Alignment(1.0, 0.5) alignment.add(layer_selector) top.pack_start(alignment, True, True) separator = gtk.VSeparator() top.pack_start(separator, False, False) self.image = gtk.Image() self.image.set_from_stock(CONTRACT_PROPERTIES, gtk.ICON_SIZE_MENU) button = gtk.Button() button.set_image(self.image) button.set_relief(gtk.RELIEF_NONE) button.connect("clicked", self.toggle_properties) top.pack_start(button, False, False) table = gtk.Table() box.add(table) bottom = gtk.HBox() box.pack_start(bottom, False, False) self.climber = Climber(self.canvas) bottom.pack_start(self.climber, False, False) pager = Pager(self.canvas) alignment = gtk.Alignment(1.0, 0.5) alignment.add(pager) bottom.pack_start(alignment, True, True) self.horizontal_ruler = HorizontalRuler() self.horizontal_ruler.connect("append-tag", self.append_tag) self.horizontal_ruler.connect("move-tag", self.move_tag) table.attach(self.horizontal_ruler, 1, 2, 0, 1, gtk.FILL | gtk.EXPAND, 0) self.vertical_ruler = VerticalRuler() self.vertical_ruler.connect("append-tag", self.append_tag) self.vertical_ruler.connect("move-tag", self.move_tag) table.attach(self.vertical_ruler, 0, 1, 1, 2, 0, gtk.FILL | gtk.EXPAND) area = gtk.ScrolledWindow() area.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) adjustment = area.get_vadjustment() adjustment.connect("value-changed", self.scroll, VERTICAL) adjustment = area.get_hadjustment() adjustment.connect("value-changed", self.scroll, HORIZONTAL) table.attach(area, 1, 2, 1, 2, gtk.FILL | gtk.EXPAND, gtk.FILL | gtk.EXPAND) self.canvas.code_editor = code_editor self.canvas.horizontal_ruler = self.horizontal_ruler self.canvas.vertical_ruler = self.vertical_ruler self.connect("realize", self.realize, area)