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
