def payment_value_colorize(payment): if payment.status == Payment.STATUS_CANCELLED: return Gdk.color_parse('gray') if payment.is_inpayment(): return Gdk.color_parse('blue') return Gdk.color_parse('red')
def __init__(self, activity_path, default): super(XoIcon, self).__init__(orientation=Gtk.Orientation.VERTICAL) self.icons = XoIcons(default) self.home = XoHome(self.icons.get_icon(), activity_path) self.icons.connect('icon_changed', self.home.update) self.home_box = Gtk.EventBox() self.home_box.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse('white')) self.home_box.add(self.home) self.icons_box = Gtk.EventBox() self.icons_box.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse('white')) self.icons_box.add(self.icons) self.icons_scroll = Gtk.ScrolledWindow() self.icons_scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) self.icons_scroll.add_with_viewport(self.icons_box) self.icons_scroll.set_size_request(-1, style.MEDIUM_ICON_SIZE + 30) self.pack_start(self.home_box, True, True, 0) self.pack_start(Gtk.HSeparator(), False, False, 0) self.pack_start(self.icons_scroll, False, False, 0) self.show_all()
def background_color(tags, bgcolor=None): if not bgcolor: bgcolor = Gdk.color_parse("#FFFFFF") # Compute color my_color = None color_count = 0.0 red = 0 green = 0 blue = 0 for my_tag in tags: my_color_str = my_tag.get_attribute("color") if my_color_str: my_color = Gdk.color_parse(my_color_str) color_count = color_count + 1 red = red + my_color.red green = green + my_color.green blue = blue + my_color.blue if color_count != 0: red = int(red / color_count) green = int(green / color_count) blue = int(blue / color_count) brightness = (red + green + blue) / 3.0 target_brightness = (bgcolor.red + bgcolor.green + bgcolor.blue) / 3.0 alpha = (1 - abs(brightness - target_brightness) / 65535.0) / 2.0 red = int(red * alpha + bgcolor.red * (1 - alpha)) green = int(green * alpha + bgcolor.green * (1 - alpha)) blue = int(blue * alpha + bgcolor.blue * (1 - alpha)) my_color = Gdk.Color(red, green, blue).to_string() return my_color
def __init__(self, colors): super(RedBotPlayfield, self).__init__() self.colors = [Gdk.color_parse(c) for c in colors] self.colors.append(Gdk.color_parse("black")) self.set_row_homogeneous(True) self.set_column_homogeneous(True) self.modify_bg(Gtk.StateType.NORMAL, self.colors[-1])
def test_color_parse(self): with capture_glib_deprecation_warnings(): c = Gdk.color_parse('#00FF80') self.assertEqual(c.red, 0) self.assertEqual(c.green, 65535) self.assertEqual(c.blue, 32896) self.assertEqual(Gdk.color_parse('bogus'), None)
def status(self, type): """ Status bar """ if type=="inputs": self.eventbox.show() self.eventbox.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse("#F07568")) self.image_status.set_from_icon_name("gtk-dialog-error", Gtk.IconSize(6)) self.label_status.set_text("Error: invalid inputs or server unreachable") elif type=="getfavicon": self.eventbox.show() self.eventbox.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse("#729fcf")) self.image_status.set_from_icon_name("gtk-dialog-warning", Gtk.IconSize(6)) self.label_status.set_text("Trying to get favicon...") elif type=="errfavicon": self.eventbox.show() self.eventbox.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse("#F07568")) self.image_status.set_from_icon_name("gtk-dialog-error", Gtk.IconSize(6)) self.label_status.set_text("Trying to get favicon...Failed!") elif type=="succfavicon": self.eventbox.show() self.eventbox.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse("#73d216")) self.image_status.set_from_icon_name("gtk-info", Gtk.IconSize(6)) self.label_status.set_text("Trying to get favicon...Success!") elif type=="success": self.eventbox.show() self.eventbox.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse("#73d216")) self.image_status.set_from_icon_name("gtk-info", Gtk.IconSize(6)) self.label_status.set_text("Web application added to your menu!")
def __init__(self, plugin): #self._plugin = plugin self._instance, self._window = plugin.get_instance() #Set the Glade file gladefile = os.path.join(os.path.dirname(__file__),"config.glade") UI = Gtk.Builder() UI.set_translation_domain('smart_highlight') UI.add_from_file(gladefile) self.configWindow = UI.get_object("configWindow") self.matchWholeWordCheckbutton = UI.get_object("matchWholeWordCheckbutton") self.matchCaseCheckbutton = UI.get_object("matchCaseCheckbutton") self.regexSearchCheckbutton = UI.get_object("regexSearchCheckbutton") self.fgColorbutton = UI.get_object("fgColorbutton") self.bgColorbutton = UI.get_object("bgColorbutton") self.matchWholeWordCheckbutton.set_active(self._instance.options['MATCH_WHOLE_WORD']) self.matchCaseCheckbutton.set_active(self._instance.options['MATCH_CASE']) self.regexSearchCheckbutton.set_active(self._instance.options['REGEX_SEARCH']) self.fgColorbutton.set_color(Gdk.color_parse(self._instance.smart_highlight['FOREGROUND_COLOR'])) self.bgColorbutton.set_color(Gdk.color_parse(self._instance.smart_highlight['BACKGROUND_COLOR'])) self.configWindow.show_all() signals = { "on_configWindow_destroy" : self.on_configWindow_destroy, "on_matchWholeWordCheckbutton_toggled" : self.on_matchWholeWordCheckbutton_toggled, "on_matchCaseCheckbutton_toggled" : self.on_matchCaseCheckbutton_toggled, "on_regexSearchCheckbutton_toggled": self.on_regexSearchCheckbutton_toggled, "on_fgColorbutton_color_set" : self.on_fgColorbutton_color_set, "on_bgColorbutton_color_set" : self.on_bgColorbutton_color_set } UI.connect_signals(signals)
def new_terminal (self,gevice): hbox_term = Gtk.HBox(homogeneous=False,spacing=0) terminal = Vte.Terminal() terminal.set_mouse_autohide(True) terminal.set_default_colors() bgcolor = Gdk.color_parse(gevice.gpref.gsettings.get_string("backcolor")) terminal.set_color_background(bgcolor) fgcolor = Gdk.color_parse(gevice.gpref.gsettings.get_string("forecolor")) terminal.set_color_foreground(fgcolor) terminal.set_size_request(10,10) terminal.set_size (30,1) terminal.set_mouse_autohide (True) # capture word limited for characters when double click terminal.set_word_chars("-A-Za-z0-9,./?%&#:_") terminal.connect('event',self.the_focus,terminal) adj = terminal.get_vadjustment() scroll = Gtk.VScrollbar.new(adj) hbox_term.pack_start(terminal,True,True,0) hbox_term.pack_start(scroll,False,False,0) return hbox_term,terminal
def append_page(self, widget, label): vbox = Gtk.VBox() vbox.set_border_width(4) evbox = Gtk.EventBox() evbox.add(label) #evbox.modify_fg(Gtk.StateType.NORMAL, Gdk.color_parse("yellow")) evbox.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse("skyblue")) vbox.pack_start(evbox, False, False, 0) vbox.pack_start(widget, True, True, 4) frame = Gtk.EventBox() frame.set_size_request(300, 300) frame.props.visible_window = True frame.set_border_width(0) frame.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse("palegreen1")) frame.add(vbox) frame.show_all() pos = self.get_widget_position(frame) if pos is None: x, y = 0, 0 else: x, y = pos wd, ht = self.get_widget_size(frame) subwin = Bunch.Bunch(widget=widget, label=evbox, frame=frame, x=x, y=y, width=wd, height=ht) self.children.append(subwin) evbox.connect("button_press_event", self.select_child_cb, subwin) frame.connect("button_press_event", self.start_resize_cb, subwin) self.put(frame, self.cascade_offset, self.cascade_offset)
def get_widget(self): gladefile = os.path.join(os.path.dirname(__file__),"config.ui") UI = Gtk.Builder() UI.set_translation_domain('smart-highlight') UI.add_from_file(gladefile) widget = UI.get_object('smart_highlight_config') matchWholeWordCheckbutton = UI.get_object("matchWholeWordCheckbutton") matchCaseCheckbutton = UI.get_object("matchCaseCheckbutton") fgColorbutton = UI.get_object("fgColorbutton") bgColorbutton = UI.get_object("bgColorbutton") if self.has_settings_schema: matchWholeWordCheckbutton.set_active(self.settings.get_boolean('match-whole-word')) matchCaseCheckbutton.set_active(self.settings.get_boolean('match-case')) fgColorbutton.set_color( Gdk.color_parse(self.settings.get_string('foreground-color')) or Gdk.color_parse(self.default_settings['foreground-color'])) bgColorbutton.set_color( Gdk.color_parse(self.settings.get_string('background-color')) or Gdk.color_parse(self.default_settings['background-color'])) signals = { "on_matchWholeWordCheckbutton_toggled": self.on_matchWholeWordCheckbutton_toggled, "on_matchCaseCheckbutton_toggled": self.on_matchCaseCheckbutton_toggled, "on_fgColorbutton_color_set": self.on_fgColorbutton_color_set, "on_bgColorbutton_color_set": self.on_bgColorbutton_color_set } UI.connect_signals(signals) else: self.logger.warn("Configuration disabled because settings schema " "is not installed.") widget.set_sensitive(False) return widget
def __init__(self): Gtk.EventBox.__init__(self) toolbar = Gtk.Toolbar() toolbar.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse('#f0e6aa')) toolbar.modify_fg(Gtk.StateType.NORMAL, Gdk.color_parse('#000000')) self.anterior = get_boton(os.path.join(icons, "go-next-rtl.svg"), pixels=get_pixels(0.5), tooltip_text="Anterior") self.anterior.connect("clicked", self.__emit_accion) toolbar.insert(self.anterior, - 1) item = Gtk.ToolItem() item.set_expand(True) self.entry = Gtk.Entry() self.entry.show() item.add(self.entry) toolbar.insert(item, - 1) self.siguiente = get_boton(os.path.join(icons, "go-next.svg"), pixels=get_pixels(0.5), tooltip_text="Siguiente") self.siguiente.connect("clicked", self.__emit_accion) toolbar.insert(self.siguiente, - 1) self.entry.connect("changed", self.__emit_buscar) self.add(toolbar) self.show_all() self.anterior.set_sensitive(False) self.siguiente.set_sensitive(False)
def set_colours(self, bg_colour, komadai_colour, square_colour, text_colour, border_colour, grid_colour): if gv.verbose: print("in gui set_colours with these parms:") print(" bg_colour=", bg_colour) print(" komadai_colour=", komadai_colour) print(" square_colour=", square_colour) print(" text_colour=", text_colour) # print " piece_fill_colour=", piece_fill_colour # print " piece_outline_colour=", piece_outline_colour # print " piece_kanji_colour=", piece_kanji_colour print(" border_colour=", border_colour) print(" grid_colour=", grid_colour) self.get_window().modify_bg( Gtk.StateType.NORMAL, Gdk.color_parse(bg_colour)) #self.komadaiw_eb.modify_bg( # Gtk.StateType.NORMAL, Gdk.color_parse(komadai_colour)) #self.komadaib_eb.modify_bg( # Gtk.StateType.NORMAL, Gdk.color_parse(komadai_colour)) self.komadaiw_eb.queue_draw() self.komadaib_eb.queue_draw() # square/komadai square colours are set in board.py in # set_image_cairo_komadai and set_image_cairo # border surrounds the board and contains the co-ordinates #self.border_eb.modify_bg( # Gtk.StateType.NORMAL, Gdk.color_parse(border_colour)) self.border_eb.queue_draw() self.grid_eb.modify_bg( Gtk.StateType.NORMAL, Gdk.color_parse(grid_colour)) gv.board.refresh_screen()
def __init__(self): Gtk.EventBox.__init__(self) self.data = None self.cards_data = None self._workspace_size = 0 # set request size to 100x100 to skip first time sizing in _allocate_cb self.set_size_request(100, 100) self.connect('size-allocate', self._allocate_cb) self._background_color = '#BBBBBB' # Set table settings self.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse(self._background_color)) self.table = Gtk.Table() self.table.grab_focus() self.table.set_can_default(True) self.table.set_row_spacings(CARD_PAD) self.table.set_col_spacings(CARD_PAD) self.table.set_border_width(CARD_PAD) self.table.set_resize_mode(Gtk.ResizeMode.IMMEDIATE) self.table.set_halign(Gtk.Align.CENTER) self.table.set_valign(Gtk.Align.CENTER) self.set_property('child', self.table) self.load_message = Gtk.Label(label='Loading Game') self.load_message.modify_fg(Gtk.StateType.NORMAL, Gdk.color_parse('#ffffff')) self.load_message.modify_font(Pango.FontDescription('10')) self.load_message.show() self.first_load = True self.load_mode = False self.dict = None self.show_all()
def create_drawing_areas(self, sources): """Create as preview areas as video sources exits""" main = self.main_area if self.swap: sources.reverse() sources_num = len(sources) i = 0 areas = dict() for child in main.get_children(): if i > sources_num: main.remove(child) child.destroy() continue source = sources[i] child.set_name(source) child.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse("black")) areas[source] = child i+=1 for source in sources[i:]: new_area = Gtk.DrawingArea() new_area.set_name(source) new_area.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse("black")) areas[source] = new_area main.pack_start(new_area, True, True, int(self.proportion*3)) for child in main.get_children(): child.show() return areas
def __init__(self): super(TestVte, self).__init__() self.set_size_request(400, 400) self.connect("destroy", Gtk.main_quit) vbox = Gtk.VBox() self.vte = Vte.Terminal() vbox.add(self.vte) self.vte.set_colors(Gdk.color_parse('#000000'), Gdk.color_parse('#FFFFFF'), []) self.vte.set_emulation('xterm') sucess_, pid = self.vte.fork_command_full(Vte.PtyFlags.DEFAULT, os.environ["HOME"], ["/bin/bash"], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None) button1 = Gtk.Button('Get text') button1.connect('clicked', self.__get_text_cb) vbox.add(button1) self.add(vbox) self.show_all()
def validate_password(self, editable, new_text, new_text_length, position, editable1, editable2, label): text1 = editable1.get_text() text1 += new_text text2 = editable2.get_text() if text1 != text2: editable1.modify_base(Gtk.StateType.NORMAL, Gdk.color_parse('#ff0000')) label.set_text("No coinciden") else: editable1.modify_base(Gtk.StateType.NORMAL, Gdk.color_parse('#00ff00')) strength = self.get_text_strength(text1) strength = '<span foreground="#66BF66">%s</span>' % strength label.set_markup(strength) t1, t2 = self.cmasterp2.get_text(), self.cmasterp1.get_text() t3, t4 = self.cmasternp2.get_text(), self.cmasternp1.get_text() if editable1.name == 'cmasterp2': t1 += new_text else: t3 += new_text if t1 == t2 and t3 == t4 and not '' in [t1,t2,t3,t4]: self.change_master_button.set_sensitive(True) else: self.change_master_button.set_sensitive(False)
def _put_opt(self): """Put options on the GUI""" # General self.cbStartHidden.set_active(self._conf["general_starthidden"]) self.cbShowScrollbar.set_active(self._conf["general_showscrollbar"]) self.spbtnDefHeight.set_value(self._conf["general_defheight"]) self.entryCmd.set_text(self._conf["general_command"]) self.comboboxCursor.set_active(self._conf["general_cursor"]) # Color self.clbtnFg.set_color(Gdk.color_parse(self._conf["color_text"])) self.clbtnBg.set_color(Gdk.color_parse(self._conf["color_background"])) index = self._palette_list.index(self._conf["color_palettename"]) self.comboboxPalette.set_active(index) self._set_palette(self._conf["color_palettename"]) # Font self.fontbtn.set_font_name(self._conf["font_name"]) font = Pango.FontDescription(self._conf["font_name"]) self.demoTerm.set_font(font) self.cbAllowBold.set_active(self._conf["font_allowbold"]) self.demoTerm.set_allow_bold(self._conf["font_allowbold"]) # Folders if self._conf["folders_showinall"]: self.rbAllFolders.set_active(True) else: self.rbFolderList.set_active(True) self._conf["folders_list"] = [] for path in CONF["folders_list"]: self._add_path_to_list(self.lsstFolderList, path, self._conf["folders_list"])
def __init__(self): Gtk.Notebook.__init__(self) self.accion_instrospeccion = [] self.copy_cut = [] self.estructura_proyecto = Estructura_Proyecto() self.introspeccion = Introspeccion() scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scroll.add(self.introspeccion) label = Gtk.Label("Introspección") label.modify_fg(Gtk.StateType.NORMAL, Gdk.color_parse('#000000')) self.append_page(scroll, label) scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scroll.add(self.estructura_proyecto) label = Gtk.Label("Proyecto") label.modify_fg(Gtk.StateType.NORMAL, Gdk.color_parse('#000000')) self.append_page(scroll, label) self.show_all() self.introspeccion.connect("new_select", self.__re_emit_new_select) # FIXME: La Interfaz se cuelga #self.estructura_proyecto.connect("button-press-event", # self.__click_derecho_en_estructura) self.estructura_proyecto.connect("open", self.__re_emit_open)
def __init__(self, window, core, enable_menu=True): Gtk.EventBox.__init__(self) self.core = core self.events = core.events self.win = window if enable_menu: self.menu = Gtk.Menu() close_item = Gtk.MenuItem.new_with_label("Close") close_item.connect('activate', self.win.close) self.menu.append(close_item) self.menu.show_all() self.connect("button-press-event", self.tab_popup) self.label = Gtk.Label() self.add(self.label) color = 'white' if is_dark_too_light(STROKE): color = 'black' self.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse(STROKE)) self.label.modify_fg(Gtk.StateType.NORMAL, Gdk.color_parse(color)) self.update() self.show_all()
def __init__(self, text): Gtk.TextView.__init__(self) self.hpad = 35 self.vpad = 30 self.border_size = 2 self.background_gradient = None self.text_color = Gdk.color_parse("#000")[1] self.border_color = Gdk.color_parse("#000")[1] self.text = text self.font_desc = Pango.FontDescription() self.font_desc.set_size(10 * Pango.SCALE) self.font_desc.set_style(Pango.Style.NORMAL) self.font_desc.set_variant(Pango.Variant.NORMAL) self.font_desc.set_weight(Pango.Weight.LIGHT) self.font_desc.set_stretch(Pango.Stretch.EXPANDED) self._layout = self.create_pango_layout(text) self._layout.set_height(-1) self._layout.set_width(400*Pango.SCALE) self._layout.set_ellipsize(Pango.EllipsizeMode.NONE) self._layout.set_font_description(self.font_desc) self.do_resize() self.connect('draw', self._draw)
def __init__(self): Gtk.EventBox.__init__(self) self.pairs = [] self.current_pair = None self.current_game_key = None self.model = None self.pair_list_modified = False self.game_loaded = False self.hbox = Gtk.HBox(False) fill_box = Gtk.Label() fill_box.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse('#d7d7d7')) fill_box.show() self.hbox.pack_end(fill_box, True, True, 0) self._scroll = Gtk.ScrolledWindow() self._scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) self._scroll.add_with_viewport(self.hbox) self._scroll.set_border_width(0) self._scroll.get_child().modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse('#d7d7d7')) self.add(self._scroll) self.set_size_request(-1, PAIR_SIZE * 2 + style.DEFAULT_SPACING * 4) self.show_all()
def __init__(self, *args, **kwds): super(DiffViewerWidget, self).__init__(*args, **kwds) self.set_editable(False) self.set_cursor_visible(False) self.color_plus = Gdk.color_parse('#ddffdd') self.color_minus = Gdk.color_parse('#ffdddd') self._init_tag_table()
def entry_changed(entry, is_fee): amount = numbify(amount_entry) fee = numbify(fee_entry) if not is_fee: fee = None if amount is None: return try: tx = self.wallet.make_unsigned_transaction([("op_return", "dummy_tx", amount)], fee) self.funds_error = False except NotEnoughFunds: self.funds_error = True if not self.funds_error: if not is_fee: fee = tx.get_fee() fee_entry.set_text(str(Decimal(fee) / 100000000)) self.fee_box.show() amount_entry.modify_text(Gtk.StateType.NORMAL, Gdk.color_parse("#000000")) fee_entry.modify_text(Gtk.StateType.NORMAL, Gdk.color_parse("#000000")) send_button.set_sensitive(True) else: send_button.set_sensitive(False) amount_entry.modify_text(Gtk.StateType.NORMAL, Gdk.color_parse("#cc0000")) fee_entry.modify_text(Gtk.StateType.NORMAL, Gdk.color_parse("#cc0000"))
def _configure_vt(self, vt): conf = ConfigParser.ConfigParser() conf_file = os.path.join(env.get_profile_path(), 'terminalrc') if os.path.isfile(conf_file): f = open(conf_file, 'r') conf.readfp(f) f.close() else: conf.add_section('terminal') font = self._get_conf(conf, 'font', 'Monospace') vt.set_font(Pango.FontDescription(font)) self._theme_colors = {"light": {'fg_color': '#000000', 'bg_color': '#FFFFFF'}, "dark": {'fg_color': '#FFFFFF', 'bg_color': '#000000'}} fg_color = self._theme_colors[self._theme_state]['fg_color'] bg_color = self._theme_colors[self._theme_state]['bg_color'] try: vt.set_colors(Gdk.color_parse(fg_color), Gdk.color_parse(bg_color), []) except TypeError: # Vte 0.38 requires the colors set as a different type # in Fedora 21 we get a exception # TypeError: argument foreground: Expected Gdk.RGBA, # but got gi.overrides.Gdk.Color vt.set_colors(Gdk.RGBA(*Gdk.color_parse(fg_color).to_floats()), Gdk.RGBA(*Gdk.color_parse(bg_color).to_floats()), []) blink = self._get_conf(conf, 'cursor_blink', False) vt.set_cursor_blink_mode(blink) bell = self._get_conf(conf, 'bell', False) vt.set_audible_bell(bell) scrollback_lines = self._get_conf(conf, 'scrollback_lines', 1000) vt.set_scrollback_lines(scrollback_lines) vt.set_allow_bold(True) scroll_key = self._get_conf(conf, 'scroll_on_keystroke', True) vt.set_scroll_on_keystroke(scroll_key) scroll_output = self._get_conf(conf, 'scroll_on_output', False) vt.set_scroll_on_output(scroll_output) if hasattr(vt, 'set_emulation'): # set_emulation is not available after vte commit # 4e253be9282829f594c8a55ca08d1299e80e471d emulation = self._get_conf(conf, 'emulation', 'xterm') vt.set_emulation(emulation) if hasattr(vt, 'set_visible_bell'): visible_bell = self._get_conf(conf, 'visible_bell', False) vt.set_visible_bell(visible_bell) conf.write(open(conf_file, 'w'))
def login(self): def auth_response(dialog, resp_id): if resp_id == Gtk.ResponseType.OK: self.response = '' email = dialog.email_entry.get_text() password = dialog.password_entry.get_text() self._login = email self._password_sha1 = hashlib.sha1(password).hexdigest() del password self._authorization_header = base64.b64encode('{}:{}'.format(self._public_key, self._login)) if not self.are_credentials_ok(): self.relogin() # Window to enter email and password pin_dialog = Gtk.Dialog( title='Droplr Login', flags=Gtk.DIALOG_DESTROY_WITH_PARENT, buttons=( 'Sign Up', Gtk.ResponseType.OK, Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL ) ) pin_dialog.set_default_response(Gtk.ResponseType.OK) pin_dialog.set_modal(False) pin_dialog.set_decorated(True) pin_dialog.set_resizable(False) pin_dialog.email_entry = email_entry = Gtk.Entry() email_entry.set_activates_default(Gtk.TRUE) pin_dialog.email_entry.show() pin_dialog.password_entry = password_entry = Gtk.Entry() password_entry.set_activates_default(Gtk.TRUE) email_label = Gtk.Label('e-mail :') password_label = Gtk.Label('password :'******'https://www.dropbox.com/forgot') forgot_password_button = Gtk.Button('Forgot password?') forgot_password_button.connect('clicked', forgot_password_callback, None) forgot_password_button.props.relief = Gtk.RELIEF_NONE label = forgot_password_button.get_children()[0] label.modify_fg(Gtk.STATE_NORMAL, Gdk.color_parse('red')) label.modify_fg(Gtk.STATE_PRELIGHT, Gdk.color_parse('red')) table = Gtk.Table(2, 3, True) table.attach(email_label, 0, 1, 0, 1) table.attach(password_label, 0, 1, 1, 2) table.attach(email_entry, 1, 3, 0, 1) table.attach(password_entry, 1, 3, 1, 2) table.show_all() pin_dialog.vbox.add(table) pin_dialog.vbox.add(forgot_password_button) pin_dialog.show_all() pin_dialog.connect('response', auth_response) pin_dialog.run() pin_dialog.destroy()
def evaluate(widget, event=None): "Evaluate a given x for the three functions" def entry_changed(self): for e in ((y1, dlg_win.y1_entry), (y2, dlg_win.y2_entry), (y3, dlg_win.y3_entry)): try: x = float(dlg_win.x_entry.get_text()) safe_dict['x']=x e[1].set_text(str(eval(e[0].replace("^","**"),{"__builtins__":{}},safe_dict))) except: if len(e[0]) > 0: e[1].set_text("Error: %s" % sys.exc_value) else: e[1].set_text("") def close(self): dlg_win.destroy() dlg_win = Gtk.Window(Gtk.WindowType.TOPLEVEL) dlg_win.set_title(_("Evaluate")) dlg_win.connect("destroy", close) dlg_win.x_entry = Gtk.Entry() dlg_win.x_entry.set_size_request(200, 24) dlg_win.x_entry.connect("changed", entry_changed) dlg_win.y1_entry = Gtk.Entry() dlg_win.y1_entry.set_size_request(200, 24) dlg_win.y1_entry.set_sensitive(False) dlg_win.y2_entry = Gtk.Entry() dlg_win.y2_entry.set_size_request(200, 24) dlg_win.y2_entry.set_sensitive(False) dlg_win.y3_entry = Gtk.Entry() dlg_win.y3_entry.set_size_request(200, 24) dlg_win.y3_entry.set_sensitive(False) table = Gtk.Table(2, 5) label = Gtk.Label(label="x = ") label.set_alignment(0, .5) table.attach(label, 0, 1, 0, 1, xpadding=5, ypadding=5, xoptions=Gtk.AttachOptions.FILL) table.attach(dlg_win.x_entry, 1, 2, 0, 1) label = Gtk.Label(label="y1 = ") label.set_alignment(0, .5) label.modify_fg(Gtk.StateType.NORMAL, Gdk.color_parse("blue")) table.attach(label, 0, 1, 1, 2, xpadding=5, ypadding=5, xoptions=Gtk.AttachOptions.FILL) table.attach(dlg_win.y1_entry, 1, 2, 1, 2) label = Gtk.Label(label="y2 = ") label.set_alignment(0, .5) label.modify_fg(Gtk.StateType.NORMAL, Gdk.color_parse("red")) table.attach(label, 0, 1, 2, 3, xpadding=5, ypadding=5, xoptions=Gtk.AttachOptions.FILL) table.attach(dlg_win.y2_entry, 1, 2, 2, 3) label = Gtk.Label(label="y3 = ") label.set_alignment(0, .5) label.modify_fg(Gtk.StateType.NORMAL, Gdk.color_parse("DarkGreen")) table.attach(label, 0, 1, 3, 4, xpadding=5, ypadding=5, xoptions=Gtk.AttachOptions.FILL) table.attach(dlg_win.y3_entry, 1, 2, 3, 4) table.set_border_width(24) dlg_win.add(table) dlg_win.show_all()
def getColor(colorString): # Takes a color string in either #RRGGBB format # TODO: Take a group, role format (using GTK int values) # Returns gdk color if colorString[0] == "#": return Gdk.color_parse(colorString) return Gdk.color_parse("#000000")
def on_dambutt_clicked(self,button): damage=int(self.damageentry.get_text()) self.hpcurrent-=damage self.update_hplabel() if (self.hpcurrent<1): self.rowframe.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse("orange")) if (self.hpcurrent<0): self.rowframe.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse("red"))
def makemered(self, whatodo): if whatodo: self.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse(COLOR_WORK)) else: self.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse(COLOR_OK)) self.set_sensitive(False) self.saferefreshme() self.set_sensitive(True)
def set_frozen(self,entry,frozen): if frozen: entry.set_editable(False) entry.set_has_frame(False) entry.modify_base(Gtk.StateType.NORMAL, Gdk.color_parse("#eeeeee")) else: entry.set_editable(True) entry.set_has_frame(True) entry.modify_base(Gtk.StateType.NORMAL, Gdk.color_parse("#ffffff"))
def mytimer(self): t1 = time.time() t_diff = t1 - self.t0 self.t0 = t1 lbl_txt = 'UPDATE[ms]:%-4d' % (t_diff * 1000) self.lbl.set_text(lbl_txt + ' DEV:' + serial_dev + ' BAUD:' + str(serial_baud) + ' [Takago Lab.2019]') for k, widget in self.entry.items(): if widget.auto_update == False: widget.modify_fg(Gtk.StateFlags.NORMAL, Gdk.color_parse('#FFF')) widget.modify_bg(Gtk.StateFlags.NORMAL, Gdk.color_parse('#00F')) continue val = self.read_reg(widget.adr, widget.N) if widget.radix == 16: if widget.N == 2: dat = '%04X' % val else: dat = '%02X' % val elif widget.radix == 2: if widget.N == 2: dat = format(val, '016b') else: dat = format(val, '08b') else: if widget.N == 2: dat = '%5d' % val else: dat = '%3d' % val widget.modify_fg(Gtk.StateFlags.NORMAL, Gdk.color_parse('#000')) if widget.get_editable() == False: if dat != widget.get_text(): widget.modify_bg(Gtk.StateFlags.NORMAL, Gdk.color_parse('#F68')) else: widget.modify_bg(Gtk.StateFlags.NORMAL, Gdk.color_parse('#999')) else: if dat != widget.get_text(): widget.modify_bg(Gtk.StateFlags.NORMAL, Gdk.color_parse('#9CD')) else: widget.modify_bg(Gtk.StateFlags.NORMAL, Gdk.color_parse('#DDD')) widget.set_text(dat) self.timer_id = GObject.timeout_add(10, self.mytimer) # 10ms後に呼び出す
def __init__(self): Gtk.EventBox.__init__(self) # Take care of the background first white = Gdk.color_parse("white") self.modify_bg(Gtk.StateFlags.NORMAL, white) self.box = Gtk.VButtonBox() self.box.set_layout(Gtk.ButtonBoxStyle.CENTER) self.add(self.box) self.box.show() self.show() self.bookmark_icon = Icon(icon_name='emblem-favorite', pixel_size=18) tooltip_text = _('Bookmark') self.bookmark_icon.set_tooltip_text(tooltip_text) self.box.pack_start(self.bookmark_icon, False, False, 0)
def fill_pref_dialog(self): """load config into the dialog""" self.custom_font_preference.set_font_name( config.get( 'visual', 'custom_font', )) parse_color = lambda x: Gdk.color_parse(state['gui'].theme[x]) self.colorpreference.set_color(parse_color('foreground')) self.textboxbgpreference.set_color(parse_color('textboxbg')) self.bgpreference.set_color(parse_color('background')) self.borderpreference.set_color(parse_color('border')) self.paddingpreference.set_value(float(state['gui'].theme['padding'])) self.widthpreference.set_value( float(state['gui'].theme['width']) * 100) self.heightpreference.set_value( float(state['gui'].theme['height']) * 100)
def _show_image_viewer(self, icon=None, image=False): media_box = Gtk.EventBox() media_box.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse('white')) if image: image = Gtk.Image() pixbuf = GdkPixbuf.Pixbuf.new_from_file(self._file_path) image.set_from_pixbuf(pixbuf) media_box.add(image) if icon: h = Gdk.Screen.width() / 3 icon = Icon(icon_name=icon, pixel_size=h) media_box.add(icon) media_box.show_all() self._replace_with_viewport(media_box)
def __init__(self, handle): ''' Initialize the toolbars and the reading board ''' super(LetterMatch, self).__init__(handle) self.datapath = get_path(activity, 'instance') self.image_id = None self.audio_id = None if 'LANG' in os.environ: language = os.environ['LANG'][0:2] elif 'LANGUAGE' in os.environ: language = os.environ['LANGUAGE'][0:2] else: language = 'es' # default to Spanish # FIXME: find some reasonable default situation language = 'es' self.letter = None self.activity_path = activity.get_bundle_path() self._lessons_path = os.path.join(self.activity_path, 'lessons', language) self._images_path = os.path.join(self.activity_path, 'images', language) self._sounds_path = os.path.join(self.activity_path, 'sounds', language) self.data_from_journal = {} if 'data_from_journal' in self.metadata: self.data_from_journal = json.loads( str(self.metadata['data_from_journal'])) self._setup_toolbars() self.canvas = Gtk.DrawingArea() self.canvas.set_size_request(Gdk.Screen.width(), Gdk.Screen.height()) self.canvas.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse("#000000")) self.canvas.show() self.set_canvas(self.canvas) self.mode = 'letter' self._page = Page(self.canvas, self._lessons_path, self._images_path, self._sounds_path, parent=self)
def __init__(self, button, toolbar, view_icon, favorite_icon, label): Gtk.Toolbar.__init__(self) self.toolbar = toolbar self.button = button self.view_icon = view_icon self.favorite_icon = favorite_icon self.set_view_icon = ToolButton(view_icon) self.set_view_icon.set_tooltip(_('Set toolbar icon')) self.set_view_icon.connect('clicked', self.set_icon, False) self.set_favorite_icon = ToolButton(favorite_icon) self.set_favorite_icon.set_tooltip(_('Set the icon of favorites list')) self.set_favorite_icon.connect('clicked', self.set_icon, True) entry_toolitem = Gtk.ToolItem() self.favorite_name_entry = Gtk.Entry() self.favorite_name_entry.set_placeholder_text(_('Favorite view name')) width = Gdk.Screen.width() - (style.STANDARD_ICON_SIZE * 12) entry_toolitem.set_size_request(width, 55) self.favorite_name_entry.set_text(label) self.favorite_name_entry.connect("activate", self.edited_view_name) entry_toolitem.add(self.favorite_name_entry) label = Gtk.Label(_('Name of favorite view') + '\t') label.modify_fg(Gtk.StateType.NORMAL, Gdk.color_parse('white')) tool_label = Gtk.ToolItem() tool_label.add(label) self.remove_btn = ToolButton('list-remove') self.remove_btn.set_tooltip(_('Remove favorite view')) self.remove_btn.connect('clicked', self.remove_view) separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) self.insert(self.set_view_icon, -1) self.insert(self.set_favorite_icon, -1) self.insert(tool_label, -1) self.insert(entry_toolitem, -1) self.insert(separator, -1) self.insert(self.remove_btn, -1) self.show_all()
def color_swatch_new(self, str_color): color = Gdk.color_parse(str_color) rgba = Gdk.RGBA.from_color(color) button = Gtk.Button() area = Gtk.DrawingArea() area.set_size_request(24, 24) area.connect("draw", self.on_draw, { 'color': rgba, 'width': 24, 'heigth': 24 }) button.add(area) return button
def init_ui(self): self.connect("draw", self.on_draw) self.box = Gtk.Box(spacing=6) self.add(self.box) self.chars_int = range(48, 58) +\ range(65382, 65438) # range(404, 448) +\ # range(564, 688) +\ # range(931, 1124) +\ # range(65382, 65438) self.labels = [] for x in xrange(0, COLUMNS): lbl = self.generate_label() self.box.pack_start(lbl, True, True, 0) self.labels.append(lbl) lbtn = Gtk.Label() lbtn.set_text("⚪") fd = Pango.FontDescription("Serif 20") lbtn.modify_font(fd) lbtn.modify_fg(Gtk.StateFlags.NORMAL, Gdk.color_parse("gray")) lbtn.set_has_window(True) lbtn.set_events(Gdk.EventMask.BUTTON_PRESS_MASK) lbtn.connect("button-press-event", self.on_button_clicked) self.box.pack_start(lbtn, True, True, 0) root_win = Gdk.get_default_root_window() root_height = root_win.get_height() root_width = root_win.get_width() logging.info("Desktop-size: " + repr(root_width) + "x" + repr(root_height)) self.connect("delete-event", Gtk.main_quit) self.show_all() w_width, w_height = self.get_size() logging.info("Window-size: " + repr(w_width) + "x" + repr(w_height)) #self.move(root_width - w_width - 10, root_height - w_height - 10) #self.resize(root_width / 4, root_height / 4) self.move(100, 100) for x in xrange(0, COLUMNS): t = random.uniform(1, 5) threading.Timer(t, self.update_lbl, [self.labels[x]]).start()
def tensor_element_focus_in(self, widget, event, row, col): """ Called when a tensor data entry widget gains focus. Used to delete the printable_type placeholder. """ dim1, dim2 = self.node.tensor_shape(self.geometry_dim_tree) if not self.interacted[row + col * dim2]: self.interacted[row + col * dim2] = True if self.node.is_symmetric_tensor(self.geometry_dim_tree): self.interacted[col + row * dim1] = True if self.node.data is None: widget.set_text("") widget.modify_text(gtk.StateFlags.NORMAL, gdk.color_parse("black")) return
def _build_textview(self): self._textview = Gtk.TextView() self._textview.set_wrap_mode(Gtk.WrapMode.NONE) pangoFont = Pango.FontDescription('Mono') self._textview.modify_font(pangoFont) bgcolor = Gdk.color_parse('#FFFFFF') self._textview.modify_base(Gtk.StateType.NORMAL, bgcolor) self._textview.set_editable(False) scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scroll.add(self._textview) self.add2(scroll)
def _set_value(self, value): if value is None: value = '' color = Gdk.color_parse(value) self._color_choice.props.active = color is not None self._image_choice.props.active = color is None if color is not None: self._color_value.props.color = color self._image_value.unselect_all() else: if value: self._image_value.select_filename(value) else: self._image_value.unselect_all()
def get_color(self, color): ''' ''' if color is None: return None try: #Generate 13 digit color string from supplied color col = Gdk.color_parse(color).to_string() except ValueError: logging.debug("Unable to parse color from '%s'" % color) return None #Create matplotlib color string _color = "#%s%s%s" % (col[1:3], col[5:7], col[9:11]) #logging.debug("%s color saved as: %s" % (color, _color)) return _color
def display_test(self, _button, color=''): self.colourIndex = 0 if "automatic" in color.lower(): colour_array = ['White', 'Red', 'Green', 'Blue', 'Black', 'Exit'] else: colour_array = [color, 'Exit'] colour_parsed = Gdk.color_parse(colour_array[self.colourIndex]) test_window = Gtk.Window() test_window.fullscreen() test_window.connect('button-release-event', self.display_test_action, test_window, colour_array) test_window.connect('key-release-event', self.display_test_action, test_window, colour_array) test_window.connect("destroy", Gtk.main_quit) test_window.modify_bg(Gtk.StateType.NORMAL, colour_parsed) test_window.show_all() Gtk.main()
def __init__(self, parent=None): Gtk.Dialog.__init__(self, self.__class__.__name__, parent, 0, None) self.connect('destroy', lambda *w: Gtk.main_quit()) self.set_name('os_dialog') Gtk.Window.set_default_icon_from_file ("/usr/share/os-about/about-os-window-icon.png") self.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse('white')) # Set the dialog default spacing for about self.set_title(_("Start here with Oracle Solaris")) self.set_border_width(5) self.set_resizable(False) self.vbox.set_border_width(2) self.action_area.set_border_width(5) vbox = Gtk.VBox(False, 8) vbox.set_border_width(5) self.vbox.pack_start(vbox, False, False, 0) # Logo logo = Gtk.Image() pixbuf = GdkPixbuf.Pixbuf.new_from_file (ICON_PATH + "about-os-logo.png") # scale = 48.0 / pixbuf.get_height() # width_scale = pixbuf.get_width() * scale # height_scale = pixbuf.get_height() * scale # pixbuf = pixbuf.scale_simple (int(width_scale), int(height_scale), GdkPixbuf.InterpType.BILINEAR) logo.set_from_pixbuf (pixbuf) logo_hbox = Gtk.HBox(True, 0) logo_hbox.pack_start(logo, False, False, 0) vbox.pack_start(logo_hbox, False, False, 0) close_button=self.add_button(Gtk.STOCK_CLOSE,Gtk.ResponseType.CANCEL) self.set_default_response (Gtk.ResponseType.CANCEL) close_button.grab_default() close_button.grab_focus() close_button.connect('clicked', lambda *w: Gtk.main_quit()) self.create_section(help_link, vbox) self.create_section(personalize_link, vbox) self.create_section(participate_link, vbox) self.show_all()
def __init__(self, ajuste): Gtk.Scale.__init__(self, orientation=Gtk.Orientation.HORIZONTAL) self.modify_bg(0, Gdk.color_parse("#ffffff")) self.ajuste = ajuste self.set_digits(0) self.set_draw_value(False) self.borde = 10 path = os.path.dirname(BASE_PATH) icono = os.path.join(path, "Iconos", "iconplay.svg") pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(icono, 16, 16) self.pixbuf = pixbuf.rotate_simple(GdkPixbuf.PixbufRotation.CLOCKWISE) self.show_all()
def __init__(self, xdist, ydist): Gtk.Window.__init__(self, type=Gtk.WindowType.POPUP) self.set_border_width(15) self.set_default_size(300, 70) self.set_decorated(False) self.move(xdist, ydist) # distance to top left corner # little greyish self.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse("#222")) hbox = Gtk.Box(spacing=20) self.add(hbox) self.label = Gtk.Label(WARNING_TEXT) self.label.set_markup( '<span foreground="#00FFCC" size="medium" face="cursive">' + WARNING_TEXT + '</span>') hbox.pack_start(self.label, True, True, 0)
def set_bg_color (self, color): try: if type(color) == str: color = Gdk.color_parse(color) color = Gdk.RGBA(color.red/65535.0, color.green/65535.0, color.blue/65535.0) else: color = Gdk.RGBA(*color) except: logging.critical("set_bg_color handed Bad color: %s" % color, exc_info=True) return self.eb.override_color(Gtk.StateFlags.NORMAL, color) self.eb.override_background_color(Gtk.StateFlags.NORMAL, color) self.table.override_color(Gtk.StateFlags.NORMAL, color) self.table.override_background_color(Gtk.StateFlags.NORMAL, color) for e in list(self.__entries__.values()): e.override_background_color(Gtk.StateFlags.NORMAL, color)
def __init__(self, handle): activity.Activity.__init__(self, handle) self.build_toolbar() self.__canvas = ToolbarView(self) width = Gdk.Screen.width() self.__canvas.set_size_request(width, 55) fixed = Gtk.Fixed() center = (Gdk.Screen.height() / 2) - 55 fixed.put(self.__canvas, 0, center) eventbox = Gtk.EventBox() eventbox.add(fixed) eventbox.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse('white')) self.set_canvas(eventbox) self.show_all()
def init_state(self): blue = Gdk.color_parse("#0072A8") self.widget("header").modify_bg(Gtk.StateType.NORMAL, blue) # [hostname, conn, can_migrate, tooltip] dest_model = Gtk.ListStore(str, object, bool, str) dest_combo = self.widget("migrate-dest") dest_combo.set_model(dest_model) text = Gtk.CellRendererText() dest_combo.pack_start(text, True) dest_combo.add_attribute(text, 'text', 0) dest_combo.add_attribute(text, 'sensitive', 2) dest_model.set_sort_column_id(0, Gtk.SortType.ASCENDING) # Hook up signals to get connection listing self.engine.connect("conn-added", self.dest_add_conn) self.engine.connect("conn-removed", self.dest_remove_conn) self.destconn_changed(dest_combo)
def create_drawing_areas(self, source): # TODO refactorize, REC """Creates the preview areas depending on the video tracks of a mediapackage""" main = self.main_area for child in main.get_children(): main.remove(child) child.destroy() areas = dict() for key in source.keys(): new_area = Gtk.DrawingArea() new_area.set_name("playerarea "+str(key)) areas[key]=new_area areas[key].modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse("black")) main.pack_start(new_area,True,True,3)#TODO editable padding=3 for child in main.get_children(): child.show() return areas
def do_draw(self, gpsmap, ctx): """ Draw the two extreme dates """ ctx.select_font_face(self.font, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL) ctx.set_font_size(int(self.size)) color = Gdk.color_parse(self.color) ctx.set_source_rgba(float(color.red / 65535.0), float(color.green / 65535.0), float(color.blue / 65535.0), 0.6) # transparency coord_x = 10 coord_y = 15 + 2 * int(self.size) # Display the oldest date ctx.move_to(coord_x, coord_y) ctx.show_text(self.first) coord_y = 15 + 3 * int(self.size) # Display the newest date ctx.move_to(coord_x, coord_y) ctx.show_text(self.last)
def __init__(self): Gtk.Window.__init__(self, title="pyqrtray") color = Gdk.color_parse('white') self.modify_bg(Gtk.StateType.NORMAL, color) self.image = Gtk.Image() self.add(self.image) self.old_clipboard_content = None self.clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD) self.check_clipboard() self.clipboard_callback_id = GLib.timeout_add( 1000, self.__check_clipboard_callback) self.connect("delete-event", self.__window_close_handler) self.show_all()
def init_ui(self): self.connect("draw", self.on_draw) lbl = Gtk.Label() text = "ZetCode, tutorials for programmers." lbl.set_text(text) fd = Pango.FontDescription("Serif 20") lbl.modify_font(fd) lbl.modify_fg(Gtk.StateFlags.NORMAL,Gdk.color_parse("black")) self.add(lbl) self.resize(300, 250) self.set_position(Gtk.WindowPosition.CENTER) self.connect("delete-event", Gtk.main_quit) self.show_all()
def __init__(self, filename, version=""): # DONT connect 'destroy' event here! self.window = Gtk.Window(Gtk.WindowType.TOPLEVEL) self.window.set_auto_startup_notification(False) self.window.set_default_icon_list(get_icon_list()) self.window.set_icon_list(get_icon_list()) self.window.set_title('PyXRD') self.window.set_skip_taskbar_hint(True) self.window.set_position(Gtk.WindowPosition.CENTER) self.window.set_decorated(False) self.window.set_resizable(False) self.window.set_border_width(1) self.window.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse('white')) # @UndefinedVariable ebox = Gtk.EventBox( ) # prevent the black color from showing through... self.window.add(ebox) main_vbox = Gtk.VBox(False, 1) main_vbox.set_border_width(10) ebox.add(main_vbox) self.img = ScalableImage() self.img.set_from_file(filename) self.img.set_size_request(500, 300) main_vbox.pack_start(self.img, True, True, 0) self.lbl = Gtk.Label() self.lbl.set_markup("<span size=\"larger\"><b>Loading ...</b></span>") self.lbl.set_alignment(0.5, 0.5) main_vbox.pack_end(self.lbl, True, True, 0) self.version_lbl = Gtk.Label() self.version_lbl.set_markup("<i>Version %s</i>" % version) self.version_lbl.set_alignment(0.5, 0.5) main_vbox.pack_end(self.version_lbl, True, True, 0) self.window.show_all() while Gtk.events_pending(): Gtk.main_iteration() self.start_time = time() self.closed = False
def draw_marker(ctx, x01, y01, size, color): width = 48.0 * size height = width / 2 color = Gdk.color_parse(color) ctx.set_source_rgba(float(color.red / 65535.0), float(color.green / 65535.0), float(color.blue / 65535.0), 1.0) # transparency ctx.set_line_width(2.0) ctx.move_to(x01, y01) ctx.line_to((x01 + (height / 3)), (y01 - height * 2)) ctx.line_to((x01 - (height / 3)), (y01 - height * 2)) ctx.fill() ctx.set_source_rgba(1.0, 0.0, 0.0, 0.5) ctx.move_to(x01, y01) ctx.line_to((x01 + (height / 3)), (y01 - height * 2)) ctx.line_to((x01 - (height / 3)), (y01 - height * 2)) ctx.line_to(x01, y01) ctx.stroke() ctx.save() ctx.translate(x01 + width / 4 - (width / 4), y01 - height * 2 - (width / 4)) ctx.scale(width / 2., height / 2.) ctx.arc(0., 0., 1., 0., 2 * PI) ctx.fill_preserve() ctx.set_source_rgba(1.0, 0.0, 0.0, 0.5) ctx.set_line_width(2.0) ctx.arc(0., 0., 1., 0., 2 * PI) ctx.restore() ctx.stroke() ctx.save() ctx.set_source_rgba(float(color.red / 65535.0), float(color.green / 65535.0), float(color.blue / 65535.0), 1.0) # transparency #ctx.translate(x01 + width/4 - 12.0 , y01 - height*2 - 12.0) ctx.translate(x01 + width / 4 - (width / 4), y01 - height * 2 - (width / 4)) ctx.scale(width / 2., height / 2.) ctx.arc(0., 0., 1., 0., 2 * PI) ctx.fill_preserve() ctx.set_source_rgba(1.0, 0.0, 0.0, 0.5) ctx.set_line_width(2.0) ctx.arc(0., 0., 1., 0., 2 * PI) ctx.restore() ctx.stroke()
def name2color(color): """Return the gtk color for the given color name or code. """ if isinstance(color, Gdk.Color): gtk_color = color elif color: # Found a color. Cache it. try: gtk_color=color_cache[color] except KeyError: try: color_cache[color]=Gdk.color_parse(color) except (TypeError, ValueError): logger.error("Unable to parse color %s", color) color_cache[color]=None gtk_color=color_cache[color] else: gtk_color=None return gtk_color
def get_preferences(self, date=''): RPCContextReload() try: prefs = RPCExecute('model', 'res.user', 'get_preferences', False) except RPCException: prefs = {} threads = [] for target in ( common.IconFactory.load_icons, common.MODELACCESS.load_models, common.MODELHISTORY.load_history, common.VIEW_SEARCH.load_searches, ): t = threading.Thread(target=target) threads.append(t) t.start() for t in threads: t.join() if prefs and 'language_direction' in prefs: translate.set_language_direction(prefs['language_direction']) CONFIG['client.language_direction'] = \ prefs['language_direction'] self.sig_win_menu(prefs=prefs) for action_id in prefs.get('actions', []): Action.execute(action_id, {}) # XXX: add connection date connection_date = date.strftime('%d/%m/%Y') if date else '' self.set_title(prefs.get('status_bar', ''), connection_date) # AKE: change bg color based on preferences color_bg = prefs.get('color_bg', None ) or os.environ.get('TRYTON_CLIENT_BG_COLOR', None) if color_bg: self.window.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse(color_bg)) if prefs and 'language' in prefs: translate.setlang(prefs['language'], prefs.get('locale')) if CONFIG['client.lang'] != prefs['language']: self.favorite_unset() CONFIG['client.lang'] = prefs['language'] # Set placeholder after language is set to get correct translation self.global_search_entry.set_placeholder_text(_("Action")) CONFIG.save()
def __init__(self, title, data_path): super(GTKInterface, self).__init__(title, data_path) # Load UI Gtk.Window.set_default_icon_name("checkbox") self.widgets = Gtk.Builder() self.widgets.set_translation_domain(self.gettext_domain) self.widgets.add_from_file(posixpath.join(data_path, "checkbox-gtk.ui")) self.widgets.connect_signals(self) # Set background color for head eventbox_head = self._get_widget("eventbox_head") color = Gdk.color_parse("#F0EBE2") #HACK: LP #839675 if isinstance(color, tuple): color = color[1] eventbox_head.modify_bg(Gtk.StateType.NORMAL, color) # Set and apply initial/default dialog title self._app_title = title self._dialog = self._get_widget("dialog_main") self._dialog.set_title(self._app_title) #Setup and handler to render pixmap and translatable description text. self.IMAGE_HEAD_BACKGROUND = posixpath.join(data_path, "checkbox-gtk-head.png") self.FONT = "Ubuntu" self.TEXT = title image_head=self._get_widget("image_head") try: image_head.connect("draw",self.draw_image_head) except TypeError: #Looks like GTK+ 2.x image_head.connect("expose-event",self.draw_image_head) # Set wait transient for dialog self._wait = self._get_widget("box_wait") self._wait.hide() # Set shorthand for notebook self._notebook = self._get_widget("notebook_main") self._handlers = {}
def __stop_vnc(self, widget): if not self.showed_message_stop: self.showed_message_stop = True pass else: return self.showed_message_start = False self.pid_nuevo = subprocess.getoutput("pidof x11vnc") color = Gdk.color_parse('red') os.system("kill " + self.pid_nuevo) self.messages.get_model().insert(self.last_message, [ time.strftime("\n<b>%H:%M:%S</b>\n"), ("\n<b>The VNC server is now stopped.</b>\n"), color ]) self.last_message += 1
def set_data_tensor(self): """ Create a table container packed with appropriate widgets for tensor data entry in the node data frame. """ self.set_data_empty() scrolledWindow = self.add_scrolled_window() dim1, dim2 = self.node.tensor_shape(self.geometry_dim_tree) self.data = gtk.Table(dim1, dim2) scrolledWindow.add_with_viewport(self.data) scrolledWindow.get_child().set_property("shadow-type", gtk.ShadowType.NONE) self.set_child_packing(self.frame, True, True, 0, gtk.PackType.START) self.show_all() self.buttons.show() is_symmetric = self.node.is_symmetric_tensor(self.geometry_dim_tree) for i in range(dim1): for j in range(dim2): iindex = dim1 - i - 1 jindex = dim2 - j - 1 entry = gtk.Entry() self.data.attach(entry, jindex, jindex + 1, iindex, iindex + 1) if not is_symmetric or i >= j: entry.show() entry.connect("focus-in-event", self.tensor_element_focus_in, jindex, iindex) if self.node.data is None: entry.set_text(datatype.print_type(self.node.datatype.datatype)) entry.modify_text(gtk.StateFlags.NORMAL, gdk.color_parse("blue")) else: entry.set_text(self.node.data.split(" ")[jindex + iindex * dim2]) self.interacted = [False for i in range(dim1 * dim2)] self.set_fontsize() return