def _init_ui(self):
logger.info("Initialising GTK UI")
self.area = VirtualLCD(self)
# self.area.connect("expose_event", self._expose)
self.hboxes = []
self.buttons = {}
zoomed_size = self.get_zoomed_size()
self.area.set_size_request(zoomed_size[0], zoomed_size[1])
self.vbox = gtk.VBox()
self.vbox.add(self.area)
rows = gtk.VBox()
for row in self.get_key_layout():
hbox = gtk.HBox()
for key in row:
key_text = " ".join(g15driver.get_key_names(list(key)))
g_button = gtk.Button(key_text)
g_button.connect("pressed", self._simulate_key, key,
g15driver.KEY_STATE_DOWN)
g_button.connect("released", self._simulate_key, key,
g15driver.KEY_STATE_UP)
hbox.add(g_button)
self.buttons[key] = g_button
rows.add(hbox)
self.event_box = gtk.EventBox()
self.event_box.add(rows)
self.vbox.add(self.event_box)
# self.main_window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.main_window = gtk.Window(gtk.WindowType.TOPLEVEL)
self.main_window.set_title("Gnome15")
self.main_window.set_icon_from_file(
g15icontools.get_app_icon(self.conf_client, "gnome15"))
self.main_window.add(self.vbox)
self.main_window.connect("delete-event", self._window_closed)
control = self.get_control_for_hint(g15driver.HINT_DIMMABLE)
if control:
if isinstance(control.value, int):
v = (65535 / control.upper) * control.value
# self.event_box.modify_bg(gtk.STATE_NORMAL, gdk.Color(v, v, v))
self.event_box.modify_bg(gtk.StateType.NORMAL,
gdk.Color(v, v, v))
else:
# self.event_box.modify_bg(
# gtk.STATE_NORMAL,
# gdk.Color(
# control.value[0] << 8,
# control.value[1] << 8,
# control.value[2] << 8)
# )
self.event_box.modify_bg(
gtk.StateType.NORMAL,
gdk.Color(control.value[0] << 8, control.value[1] << 8,
control.value[2] << 8))
self.main_window.show_all()
logger.info("Initialised GTK UI")
self.connected = True
logger.info("Connected")
def update_info(self, halfmove):
"""New info is received for a move"""
if halfmove == self.halfmove:
self.update_stockfish()
if (not self.show_stockfish or halfmove not in self.tags
or halfmove not in self.game.info):
return
info = self.game.info[halfmove]
if "pscore_prev" not in info or "pscore" not in info:
return
pscore_prev = info["pscore_prev"]
pscore = info["pscore"]
if halfmove % 2 == 0:
pscore *= -1
pscore_prev *= -1
scoredif = min(max(0, pscore_prev - pscore), config.MAX_DIF)
if abs(pscore) > config.LOST and abs(pscore_prev) > config.LOST:
# when the position is hopeless, all moves are ok
color = Gdk.Color(0, 0, 65535)
else:
color = Gdk.Color(scoredif / config.MAX_DIF * 65535, 0,
(config.MAX_DIF - scoredif) / config.MAX_DIF *
65535)
self.tags[halfmove].set_property("foreground-gdk", color)
def __init__(self):
super(ModuleDialog,self).__init__('Module output', None, Gtk.DialogFlags.DESTROY_WITH_PARENT, (Gtk.STOCK_OK,Gtk.ResponseType.ACCEPT))
# the cancel button
self.butt_cancel = self.action_area.get_children()[0]
self.butt_cancel.connect("clicked", lambda x: self.destroy())
# Positions
self.resize(400, 400)
self.set_position(Gtk.WindowPosition.CENTER)
# Log TextView
#################################################################
self.output_text = Gtk.TextView(buffer=None)
# Some eye candy
self.output_text.modify_base(Gtk.StateType.NORMAL, Gdk.Color(16400, 16400, 16440))
self.output_text.modify_text(Gtk.StateType.NORMAL, Gdk.Color(60535, 60535, 60535, 0))
self.output_text.set_left_margin(10)
self.output_text.set_wrap_mode(Gtk.WrapMode.NONE)
self.output_text.set_editable(False)
self.output_buffer = self.output_text.get_buffer()
self.scrolled_window = Gtk.ScrolledWindow()
self.scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.ALWAYS)
self.scrolled_window.is_visible = True
# Add Textview to Scrolled Window
self.scrolled_window.add_with_viewport(self.output_text)
#self.vbox.pack_start(self.output_text, True, True, 0)
self.vbox.pack_start(self.scrolled_window, True, True, 0)
self.show_all()
def test_color(self):
color = Gdk.Color(100, 200, 300)
self.assertEqual(color.red, 100)
self.assertEqual(color.green, 200)
self.assertEqual(color.blue, 300)
self.assertEqual(color, Gdk.Color(100, 200, 300))
self.assertNotEqual(color, Gdk.Color(1, 2, 3))
def __init__(self, plugin):
GObject.Object.__init__(self)
self.plugin = plugin
self.dataDir = plugin.plugin_info.get_data_dir()
self.geditWindow = plugin.window
#self.builder.add_from_file(os.path.join(self.dataDir, "ui", "BottomPanel.glade"))
#self.ui = Gtk.Builder()
#self.ui.add_from_file(os.path.join(self.dataDir, "ui", "BottomPanel.ui"))
#print self["scrolledWindow"]
self.builder = Gtk.Builder()
self.builder.add_from_file(self.dataDir + "/" + "ui" + "/" +
"BottomPanel.glade")
self.builder.connect_signals(self)
self.scrolledWindow = self.builder.get_object("scrolledWindow")
self.textView = self.builder.get_object("textView")
self.textView.set_editable(False)
self.textView.modify_fg(Gtk.StateType.NORMAL,
Gdk.Color(red=65535, green=65535, blue=65535))
self.textView.modify_bg(Gtk.StateType.NORMAL,
Gdk.Color(red=11776, green=13312, blue=13824))
self.textView.modify_bg(Gtk.StateType.SELECTED,
Gdk.Color(red=51776, green=0, blue=0))
self.textView.connect("button-press-event", self.onTextViewClick)
self.geditBottomPanel = self.geditWindow.get_bottom_panel()
self.geditBottomPanel.add_item(
self.scrolledWindow, "haxe_bottom_panel", "errors",
Gtk.Image.new_from_file(self.dataDir + "/" + "icons" + "/" +
"haxe_logo_16.png")
) # Gtk.Image.new_from_stock(Gtk.STOCK_YES, Gtk.IconSize.MENU))
self.geditBottomPanel.activate_item(self.scrolledWindow)
def _show_message(self, text, icon="dialog-warning"):
self.text = text
self.label.set_tooltip_text(text)
self.icon.set_from_icon_name(icon, Gtk.IconSize.MENU)
if icon == "dialog-warning":
self.hl_anim.color = Gdk.Color(65535, 0, 0)
else:
self.hl_anim.color = Gdk.Color(0, 0, 65535)
def on_finished(anim):
anim.disconnect(sig)
anim.freeze()
if not self.props.visible:
sig = self.anim.connect("animation-finished", on_finished)
self.anim.thaw()
self.show()
self.anim.animate(start=0.0, end=1.0, duration=500)
else:
sig = self.hl_anim.connect("animation-finished", on_finished)
self.hl_anim.thaw()
self.hl_anim.animate(start=0.7, end=1.0, duration=1000)
lines = text.split("\n")
if len(lines) > 1:
self.label.props.label = lines[0] + "..."
self.b_more.props.visible = True
else:
self.label.props.label = text
self.b_more.props.visible = False
def __init__ (self, coords, style=STYLE_CONTINUE, color = Gdk.Color(0,0,0), width = 2): self.x, self.y = coords self.style = style if color == None: color = Gdk.Color(0,0,0) self.color = color self.width = 1
def update_time(self):
if not self.paused:
self.time_elapsed = time.time() - self.time_task_started
self.timelabel.set_label(
time.strftime("%M:%S", time.gmtime(self.time_elapsed)) + "/" +
time.strftime("%M:%S", time.gmtime(self.time_target)))
if self.time_target != 0:
ratio = self.time_elapsed / self.time_target
if ratio > 1:
self.modify_bg(Gtk.StateType.NORMAL, Gdk.Color(50000, 0, 0))
elif ratio > 0.75:
self.modify_bg(Gtk.StateType.NORMAL,
Gdk.Color(65535, 40000, 0))
elif ratio > 0.5:
self.modify_bg(Gtk.StateType.NORMAL,
Gdk.Color(65535, 65535, 0))
else:
self.modify_bg(Gtk.StateType.NORMAL,
Gdk.Color(10000, 30000, 5000))
self.bar.set_value(min(ratio, 1))
else:
self.modify_bg(Gtk.StateType.NORMAL,
Gdk.Color(60000, 60000, 60000))
self.bar.set_value(0)
GObject.timeout_add(10, self.update_time)
def do_draw(self, contexto):
rect = self.get_allocation()
w, h = (rect.width, rect.height)
# Relleno de la barra
ww = w - self.borde * 2
hh = h - self.borde * 2
Gdk.cairo_set_source_color(contexto, Gdk.Color(0, 0, 0))
rect = Gdk.Rectangle()
rect.x, rect.y, rect.width, rect.height = (self.borde, self.borde, ww,
hh)
Gdk.cairo_rectangle(contexto, rect)
contexto.fill()
# Relleno de la barra segun progreso
Gdk.cairo_set_source_color(contexto, Gdk.Color(23000, 41000, 12000))
rect = Gdk.Rectangle()
ximage = int(self.ajuste.get_value() * ww / 100)
rect.x, rect.y, rect.width, rect.height = (self.borde, self.borde,
ximage, hh)
Gdk.cairo_rectangle(contexto, rect)
contexto.fill()
return True
def __format_help(self, buffer_help, tags_table):
from gi.repository import Gdk
from gi.repository import Pango
tag1 = Gtk.TextTag.new("1")
tag1.set_property("weight", Pango.Weight.BOLD)
tags_table.add(tag1)
tag2 = Gtk.TextTag.new("2")
tag2.set_property("weight", Pango.Weight.BOLD)
tag2.set_property("background-gdk", Gdk.Color(0, 0, 0))
tag2.set_property("foreground-gdk", Gdk.Color(65000, 65000, 65000))
tags_table.add(tag2)
tag3 = Gtk.TextTag.new("3")
tag3.set_property("weight", Pango.Weight.BOLD)
tag3.set_property("background-gdk", Gdk.Color(60000, 60000, 60000))
tags_table.add(tag3)
tit2 = [3, 60, 83]
tit3 = [5, 11, 34, 38, 48, 55, 62, 85]
self.__apply_tag(buffer_help, 1, tag1)
for id in tit2:
self.__apply_tag(buffer_help, id, tag2)
for id in tit3:
self.__apply_tag(buffer_help, id, tag3)
def __init__(self, label, min, max):
Gtk.Toolbar.__init__(self)
self.modify_fg(0, Gdk.Color(65000, 65000, 65000))
self.modify_bg(0, Gdk.Color(0, 0, 0))
self.titulo = label
self.min, self.max = (min, max)
self.escala = BarraProgreso()
self.escala.set_size_request(-1, G.get_pixels(0.8))
#self.escala.escala.borde = G.get_pixels(0.2)
item = Gtk.ToolItem()
self.frame = Gtk.Frame()
self.frame.set_label(self.titulo)
self.frame.set_label_align(0.5, 1.0)
self.frame.add(self.escala)
self.frame.show()
item.set_expand(True)
item.add(self.frame)
self.insert(item, -1)
self.show_all()
self.escala.connect("user-set-value", self.user_set_value)
def __senialar(self, valor=False):
"""
Pinta la etiqueta cuando el archivo contiene cambios sin guardar.
"""
color = Gdk.Color(0, 0, 0)
if valor:
color = Gdk.Color(65000, 26000, 0)
scroll = self.get_parent()
if not scroll:
return
notebook = scroll.get_parent()
if not notebook:
return
paginas = notebook.get_n_pages()
if not paginas:
return
for indice in range(paginas):
page = notebook.get_children()[indice]
if page == scroll:
pag = notebook.get_children()[indice]
label = notebook.get_tab_label(pag).get_children()[0]
label.modify_fg(0, color)
return
def __init__(self):
Gtk.Toolbar.__init__(self)
self.modify_bg(0, Gdk.Color(65000, 65000, 65000))
#self.insert(get_separador(draw = False, ancho = 3, expand = False), -1)
self.insert(G.get_separador(draw=False, ancho=0, expand=True), -1)
archivo = os.path.join(JAMediaObjectsPath, "Iconos",
"escalaoriginal.png")
boton = G.get_boton(archivo,
flip=False,
color=Gdk.Color(65000, 65000, 65000),
pixels=G.get_pixels(0.8))
boton.set_tooltip_text("Original")
boton.connect("clicked", self.original)
self.insert(boton, -1)
self.insert(G.get_separador(draw=False, ancho=3, expand=False), -1)
archivo = os.path.join(JAMediaObjectsPath, "Iconos", "alejar.png")
boton = G.get_boton(archivo,
flip=False,
color=Gdk.Color(65000, 65000, 65000),
pixels=G.get_pixels(0.8))
boton.set_tooltip_text("Alejar")
boton.connect("clicked", self.alejar)
self.insert(boton, -1)
self.insert(G.get_separador(draw=False, ancho=3, expand=False), -1)
archivo = os.path.join(JAMediaObjectsPath, "Iconos", "acercar.png")
boton = G.get_boton(archivo,
flip=False,
color=Gdk.Color(65000, 65000, 65000),
pixels=G.get_pixels(0.8))
boton.set_tooltip_text("Acercar")
boton.connect("clicked", self.acercar)
self.insert(boton, -1)
'''
self.insert(G.get_separador(draw = True, ancho = 0, expand = False), -1)
archivo = os.path.join(JAMediaObjectsPath, "Iconos","rotar.png")
boton = G.get_boton(archivo, flip = False, color = Gdk.Color(65000, 65000, 65000))
boton.set_tooltip_text("Rotar")
boton.connect("clicked", self.rotar_izquierda)
self.insert(boton, -1)
self.insert(G.get_separador(draw = False, ancho = 3, expand = False), -1)
archivo = os.path.join(JAMediaObjectsPath, "Iconos","rotar.png")
boton = G.get_boton(archivo, flip = True, color = Gdk.Color(65000, 65000, 65000))
boton.set_tooltip_text("Rotar")
boton.connect("clicked", self.rotar_derecha)
self.insert(boton, -1)
self.insert(G.get_separador(draw = True, ancho = 0, expand = False), -1)'''
self.insert(G.get_separador(draw=False, ancho=0, expand=True), -1)
self.show_all()
def test_color(self):
color = Gdk.Color(100, 200, 300)
self.assertEqual(color.red, 100)
self.assertEqual(color.green, 200)
self.assertEqual(color.blue, 300)
with capture_glib_deprecation_warnings():
self.assertEqual(color, Gdk.Color(100, 200, 300))
self.assertNotEqual(color, Gdk.Color(1, 2, 3))
def __paintMiniPreview(self, ret, canal):
col = 100 * ret / 255
col = 65535 * col / 100
if canal == "RED":
self.tabla.redimg.modify_bg(0, Gdk.Color(col, 0, 0))
elif canal == "GREEN":
self.tabla.greenimg.modify_bg(0, Gdk.Color(0, col, 0))
elif canal == "BLUE":
self.tabla.blueimg.modify_bg(0, Gdk.Color(0, 0, col))
def __init__(self, font):
GObject.GObject.__init__(self)
self.table = Gtk.Table(font.rows, font.cols, True)
self.add(self.table)
self._colour_frame = Gdk.Color(0, 0, 0)
self._colour_bg = Gdk.Color(font.bg['r'], font.bg['g'], font.bg['b'])
self._colour_fg = Gdk.Color(font.fg['r'], font.fg['g'], font.fg['b'])
d = bytes(
[font.fg['r'] // 256, font.fg['g'] // 256, font.fg['b'] // 256] *
(32 * 32))
self.drag_active = GdkPixbuf.Pixbuf.new_from_data(
d, GdkPixbuf.Colorspace.RGB, False, 8, 32, 32, 32 * 3)
d = bytes(
[font.bg['r'] // 256, font.bg['g'] // 256, font.bg['b'] // 256] *
(32 * 32))
self.drag_normal = GdkPixbuf.Pixbuf.new_from_data(
d, GdkPixbuf.Colorspace.RGB, False, 8, 32, 32, 32 * 3)
self.modify_bg(Gtk.StateType.NORMAL, self._colour_frame)
self.pixels = []
for i in range(font.rows):
self.pixels.append([])
for j in range(font.cols):
self.pixels[i].append(Gtk.EventBox())
self.pixels[i][j].modify_bg(Gtk.StateType.ACTIVE,
self._colour_fg)
self.pixels[i][j].modify_bg(Gtk.StateType.NORMAL,
self._colour_bg)
self.pixels[i][j].set_events(
self.pixels[i][j].get_events()
| Gdk.EventMask.POINTER_MOTION_MASK)
self.pixels[i][j].connect("button-press-event",
self.pixel_click)
self.pixels[i][j].connect("drag-motion", self.pixel_drag2)
self.pixels[i][j].drag_source_set(
Gdk.ModifierType.BUTTON1_MASK, [
Gtk.TargetEntry.new(f"pix", Gtk.TargetFlags.SAME_APP,
i * font.cols + j)
], Gdk.DragAction.PRIVATE)
self.pixels[i][j].drag_dest_set(Gtk.DestDefaults.ALL, [
Gtk.TargetEntry.new(f"pix", Gtk.TargetFlags.SAME_APP,
i * font.cols + j)
], Gdk.DragAction.PRIVATE)
self.pixels[i][j].set_size_request(28, 28)
self.table.attach(self.pixels[i][j],
j,
j + 1,
i,
i + 1,
xpadding=1,
ypadding=1)
self._modified = False
self.show_all()
def get_font_color(self, bg_color):
lightness = (((bg_color.red * 299) + (bg_color.green * 587) +
(bg_color.blue * 114)) / 1000)
new_fg_color = Gdk.Color(0, 0, 0)
if lightness < 0.5:
new_fg_color = Gdk.Color(65535, 65535, 65535)
return new_fg_color
def __init__(this):
Gtk.Window.__init__(this, title="TEST")
this.set_position(Gtk.WindowPosition.CENTER)
this.set_border_width(10)
this.set_default_size(200, 200)
green = Gdk.Color(0x0000, 0xffff, 0x0000)
red = Gdk.Color(0xffff, 0x0000, 0x0000)
this.modify_bg(0, green) # First argument is the state
this.modify_fg(0, red)
l = Gtk.Label("Hello")
this.add(l)
def __init__(self, font):
GObject.GObject.__init__(self)
self.fg = (b"%c%c%c" %
(font.fg['r'] >> 8, font.fg['g'] >> 8, font.fg['b'] >> 8))
self.bg = (b"%c%c%c" %
(font.bg['r'] >> 8, font.bg['g'] >> 8, font.bg['b'] >> 8))
self.highlight_colour = Gdk.Color(65535, 0, 0)
tc = self.get_style_context().get_background_color(
Gtk.StateFlags.NORMAL)
#print(tc)
#tc = tc.bg[Gtk.StateFlags.NORMAL]
self.normal_colour = Gdk.Color(tc.red, tc.green, tc.blue)
self.font = font
self.chars_per_line = int(floor(sqrt(font.chars)))
self.lines = int(ceil(font.chars / self.chars_per_line))
self.table = Gtk.Table(self.lines, self.chars_per_line, True)
self.add_with_viewport(self.table)
self.pbf = []
self.img = []
self.img_border = []
for c in range(font.chars):
# generate a pixmap of the character and display it in the table
# first make a string from the font entry
d = b""
for i in range(font.rows):
for j in range(font.cols):
if font.get_character(c)[i][j]:
d += self.fg
else:
d += self.bg
# now make a new pixbuf from this
self.pbf.append(
GdkPixbuf.Pixbuf.new_from_data(d, GdkPixbuf.Colorspace.RGB,
False, 8, font.cols, font.rows,
font.cols * 3))
row = c / self.chars_per_line
col = c % self.chars_per_line
self.img.append(Gtk.Image.new_from_pixbuf(self.pbf[c]))
self.img_border.append(Gtk.EventBox())
self.img_border[c].add(self.img[c])
self.img_border[c].connect("button-press-event", self.char_click,
c)
self.img[c].set_padding(1, 1)
self.table.attach(self.img_border[c], col, col + 1, row, row + 1)
self.show_all()
def test_color_floats(self):
self.assertEqual(Gdk.Color(13107, 21845, 65535),
Gdk.Color.from_floats(0.2, 1.0 / 3.0, 1.0))
self.assertEqual(Gdk.Color(13107, 21845, 65535).to_floats(),
(0.2, 1.0 / 3.0, 1.0))
self.assertEqual(Gdk.RGBA(0.2, 1.0 / 3.0, 1.0, 0.5).to_color(),
Gdk.Color.from_floats(0.2, 1.0 / 3.0, 1.0))
self.assertEqual(Gdk.RGBA.from_color(Gdk.Color(13107, 21845, 65535)),
Gdk.RGBA(0.2, 1.0 / 3.0, 1.0, 1.0))
def draw(self):
"""Updates the display with the selected paragraph."""
p = self.current_p
self.pname.set_text('<span size="larger" weight="bold">%s</span>' %
self.current_name)
self.pname.set_use_markup(True)
descr = p.get_description()
self.pdescription.set_text(descr or _("No description available"))
font = p.get_font()
self.top.get_object("size").set_value(font.get_size())
if font.get_type_face() == FONT_SERIF:
self.top.get_object("roman").set_active(1)
else:
self.top.get_object("swiss").set_active(1)
self.top.get_object("bold").set_active(font.get_bold())
self.top.get_object("italic").set_active(font.get_italic())
self.top.get_object("underline").set_active(font.get_underline())
if p.get_alignment() == PARA_ALIGN_LEFT:
self.top.get_object("lalign").set_active(1)
elif p.get_alignment() == PARA_ALIGN_RIGHT:
self.top.get_object("ralign").set_active(1)
elif p.get_alignment() == PARA_ALIGN_CENTER:
self.top.get_object("calign").set_active(1)
else:
self.top.get_object("jalign").set_active(1)
self.top.get_object("rmargin").set_value(p.get_right_margin())
self.top.get_object("lmargin").set_value(p.get_left_margin())
self.top.get_object("pad").set_value(p.get_padding())
self.top.get_object("tmargin").set_value(p.get_top_margin())
self.top.get_object("bmargin").set_value(p.get_bottom_margin())
self.top.get_object("indent").set_value(p.get_first_indent())
self.top.get_object("tborder").set_active(p.get_top_border())
self.top.get_object("lborder").set_active(p.get_left_border())
self.top.get_object("rborder").set_active(p.get_right_border())
self.top.get_object("bborder").set_active(p.get_bottom_border())
self.fg_color = font.get_color()
c = Gdk.Color(self.fg_color[0] << 8, self.fg_color[1] << 8,
self.fg_color[2] << 8)
self.top.get_object("color").set_color(c)
self.top.get_object('color_code').set_text("#%02X%02X%02X" %
self.fg_color)
self.bg_color = p.get_background_color()
c = Gdk.Color(self.bg_color[0] << 8, self.bg_color[1] << 8,
self.bg_color[2] << 8)
self.top.get_object("bgcolor").set_color(c)
self.top.get_object('bgcolor_code').set_text("#%02X%02X%02X" %
self.bg_color)
def load_data(self):
if "saved-data" in self.metadata:
self.background_color = Gdk.Color(
*tuple(eval(self.metadata["background-color"])))
self.text_color = Gdk.Color(
*tuple(eval(self.metadata["text-color"])))
self.font_size = int(self.metadata["font-size"])
self.button_position = Gtk.PackType.START if self.metadata[
"button-position"] == "Left" else Gtk.PackType.END
else:
self.background_color = Gdk.Color(0, 0, 0)
self.text_color = Gdk.Color(65535, 65535, 65535)
self.font_size = 12
self.button_position = Gtk.PackType.END
def __init__(self):
Gtk.Toolbar.__init__(self)
self.modify_bg(0, Gdk.Color(0, 0, 0))
self.insert(G.get_separador(draw=False, ancho=3, expand=False), -1)
item = Gtk.ToolItem()
self.label = Gtk.Label("")
self.label.modify_fg(0, Gdk.Color(65000, 65000, 65000))
self.label.show()
item.add(self.label)
self.insert(item, -1)
self.show_all()
def __init__(self, _sheriff):
super(SheriffCommandConsole, self).__init__()
self.stdout_maxlines = 2000
self.max_kb_per_sec = 0
self.max_chars_per_2500_ms = 0
self.sheriff = _sheriff
# stdout textview
self.stdout_textview = Gtk.TextView()
self.stdout_textview.set_property("editable", False)
self.sheriff_tb = self.stdout_textview.get_buffer()
self.add(self.stdout_textview)
stdout_adj = self.get_vadjustment()
stdout_adj.scrolled_to_end = 1
stdout_adj.connect("changed", self.on_adj_changed)
stdout_adj.connect("value-changed", self.on_adj_value_changed)
# deal with keyboard shortcuts
self.connect("key-release-event", self.on_key_release)
# add callback so we can add a clear option to the default right click popup
self.stdout_textview.connect("populate-popup",
self.on_tb_populate_menu)
# set some default appearance parameters
self.font_str = "Monospace 10"
self.set_font(self.font_str)
self.base_color = Gdk.Color(65535, 65535, 65535)
self.text_color = Gdk.Color(0, 0, 0)
self.set_background_color(self.base_color)
self.set_text_color(self.text_color)
# stdout rate limit maintenance events
GObject.timeout_add(500, self._stdout_rate_limit_upkeep)
self.sheriff.add_listener(self)
self._cmd_extradata = {}
self.output_sub = rospy.Subscriber("/procman/output", ProcmanOutput,
self.on_procman_output)
self.text_tags = {"normal": Gtk.TextTag.new("normal")}
for tt in list(self.text_tags.values()):
self.sheriff_tb.get_tag_table().add(tt)
self.set_output_rate_limit(DEFAULT_MAX_KB_PER_SECOND)
def _do_update_control(self, control):
if self.connected:
if control == self.get_control_for_hint(g15driver.HINT_MKEYS):
self._do_set_mkey_lights()
elif control == self.get_control_for_hint(g15driver.HINT_DIMMABLE):
if isinstance(control.value, int):
v = (65535 / control.upper) * control.value
self.event_box.modify_bg(Gtk.StateType.NORMAL,
Gdk.Color(v, v, v))
else:
self.event_box.modify_bg(
Gtk.StateType.NORMAL,
Gdk.Color(control.value[0] << 8, control.value[1] << 8,
control.value[2] << 8))
def _update_selection_tag(self):
context = self._view.get_style_context()
state = context.get_state()
fg_rgba = context.get_color(state)
bg_rgba = context.get_background_color(state)
# TODO: Use GdkRGBA directly when possible
fg = Gdk.Color(fg_rgba.red * 65535, fg_rgba.green * 65535,
fg_rgba.blue * 65535)
bg = Gdk.Color(bg_rgba.red * 65535, bg_rgba.green * 65535,
bg_rgba.blue * 65535)
self._selection_tag.props.foreground_gdk = fg
self._selection_tag.props.background_gdk = bg
def __init__(self, scale):
GObject.GObject.__init__(self)
self.scale = scale
self.connect("draw", self.draw)
self.connect("size-allocate", self.on_size_allocate)
self.color_bg = Gdk.Color(0, 0, 0)
self.color_value = None
self.color_mark = Gdk.Color(int(65535 * 0.2), int(65535 * 0.2),
int(65535 * 0.2))
self.width = 0
self.height = 0
self.cache_surface = None
def init_gnuhealth_env(self):
# Init GNU Health CLI
self.cli = None
self.cli = Gtk.Entry()
# Maximum of 64 chars
self.cli.set_max_length(64)
self.cli.set_placeholder_text(_("GNU Health Command"))
#CLI colors
self.cli.modify_base(Gtk.StateType.NORMAL, Gdk.Color(6,69,72))
self.cli.modify_text(Gtk.StateType.NORMAL, Gdk.Color(0,0,0))
# Init the GNU Health Status Bar
self.statusbar = None
self.footer = None
self.ghheader = None
self.ghheader_contents = None
self.footer_contents = None
self.statusbar = Gtk.Statusbar()
self.context_id = self.statusbar.get_context_id("Statusbar")
self.ghheader = Gtk.HBox()
self.ghheader.set_size_request(200,-1)
# Main footer
self.ghfooter = Gtk.HBox()
# Create initally a 1x3 table for the footer, leaving the
# middle column empty
self.ghfooter_contents = Gtk.Table(1,3,True)
# Create initally a 1x3 table for the header
self.ghheader_contents = Gtk.Table(1,3,True)
# Set GNU Health Footer
self.set_ghfooter()
cli_position = self.cli_position
#Default CLI position at top
if (not cli_position or cli_position == 'top'):
self.ghheader_contents.attach(self.cli, 0, 1, 0, 1)
self.ghheader.pack_start(self.ghheader_contents,expand=True,
fill=True, padding=0)
self.vbox.pack_start (self.ghheader,
expand=False, fill=False, padding=0)
self.vbox.reorder_child(self.ghheader, 1)
self.ghheader.show_all()
def getHeadingColor( self ):
try:
color = self.headingColor.get_color()
except:
color = Gdk.Color(0, 0, 0)
self.headingColor.get_color(color)
return self.gdkColorToString( color )
def getBorderColor( self ):
try:
color = self.borderColor.get_color()
except:
color = Gdk.Color(0, 0, 0)
self.borderColor.get_color(color)
return self.gdkColorToString( color )
