def __init__(self, weh):
super(GTKstrip, self).__init__()
self.label = "GTKstrip"
chars = "ESKISTLFÜNFZEHNZWANZIGDREIVIERTELTGNACHVORJMHALBQZWÖLFPZWEINSIEBENKDREIRHFÜNFELFNEUNVIERWACHTZEHNRSBSECHSFMUHR...."
self.labels = []
self.colors = []
self.weh = weh
self.win = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.win.connect("delete_event", self.delete_event)
self.win.connect("destroy", self.destroy)
self.win.connect("key_press_event", self.key_press_event)
table = gtk.Table(11, 11, True)
x = 0
y = 0
for i in unicode(chars):
label = gtk.Label(i)
self.labels.append(label)
self.colors.append(Color(0, 0, 0))
table.attach(label, x, x + 1, y, y + 1, FILL, FILL)
x += 1
if x == 11:
x = 0
y += 1
attrs = pango.AttrList()
# attrs.insert(pango.AttrLanguage("de"))
attrs.insert(pango.AttrForeground(0, 0, 0))
attrs.insert(pango.AttrSize(30 * 1000))
attrs.insert(pango.AttrBackground(0, 0, 0))
label.set_attributes(attrs)
label.show()
color = gtk.gdk.color_parse('#000000')
self.win.modify_bg(gtk.STATE_NORMAL, color)
self.win.add(table)
self.win.show_all()
def __init__(self, parent=None, size=(1920, 1080)):
self.superior = parent
wprop = size[0] / 1920.0
hprop = size[1] / 1080.0
self.wprop = wprop
self.hprop = hprop
gtk.HBox.__init__(self, False, int(wprop * 5))
self.set_border_width(int(wprop * 20))
self.vbox = gtk.VBox(False, 0)
self.buttons = gtk.VButtonBox()
self.buttons.set_layout(gtk.BUTTONBOX_START)
self.buttons.set_spacing(int(wprop * 5))
scrolled = gtk.ScrolledWindow()
scrolled.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.list, self.view = self.prepare_view()
self.view.get_selection().connect("changed", self.append_info)
scrolled.add(self.view)
sidebox = gtk.VBox(False, 0)
frame = gtk.Frame()
label = gtk.Label("Profile Tracks")
alist = pango.AttrList()
font = pango.FontDescription("bold " + str(int(self.hprop * 15)))
attr = pango.AttrFontDesc(font, 0, -1)
alist.insert(attr)
label.set_attributes(alist)
frame.set_label_widget(label)
frame.set_label_align(0.5, 0.5)
frame.set_shadow_type(gtk.SHADOW_ETCHED_IN)
align = gtk.Alignment(1, 0.5, 0.95, 0.9)
self.sidetable = gtk.Table(homogeneous=True)
self.sidetable.set_size_request(int(wprop * 300), -1)
align.add(self.sidetable)
frame.add(align)
self.vbox.pack_end(scrolled, True, True, 0)
self.pack_start(self.vbox, True, True, 0)
sidebox.pack_start(self.buttons, False, False, int(hprop * 10))
sidebox.pack_start(frame, False, False, int(hprop * 15))
self.pack_start(sidebox, False, False, int(wprop * 15))
def get_label_attributes(readonly, required):
"Return the pango attributes applied to a label according to its state"
if readonly:
style = pango.STYLE_NORMAL
weight = pango.WEIGHT_NORMAL
else:
style = pango.STYLE_ITALIC
if required:
weight = pango.WEIGHT_BOLD
else:
weight = pango.WEIGHT_NORMAL
attrlist = pango.AttrList()
if hasattr(pango, 'AttrWeight'):
attrlist.change(pango.AttrWeight(weight, 0, -1))
if hasattr(pango, 'AttrStyle'):
attrlist.change(pango.AttrStyle(style, 0, -1))
return attrlist
def resize(self):
"""Adapts GUI elements to the screen size"""
buttonlist = [
"playbutton", "editbutton", "ingestbutton", "deletebutton"
]
size = context.get_mainwindow().get_size()
wprop = size[0] / 1920.0
hprop = size[1] / 1080.0
vbar = self.scroll.get_vscrollbar()
vbar.set_size_request(int(wprop * 6), -1)
self.renders[0].set_property('height', int(hprop * 40))
self.renders[0].set_property('width-chars', int(wprop * 56)) #name
self.renders[1].set_property('width-chars', int(wprop * 14)) #size
self.renders[2].set_property('width-chars', int(wprop * 10)) #duration
self.renders[3].set_property('width-chars', int(wprop * 23)) #date
self.renders[5].set_property('width-chars',
int(wprop * 27)) #presenter
self.renders[6].set_property('width-chars', int(wprop * 33.5)) #series
#self.renders[7].set_property('width-chars',int(wprop*12.5))#statusess
self.renders[8].set_property('width-chars',
int(wprop * 14)) #operations less
fsize = 12 * hprop
for cell in self.renders:
font = pango.FontDescription(str(fsize))
cell.set_property('font-desc', font)
for column in self.vista.get_columns():
first = column.get_widget()
if not first:
label = gtk.Label(" " + column.get_title())
else:
label = column.get_widget()
attr = pango.AttrList()
attr.insert(pango.AttrFontDesc(font, 0, -1))
label.set_attributes(attr)
if not first:
label.show()
column.set_widget(label)
column.queue_resize()
self.do_resize(buttonlist)
return True
def set_attr(layout):
attr = pango.AttrList()
size = pango.AttrSize(int(11.5 * pango.SCALE), 0, -1)
attr.insert(size)
if customAttr and customAttr.attributes_dict:
attributes_dict = customAttr.attributes_dict
if attributes_dict.has_key("regex_include_match"):
start, end = attributes_dict["regex_include_match"]
pango_color = pango.AttrBackground(self.include_color.red, self.include_color.green,
self.include_color.blue, start, end)
attr.insert(pango_color)
if attributes_dict.has_key("regex_exclude_match"):
start, end = attributes_dict["regex_exclude_match"]
pango_color = pango.AttrForeground(self.exclude_color.red, self.exclude_color.green,
self.exclude_color.blue, start, end)
attr.insert(pango_color)
layout.set_attributes(attr)
def main():
if len(sys.argv) != 3:
usage()
sys.exit(1)
version = sys.argv[1]
imgpath = sys.argv[2]
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 140,24)
ctx = cairo.Context(surface)
c = pangocairo.CairoContext(ctx)
l = c.create_layout()
font_desc = pango.FontDescription('Grixel Acme 7 Wide Bold 14')
l.set_font_description(font_desc)
fo = cairo.FontOptions()
fo.set_antialias(cairo.ANTIALIAS_NONE)
c.set_font_options(fo)
pangocairo.context_set_font_options (l.get_context(), fo)
l.set_text('theory')
set_context_color(ctx,'#333333')
ctx.move_to(4,-8)
c.show_layout(l)
c.update_layout(l)
l = c.create_layout()
font_desc = pango.FontDescription('Grixel Acme 7 Wide 7')
attr = pango.AttrList()
attr.insert(pango.AttrLetterSpacing(1200,0,100))
l.set_attributes(attr)
l.set_font_description(font_desc)
fo = cairo.FontOptions()
fo.set_antialias(cairo.ANTIALIAS_NONE)
pangocairo.context_set_font_options (l.get_context(), fo)
l.set_text(version)
ctx.move_to(105,8)
ctx.set_source_rgb (.33,.33,.33)
c.show_layout(l)
c.update_layout(l)
surface.write_to_png(imgpath)
def __init__(self,
coords,
pango_context,
thought_number,
save,
undo,
loading,
background_color,
foreground_color,
name="thought"):
super(TextThought, self).__init__(coords, save, name, undo,
background_color, foreground_color)
self.index = 0
self.end_index = 0
self.bytes = ""
self.bindex = 0
self.text_element = save.createTextNode("GOOBAH")
self.element.appendChild(self.text_element)
self.layout = None
self.identity = thought_number
self.pango_context = pango_context
self.moving = False
self.preedit = None
self.attrlist = None
self.attributes = pango.AttrList()
self.current_attrs = []
self.double_click = False
self.orig_text = None
if prefs.get_direction() == gtk.TEXT_DIR_LTR:
self.pango_context.set_base_dir(pango.DIRECTION_LTR)
else:
self.pango_context.set_base_dir(pango.DIRECTION_RTL)
self.b_f_i = self.bindex_from_index
margin = utils.margin_required(utils.STYLE_NORMAL)
if coords:
self.ul = (coords[0] - margin[0], coords[1] - margin[1])
else:
self.ul = None
self.all_okay = True
def __init__(self):
gtk.Table.__init__(self)
self.resize(4,110)
self.set_homogeneous(True)
self.mute = False
self.vumeter=gtk.ProgressBar()
#numbers
minimum = gtk.Label("-100")
maximum = gtk.Label("0dB")
mark = gtk.Label("-10")
sixty = gtk.Label("-60")
thirty = gtk.Label("-30")
labels= [minimum,sixty,thirty,mark,maximum]
for label in labels:
label.set_justify(gtk.JUSTIFY_CENTER)
alist = pango.AttrList()
font=pango.FontDescription("bold")
attr=pango.AttrFontDesc(font,0,-1)
alist.insert(attr)
label.set_attributes(alist)
#marks
mark100=gtk.VSeparator()
mark60=gtk.VSeparator()
mark30=gtk.VSeparator()
mark10=gtk.VSeparator()
mark0=gtk.VSeparator()
# attach to widget
self.attach(mark100,5,6,1,2,gtk.EXPAND|gtk.FILL,gtk.EXPAND|gtk.FILL,0,0)#-100
self.attach(mark60,45,46,1,2,gtk.EXPAND|gtk.FILL,gtk.EXPAND|gtk.FILL,0,0)#-60
self.attach(mark30,75,76,1,2,gtk.EXPAND|gtk.FILL,gtk.EXPAND|gtk.FILL,0,0)#-30
self.attach(mark10,95,96,1,2,gtk.EXPAND|gtk.FILL,gtk.EXPAND|gtk.FILL,0,0)#-10
self.attach(mark0,105,106,1,2,gtk.EXPAND|gtk.FILL,gtk.EXPAND|gtk.FILL,0,0)#0
self.attach(minimum,0,10,0,1,gtk.EXPAND|gtk.FILL,gtk.EXPAND|gtk.FILL,0,0)#-100
self.attach(sixty,40,50,0,1,gtk.EXPAND|gtk.FILL,gtk.EXPAND|gtk.FILL,0,0)#-60
self.attach(thirty,70,80,0,1,gtk.EXPAND|gtk.FILL,gtk.EXPAND|gtk.FILL,0,0)#-30
self.attach(mark,90,100,0,1,gtk.EXPAND|gtk.FILL,gtk.EXPAND|gtk.FILL,0,0)#-10
self.attach(maximum,100,110,0,1,gtk.EXPAND|gtk.FILL,gtk.EXPAND|gtk.FILL,0,0)#0
self.attach(self.vumeter,5,105,2,4,gtk.EXPAND|gtk.FILL,gtk.EXPAND|gtk.FILL,0,0)
def layer_name_datafunc(self, column, renderer, model, tree_iter,
*data_etc):
layer = model.get_value(tree_iter, 0)
path = model.get_path(tree_iter)
name = layer.name
attrs = pango.AttrList()
if not name:
layer_num = self.app.doc.get_number_for_nameless_layer(layer)
name = _(u"Untitled layer #%d") % layer_num
markup = "<small><i>%s</i></small> " % (escape(name), )
if gtk2compat.USE_GTK3:
parse_result = pango.parse_markup(markup, -1, '\000')
parse_ok, attrs, name, accel_char = parse_result
assert parse_ok
else:
parse_result = pango.parse_markup(markup)
attrs, name, accel_char = parse_result
renderer.set_property("attributes", attrs)
renderer.set_property("text", name)
def draw_text(self, text='Hello'):
self.window.window.move_resize(700, 750, 1280, 80)
ctx = self.window.window.cairo_create()
ptx = self.window.get_pango_context()
ctx.save()
ctx.set_source_rgba(0.3, 0.0, 0.0, 0.3)
ctx.set_operator(cairo.OPERATOR_SOURCE)
ctx.paint()
ctx.restore()
font = pango.FontDescription()
font.set_family("sans")
font.set_size(32 * pango.SCALE)
ctx.move_to(400, 0)
if not self.layout:
# layout = pango.Layout(ptx)
# layout = ctx.create_layout()
# layout = self.object.get_layout()
layout = self.object.create_pango_layout(text)
layout.set_font_description(font)
layout.set_text(text)
attrs = pango.AttrList()
attr = pango.AttrForeground(65535, 0, 0, 0, -1)
attrs.insert(attr)
layout.set_attributes(attrs)
self.layout = layout
ctx.show_layout(layout)
layout = self.layout
layout.set_alignment(pango.ALIGN_RIGHT)
print layout.get_alignment()
print layout.get_pixel_size()
layout.set_text(text)
ctx.set_source_rgba(1, 0, 0, 0.5)
ctx.fill()
ctx.show_layout(layout)
def __init__(self, dial_group = None, window_group = None,
window_title = "", additional_text = None,
actionok = None, actioncancel = None):
gtk.Dialog.__init__(self, window_title, None,
gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK))
if window_group is not None:
window_group.add_window(self)
self.set_resizable(False)
self.connect("close", self.respond, actionok, actioncancel)
self.connect("response", self.respond, actionok, actioncancel)
self.connect("window-state-event", self.window_attn)
self.set_default_response(gtk.RESPONSE_OK)
hbox = gtk.HBox(False, 20)
hbox.set_border_width(20)
self.vbox.pack_start(hbox, True, True, 0)
hbox.show()
image = gtk.Image()
image.set_from_stock(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_DIALOG)
hbox.pack_start(image, True, True, 0)
image.show()
vbox = gtk.VBox()
vbox.set_spacing(8)
hbox.pack_start(vbox, True, True, 0)
vbox.show()
if additional_text is not None:
if type(additional_text) is str:
additional_text = additional_text.splitlines()
for each in additional_text:
label = gtk.Label()
attrlist = pango.AttrList()
attrlist.insert(pango.AttrSize(12500, 0, len(each)))
label.set_attributes(attrlist)
label.set_text(each)
vbox.add(label)
label.show()
if dial_group is not None:
dial_group.add(self)
self.dial_group = dial_group
def set_window_size(self, setting):
"""Set window and label size."""
window_width = self.screen_width
window_height = -1
if setting == SIZE_LARGE:
window_height = 24 * self.screen_height / 100
if setting == SIZE_MEDIUM:
window_height = 12 * self.screen_height / 100
if setting == SIZE_SMALL:
window_height = 8 * self.screen_height / 100
attr = pango.AttrList()
attr.change(pango.AttrSize((50 * window_height / 100) * 1000, 0, -1))
attr.change(pango.AttrFamily("Sans", 0, -1))
attr.change(pango.AttrWeight(pango.WEIGHT_BOLD, 0, -1))
attr.change(pango.AttrForeground(65535, 65535, 65535, 0, -1))
self.label.set_attributes(attr)
self.resize(window_width, window_height)
def __init__(self, parent_window, actions_label):
gtk.EventBox.__init__(self)
self.label = gtk.Label()
self.button_actions = ButtonMenu(parent_window, actions_label)
attributes = pango.AttrList()
attributes.insert(pango.AttrWeight(700, 0, -1))
attributes.insert(pango.AttrSize(16000, 0, -1))
self.label.set_attributes(attributes)
self.label.set_ellipsize(pango.ELLIPSIZE_END)
self.label.set_alignment(0.0, 0.5)
self.label.set_padding(2, 0)
hbox = gtk.HBox()
hbox.pack_start(self.label)
hbox.pack_start(self.button_actions, False, False)
self.add(hbox)
self.connect("realize", self.on_realize)
self.show_all()
def _generate_thumb_with_text(self):
""" Generate the text on the pixbuf """
# This technique is used to compose image with text
# create a pixmap with the data of the pixbuf then insert text
# cf. pygtk FAQ How do I draw a text [or something else] on a gtk.gdk.pixbuf? for mor explication
# (http://faq.pygtk.org/index.py?req=show&file=faq08.020.htp )
pixmap, mask = self._pixbuf_thumb.render_pixmap_and_mask()
# graphic context and Drawarea any created to allow generation of pixbuf composition
gc = pixmap.new_gc()
area = gtk.DrawingArea()
# create pango layout
self.pangolayout = area.create_pango_layout("")
# extract only the image name without extenstion
text_buffer, ext = os.path.splitext(self._name)
text_buffer = " " + text_buffer + " "
self.pangolayout.set_text(text_buffer)
# set text attributes
attrs = pango.AttrList()
attrs.insert(pango.AttrFamily(LCONST.THUMB_TEXT_FAMILY, 0, -1))
attrs.insert(pango.AttrStyle(pango.STYLE_ITALIC, 0, -1))
attrs.insert(
pango.AttrForeground(LCONST.THUMB_TEXT_COLOR[0],
LCONST.THUMB_TEXT_COLOR[1],
LCONST.THUMB_TEXT_COLOR[2], 0, -1))
attrs.insert(pango.AttrBackground(0, 0, 0, 0, -1))
attrs.insert(pango.AttrSize(LCONST.THUMB_TEXT_SIZE, 0, -1))
self.pangolayout.set_attributes(attrs)
# compute text layout position and set it on pixmap
(w, h) = (self._pixbuf_thumb.get_width(),
self._pixbuf_thumb.get_height())
(lw, lh) = self.pangolayout.get_pixel_size()
pixmap.draw_layout(gc, (w - lw) // 2, (h - lh - 2), self.pangolayout)
# function get_from_drawable gets the the pixbuf from the pixmap
# no need to affect resuly to a new pisbuf: self._pixbuf_thumb is changed whe get_from_drawable is used
self._pixbuf_thumb.get_from_drawable(pixmap, pixmap.get_colormap(), 0,
0, 0, 0, -1, -1)
def __begin(self, ctx):
""" callback dor drag-begin signal
Enable the display of moved rows.
At MAX 3 rows ares shown during motion.
"""
model, paths = self.get_selection().get_selected_rows()
MAX = 3
if paths:
icons = map(self.create_row_drag_icon, paths[:MAX])
height = (
sum(map(lambda s: s.get_size()[1], icons))-2*len(icons))+2
width = max(map(lambda s: s.get_size()[0], icons))
final = gtk.gdk.Pixmap(icons[0], width, height)
gc = gtk.gdk.GC(final)
gc.copy(self.style.fg_gc[gtk.STATE_NORMAL])
gc.set_colormap(self.window.get_colormap())
count_y = 1
for icon in icons:
w, h = icon.get_size()
final.draw_drawable(gc, icon, 1, 1, 1, count_y, w-2, h-2)
count_y += h - 2
if len(paths) > MAX:
count_y -= h - 2
bgc = gtk.gdk.GC(final)
bgc.copy(self.style.base_gc[gtk.STATE_NORMAL])
final.draw_rectangle(bgc, True, 1, count_y, w-2, h-2)
more = ("and %d more...") % (len(paths) - MAX + 1)
layout = self.create_pango_layout(more)
attrs = pango.AttrList()
attrs.insert(pango.AttrStyle(pango.STYLE_ITALIC, 0, len(more)))
layout.set_attributes(attrs)
layout.set_width(pango.SCALE * (w - 2))
lw, lh = layout.get_pixel_size()
final.draw_layout(gc, (w-lw)//2, count_y + (h-lh)//2, layout)
final.draw_rectangle(gc, False, 0, 0, width-1, height-1)
self.drag_source_set_icon(final.get_colormap(), final)
else:
gobject.idle_add(ctx.drag_abort, gtk.get_current_event_time())
self.drag_source_set_icon_stock(gtk.STOCK_MISSING_IMAGE)
def on_configure(self, _, event):
window_height = event.height
attr = pango.AttrList()
attr.change(pango.AttrSize(int(self.options['fontsize']) * 1000, 0, -1))
attr.change(pango.AttrFamily(self.options['font'], 0, -1))
attr.change(pango.AttrWeight(pango.WEIGHT_BOLD, 0, -1))
fgcolor = gtk.gdk.color_parse(self.fg)
attr.change(pango.AttrForeground(
fgcolor.red, fgcolor.green, fgcolor.blue, 0, -1))
self.pos_x = event.x
self.pos_y = event.y
if self.timer:
self.timer.cancel()
self.timer = Timer(self.options['timeout'], self.on_timeout)
self.timer.start()
self.label.set_attributes(attr)
def on_type_entry_changed(self, *args):
if not self.start_time:
self.start_time = time.time()
cur_text = unicode(self.type_entry.get_text())
bad_idx = []
for i, c in enumerate(cur_text):
if c != self.totype_text[i]:
bad_idx.append(i)
attrs = pango.AttrList()
for idx in bad_idx:
# Pango layout needs byte index not char one O_o
pidx = len(self.totype_text[:idx].encode('utf-8'))
Attr = pango.AttrBackground if self.totype_text[
idx] == ' ' else pango.AttrForeground
attrs.change(Attr(65535, 0, 0, pidx, pidx + 1))
self.totype_entry.get_layout().set_attributes(attrs)
self.totype_entry.queue_draw()
def make_popup_for(self, pos):
"""Generate and return a context menu for the given entry index"""
popup = gtk.Menu()
entry = self.entries[self.data[pos][3]]
# TODO: If there's more than one install prefix detected, group and
# provide section headers.
# (eg. multiple versions of the same game installed in parallel)
default_cmd = entry.default_launcher
for cmd in sorted(entry.commands,
key=lambda x: (x != default_cmd, x.role, x.name)):
# TODO: Move this into the frontend agnostic code
# TODO: Use the role name, falling back to Play only if unknown
# TODO: Sort by role
# TODO: Put a separator between the Play links and the inst/uninst
name = cmd.name if cmd.name != entry.name else 'Play'
# TODO: Add an "Are you sure?" dialog for install/uninstall
item = gtk.MenuItem(name)
item.connect('activate', lambda _, cmd=cmd: cmd.run())
popup.add(item)
# TODO: Actually use a customizable default setting
if cmd == default_cmd:
attrs = pango.AttrList()
attrs.insert(pango.AttrWeight(600, end_index=len(name)))
item.get_child().set_attributes(attrs)
popup.add(gtk.SeparatorMenuItem())
mi_rename = gtk.MenuItem("Rename...")
mi_rename.connect('activate', self.on_mi_rename_activate, pos)
popup.add(mi_rename)
mi_hide = gtk.MenuItem("Hide")
mi_hide.connect('activate', self.on_mi_hide_activate, pos)
popup.add(mi_hide)
popup.show_all()
return popup
def gfx_draw_axes(self):
axes = np.identity(3) * 32
axes[0] = np.dot(self.rotation, axes[0])
axes[1] = np.dot(self.rotation, axes[1])
axes[2] = np.dot(self.rotation, axes[2])
x0 = 48
y0 = self.height - 48
self.gfx_draw_line(x0, y0, x0 + axes[0][0], y0 - axes[0][1])
self.gfx_draw_line(x0, y0, x0 + axes[1][0], y0 - axes[1][1])
self.gfx_draw_line(x0, y0, x0 + axes[2][0], y0 - axes[2][1])
font = pango.FontDescription("courier sans 12")
X = self.area.create_pango_layout("x")
Y = self.area.create_pango_layout("y")
Z = self.area.create_pango_layout("z")
attr = pango.AttrList()
fg = pango.AttrForeground(65535, 0, 0, 0, -1)
attr.insert(fg)
X.set_alignment(pango.ALIGN_CENTER)
Y.set_alignment(pango.ALIGN_CENTER)
Z.set_alignment(pango.ALIGN_CENTER)
X.set_font_description(font)
Y.set_font_description(font)
Z.set_font_description(font)
X.set_attributes(attr)
Y.set_attributes(attr)
Z.set_attributes(attr)
self.pixmap.draw_layout(
self.black_gc,
int(x0 + axes[0][0]) - X.get_pixel_size()[0] / 2,
int(y0 - axes[0][1]) - X.get_pixel_size()[1], X)
self.pixmap.draw_layout(
self.black_gc,
int(x0 + axes[1][0]) - Y.get_pixel_size()[0] / 2,
int(y0 - axes[1][1]) - Y.get_pixel_size()[1], Y)
self.pixmap.draw_layout(
self.black_gc,
int(x0 + axes[2][0]) - Z.get_pixel_size()[0] / 2,
int(y0 - axes[2][1]) - Z.get_pixel_size()[1], Z)
def IconButton(c, box, icon, text_1, text_2, width, height, margin, f_1, p_1):
hbox = gtk.HBox()
hbox.set_border_width(margin)
button = gtk.Button()
button.set_size_request(width, height)
button.connect("clicked", f_1, *p_1)
inbox = gtk.VBox()
inbox.set_border_width(5)
image = gtk.Image()
image.set_from_file(icon)
attr = pango.AttrList()
size = pango.AttrSize(20000, 0, -1)
attr.insert(size)
title = gtk.Label()
title.set_markup(text_1)
title.set_justify(gtk.JUSTIFY_CENTER)
title.set_attributes(attr)
description = gtk.Label()
description.set_markup(text_2)
description.set_line_wrap(True)
description.set_justify(gtk.JUSTIFY_CENTER)
inbox.pack_start(image, False, False, 0)
inbox.pack_start(title, False, False, 0)
inbox.pack_start(gtk.HSeparator(), False, False, 5)
inbox.pack_start(description, False, False, 0)
button.add(inbox)
hbox.pack_start(button, False, False, 0)
box.pack_start(hbox, False, False, 0)
return button
def SetHeadingStyle(self, items):
for item in items:
if item not in self.headingsToColor:
self.headingsToColor.append(item)
HeadingStyle = pango.AttrList()
attr = pango.AttrSize(12000, 0, -1)
HeadingStyle.insert(attr)
if self.usecustomcolor:
headingcolor = gtk.gdk.color_parse(self.customheadingcolor)
attr = pango.AttrForeground(headingcolor.red, headingcolor.green,
headingcolor.blue, 0, -1)
HeadingStyle.insert(attr)
# else:
# headingcolor = self.window.rc_get_style().bg[ gtk.STATE_SELECTED ]
attr = pango.AttrWeight(pango.WEIGHT_BOLD, 0, -1)
HeadingStyle.insert(attr)
for item in items:
item.set_attributes(HeadingStyle)
def setup(self):
if self.gui:
import pango
self.core.register_ui("opengl_window",
"Dimension",
self.gui.get_object("DimensionTable"),
weight=20)
self.core.get("register_display_item")("show_dimensions",
"Show Dimensions", 60),
# Color the dimension value according to the axes.
# For "y" axis: 100% green is too bright on light background - we
# reduce it a bit.
for color, names in ((pango.AttrForeground(65535, 0, 0, 0, 100),
("model_dim_x_label", "model_dim_x",
"ModelCornerXMax", "ModelCornerXMin",
"ModelCornerXSpaces")),
(pango.AttrForeground(0, 50000, 0, 0, 100),
("model_dim_y_label", "model_dim_y",
"ModelCornerYMax", "ModelCornerYMin",
"ModelCornerYSpaces")),
(pango.AttrForeground(0, 0, 65535, 0, 100),
("model_dim_z_label", "model_dim_z",
"ModelCornerZMax", "ModelCornerZMin",
"ModelCornerZSpaces"))):
attributes = pango.AttrList()
attributes.insert(color)
for name in names:
self.gui.get_object(name).set_attributes(attributes)
self._event_handlers = (("model-change-after",
self.update_model_dimensions),
("visual-item-updated",
self.update_model_dimensions),
("model-list-chaned",
self.update_model_dimensions))
self.register_event_handlers(self._event_handlers)
return True
def update_example(self, widget=None):
start = 0
end = len(self.example)
attributes = pango.AttrList()
attributes.insert(
pango.AttrForeground(self.text_color.red, self.text_color.green,
self.text_color.blue, start, end))
attributes.insert(
pango.AttrBackground(self.highlight_color.red,
self.highlight_color.green,
self.highlight_color.blue, start, end))
# Bold verification
if self.bold_tg_button.get_active():
attributes.insert(pango.AttrWeight(pango.WEIGHT_HEAVY, start, end))
else:
attributes.insert(pango.AttrWeight(pango.WEIGHT_NORMAL, start,
end))
# Italic verification
if self.italic_tg_button.get_active():
attributes.insert(pango.AttrStyle(pango.STYLE_ITALIC, start, end))
else:
attributes.insert(pango.AttrStyle(pango.STYLE_NORMAL, start, end))
# Underline verification
if self.underline_tg_button.get_active():
attributes.insert(
pango.AttrUnderline(pango.UNDERLINE_SINGLE, start, end))
else:
attributes.insert(
pango.AttrUnderline(pango.UNDERLINE_NONE, start, end))
self.example_label.set_attributes(attributes)
def set_candidates(self, candidates, focus_candidate=0, show_cursor=True):
assert len(candidates) <= len(self.__labels)
for i, (text, attrs) in enumerate(candidates):
if i == focus_candidate and show_cursor:
if attrs == None:
attrs = pango.AttrList()
color = self.__labels[i][1].style.base[gtk.STATE_SELECTED]
end_index = len(text.encode("utf8"))
attr = pango.AttrBackground(color.red, color.green, color.blue,
0, end_index)
attrs.change(attr)
color = self.__labels[i][1].style.text[gtk.STATE_SELECTED]
attr = pango.AttrForeground(color.red, color.green, color.blue,
0, end_index)
attrs.insert(attr)
self.__labels[i][1].set_text(text)
self.__labels[i][1].show()
self.__labels[i][1].set_property("attributes", attrs)
for w in self.__candidates[i]:
w.show()
for w in reduce(operator.add, self.__candidates[len(candidates):]):
w.hide()
def create_pango_layout(self, text, *styles):
layout = self.context.create_pango_layout()
layout.set_text(text)
layout.set_font_description(self.font)
# We need to save some stuff for when we render; just stick extra properties on the
# layout. We may want to move to a setup where we have "print objects" for layouts
# or custom results.
layout._left_margin = 0
layout._right_margin = 0
layout._paragraph_background = None
attrs = pango.AttrList()
for style in styles:
spec = DEFAULT_STYLE.get_spec(style)
spec.add_pango_attributes(attrs,
start_index=0,
end_index=0x7fffffff)
# We are fudging pixels vs. points here
if spec.left_margin:
layout._left_margin = spec.left_margin
if spec.left_margin:
layout._right_margin = spec.right_margin
if spec.paragraph_background:
layout._paragraph_background = pango.Color(
spec.paragraph_background)
layout._width = self.context.get_width(
) - layout._left_margin - layout._right_margin
layout.set_width(int(pango.SCALE * layout._width))
layout.set_attributes(attrs)
return layout
def scheduler_launch_thread(self):
"""Thread handling the messages scheduler notification area."""
# Based on: http://pygstdocs.berlios.de/pygst-tutorial/seeking.html
thread_id = self.scheduler_thread_id
event_type = self.gui.get_object("nextlabel")
title = self.gui.get_object("titlelabel")
status = self.gui.get_object("eventlabel")
# Status panel
# status_disk = self.gui.get_object("status1")
# status_hours = self.gui.get_object("status2")
# status_mh = self.gui.get_object("status3")
self.check_schedule()
parpadeo = True
changed = False
signalized = False
if self.font == None:
anchura = self.get_toplevel().get_screen().get_width()
if anchura not in [1024, 1280, 1920]:
anchura = 1920
k1 = anchura / 1920.0
changing_font = pango.FontDescription("bold " + str(k1 * 42))
self.font = changing_font
bold = pango.AttrWeight(700, 0, -1)
red = pango.AttrForeground(65535, 0, 0, 0, -1)
black = pango.AttrForeground(17753, 17753, 17753, 0, -1)
font = pango.AttrFontDesc(self.font, 0, -1)
attr_red = pango.AttrList()
attr_black = pango.AttrList()
attr_red.insert(red)
attr_red.insert(font)
attr_red.insert(bold)
attr_black.insert(black)
attr_black.insert(font)
attr_black.insert(bold)
status.set_attributes(attr_black)
one_second = datetime.timedelta(seconds=1)
while thread_id == self.scheduler_thread_id:
if self.font != changing_font:
attr_black.insert(pango.AttrFontDesc(self.font, 0, -1))
attr_red.insert(pango.AttrFontDesc(self.font, 0, -1))
changing_font = self.font
if self.current:
start = self.current.getLocalDate()
duration = self.current.getDuration() / 1000
end = start + datetime.timedelta(seconds=duration)
dif = end - datetime.datetime.now()
#dif2 = datetime.datetime.now() - start
if dif < datetime.timedelta(0, 0): # Checking for malfuntions
self.current = None
self.current_mediapackage = None
status.set_text("")
else:
status.set_text("Stopping on " +
self.time_readable(dif + one_second))
if event_type.get_text() != CURRENT_TEXT:
event_type.set_text(CURRENT_TEXT)
if title.get_text() != self.current.title:
title.set_text(self.current.title)
if dif < datetime.timedelta(0, TIME_RED_STOP):
if not changed:
status.set_attributes(attr_red)
changed = True
elif changed:
status.set_attributes(attr_black)
changed = False
if dif < datetime.timedelta(0, TIME_BLINK_STOP):
parpadeo = False if parpadeo else True
# Timer(diff,self.check_schedule)
elif self.next:
start = self.next.getLocalDate()
dif = start - datetime.datetime.now()
if event_type.get_text != NEXT_TEXT:
event_type.set_text(NEXT_TEXT)
if title.get_text() != self.next.title:
title.set_text(self.next.title)
status.set_text("Starting on " + self.time_readable(dif))
if dif < datetime.timedelta(0, TIME_RED_START):
if not changed:
status.set_attributes(attr_red)
changed = True
elif changed:
status.set_attributes(attr_black)
changed = False
if dif < datetime.timedelta(0, TIME_UPCOMING):
if not signalized:
self.dispatcher.emit("upcoming-recording")
signalized = True
elif signalized:
signalized = True
if dif < datetime.timedelta(0, TIME_BLINK_START):
if parpadeo:
status.set_text("")
parpadeo = False
else:
parpadeo = True
# Timer(60,self.check_schedule)
else: # Not current or pending recordings
if event_type.get_text():
event_type.set_text("")
if status.get_text():
status.set_text("")
if title.get_text() != "No upcoming events":
title.set_text("No upcoming events")
time.sleep(0.5)
self.check_schedule()
return True
def __init__(self, logger, options, show_settings=False):
gtk.Window.__init__(self, gtk.WINDOW_POPUP)
self.timer_hide = None
self.timer_min = None
self.logger = logger
defaults = Options({
'no_systray': False,
'timeout': 2.5,
'recent_thr': 0.1,
'compr_cnt': 3,
'ignore': [],
'position': 'bottom',
'persist': False,
'font_desc': 'Sans Bold',
'font_size': 'medium',
'font_color': 'white',
'bg_color': 'black',
'opacity': 0.8,
'key_mode': 'composed',
'bak_mode': 'baked',
'mods_mode': 'normal',
'mods_only': False,
'multiline': False,
'vis_shift': False,
'vis_space': True,
'geometry': None,
'screen': 0
})
self.options = self.load_state()
if self.options is None:
self.options = defaults
else:
# copy missing defaults
for k, v in defaults.iteritems():
if k not in self.options:
self.options[k] = v
if options is not None:
# override with values from constructor
for k, v in options.iteritems():
if v is not None:
self.options[k] = v
self.set_keep_above(True)
self.set_accept_focus(False)
self.set_focus_on_map(False)
self.label = gtk.Label()
self.label.set_attributes(pango.AttrList())
self.label.set_ellipsize(pango.ELLIPSIZE_START)
self.label.set_justify(gtk.JUSTIFY_CENTER)
self.label.show()
self.add(self.label)
self.set_gravity(gtk.gdk.GRAVITY_CENTER)
self.connect("configure-event", self.on_configure)
scr = self.get_screen()
scr.connect("size-changed", self.on_configure)
scr.connect("monitors-changed", self.on_monitors_changed)
self.set_active_monitor(self.options.screen)
self.font = pango.FontDescription(self.options.font_desc)
self.update_colors()
self.update_label()
self.labelmngr = None
self.enabled = True
self.on_change_mode()
self.make_menu()
self.make_about_dialog()
self.make_preferences_dialog()
if not self.options.no_systray:
self.make_systray()
self.connect("delete-event", self.quit)
if show_settings:
self.on_preferences_dialog()
if self.options.persist:
self.show()
def set_shown_window(self, window):
if self.shown_window != None:
if self.sw_name_changed_handler != None:
self.shown_window.disconnect(self.sw_name_changed_handler)
if self.sw_state_changed_handler != None:
self.shown_window.disconnect(self.sw_state_changed_handler)
self.shown_window = window
self.sw_name_changed_handler = self.shown_window.connect(
'name-changed', self.on_window_name_changed)
self.sw_state_changed_handler = self.shown_window.connect(
'state-changed', self.on_shown_window_state_changed)
self.container.show_all()
#~ self.icon.set_from_pixbuf(self.shown_window.get_mini_icon())
name = u"" + self.shown_window.get_name()
self.label.set_tooltip_text(name)
self.label.set_text(name)
if self.shown_window.get_actions() & action_minimize:
self.minimize_button.show()
else:
self.minimize_button.hide()
if self.shown_window.is_maximized():
self.max_icon_state = 'restore'
if self.shown_window.get_actions() & action_unminimize:
self.maximize_button.show()
else:
self.maximize_button.hide()
else:
self.max_icon_state = 'maximize'
if self.shown_window.get_actions() & action_maximize:
self.maximize_button.show()
else:
self.maximize_button.hide()
if self.shown_window == self.active_window \
and self.window_state == 'passive':
self.window_state = 'active'
self.minimize_image.set_from_pixbuf(
self.pixbufs['minimize_normal_%s' % self.window_state])
self.maximize_image.set_from_pixbuf(
self.pixbufs['%s_normal_%s' %
(self.max_icon_state, self.window_state)])
self.close_image.set_from_pixbuf(self.pixbufs['close_normal_%s' %
self.window_state])
elif self.shown_window != self.active_window \
and not self.window_state == 'passive':
self.window_state = 'passive'
self.minimize_image.set_from_pixbuf(
self.pixbufs['minimize_normal_%s' % self.window_state])
self.maximize_image.set_from_pixbuf(
self.pixbufs['%s_normal_%s' %
(self.max_icon_state, self.window_state)])
self.close_image.set_from_pixbuf(self.pixbufs['close_normal_%s' %
self.window_state])
attr_list = pango.AttrList()
if settings['%s_bold' % self.window_state]:
attr_list.insert(pango.AttrWeight(pango.WEIGHT_BOLD, 0, 300))
color = settings['%s_color' % self.window_state]
r = int(color[1:3], 16) * 256
g = int(color[3:5], 16) * 256
b = int(color[5:7], 16) * 256
attr_list.insert(pango.AttrForeground(r, g, b, 0, 300))
self.label.set_attributes(attr_list)
def __init__(self, widget, self_seccion_stock, self_ventana_principal):
self.codigo = []
self.codigos_repetidos = ["l", "L", "r", "R"]
object = self_ventana_principal.window
object.set_sensitive(False)
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_size_request(1131, 600)
self.window.set_position(gtk.WIN_POS_CENTER)
self.window.set_title("Busqueda de productos")
self.window.set_resizable(False)
self.window.connect("delete-event", self.delete_event, object)
self.fixed = gtk.Fixed()
img = gtk.Image()
self.fixed.add(img)
self.window.add(self.fixed)
atributos = pango.AttrList()
atributos.insert(pango.AttrSize(12400, 0, -1))
atributos.insert(pango.AttrWeight(1200, 0, -1))
label_codigo = gtk.Label("Codigo : ")
label_descripcion = gtk.Label("Descripcion : ")
label_cantidad = gtk.Label("Cantidad : ")
label_codigo.set_attributes(atributos)
label_descripcion.set_attributes(atributos)
label_cantidad.set_attributes(atributos)
fuente_entrys = "Sans 13"
font_entry = pango.FontDescription(fuente_entrys)
self.entry = gtk.Entry()
self.entry_descripcion = gtk.Entry()
self.entry_cantidad = gtk.Entry()
self.entry.modify_font(font_entry)
self.entry_descripcion.modify_font(font_entry)
self.entry_cantidad.modify_font(font_entry)
self.fixed.put(self.entry, 150, 20)
self.fixed.put(self.entry_descripcion, 480, 20)
self.fixed.put(self.entry_cantidad, 750, 20)
self.fixed.put(label_codigo, 80, 25)
self.fixed.put(label_descripcion, 370, 25)
self.fixed.put(label_cantidad, 660, 25)
self.button_ma = gtk.Button()
self.button_ma.set_property("relief", 2)
imagen_boton_cerrar = gtk.Image()
imagen_boton_cerrar.set_from_file("../Images/boton_cerrar.png")
self.button_ma.add(imagen_boton_cerrar)
self.fixed.put(self.button_ma, 990, 550)
#agrego a una lista informacion de la bd
self.button_ma.connect("clicked", self.salir, object)
self.entry.connect("changed", self.mostrar, 'codigo')
self.entry.connect("activate", self.verificar_codigo, 'codigo')
self.entry_cantidad.connect("activate", self.cargar,
self_seccion_stock)
#--------------------------------------------------------------------------------------------------------------
self.scroll_win = gtk.ScrolledWindow()
self.scroll_win.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.scroll_win.set_size_request(1111, 470)
self.fixed.put(self.scroll_win, 10, 70)
self.liststore = gtk.ListStore(str, int, str, str, float, float, str,
str, str, str, str, 'gboolean')
self.treeview = gtk.TreeView(self.liststore)
rules_hint = self.treeview.get_rules_hint()
self.treeview.set_rules_hint(True)
self.scroll_win.add(self.treeview)
self.columnpb = gtk.TreeViewColumn("")
self.column1 = gtk.TreeViewColumn("Codigo")
self.column2 = gtk.TreeViewColumn("Descripcion")
self.column3 = gtk.TreeViewColumn("Costo")
self.column4 = gtk.TreeViewColumn("Precio")
self.column5 = gtk.TreeViewColumn("Stock inicial")
self.column6 = gtk.TreeViewColumn("Stock disponible")
self.column7 = gtk.TreeViewColumn("punto de reposicion")
self.column8 = gtk.TreeViewColumn("Reponer")
self.treeview.append_column(self.columnpb)
self.treeview.append_column(self.column1)
self.treeview.append_column(self.column2)
self.treeview.append_column(self.column3)
self.treeview.append_column(self.column4)
self.treeview.append_column(self.column5)
self.treeview.append_column(self.column6)
self.treeview.append_column(self.column7)
self.cell = gtk.CellRendererText()
self.cellpb = gtk.CellRendererPixbuf()
self.cell.set_property("cell background", "#71ACE2")
self.cell.set_property('size',
14000) #solo le da el tamaño a las celdas xd
self.cell.set_property('weight',
700) #seria el "grosor" de la fuente :P
self.cellpb.set_property("cell background", "#71ACE2")
self.columnpb.pack_start(self.cellpb, True)
self.column1.pack_start(self.cell, True)
self.column2.pack_start(self.cell, True)
self.column3.pack_start(self.cell, True)
self.column4.pack_start(self.cell, True)
self.column5.pack_start(self.cell, True)
self.column6.pack_start(self.cell, True)
self.column7.pack_start(self.cell, True)
self.treeview.set_search_column(1)
self.treeview.set_search_column(2)
self.treeview.set_search_column(3)
self.treeview.set_search_column(4)
self.treeview.set_search_column(5)
self.treeview.set_search_column(6)
self.treeview.set_search_column(7)
self.column1.set_sort_column_id(2)
self.column2.set_sort_column_id(3)
self.column3.set_sort_column_id(4)
self.column4.set_sort_column_id(5)
self.column5.set_sort_column_id(6)
self.column6.set_sort_column_id(7)
self.column7.set_sort_column_id(8)
self.columnpb.set_expand(True)
self.column1.set_expand(True)
self.column2.set_expand(True)
self.column3.set_expand(True)
self.column4.set_expand(True)
self.column5.set_expand(True)
self.column6.set_expand(True)
self.column7.set_expand(True)
self.column1.set_resizable(True)
self.column2.set_resizable(True)
self.column3.set_resizable(True)
self.column4.set_resizable(True)
self.column5.set_resizable(True)
self.column6.set_resizable(True)
self.column7.set_resizable(True)
self.lista_columnas = []
self.lista_columnas.append(self.columnpb)
self.lista_columnas.append(self.column1)
self.lista_columnas.append(self.column2)
self.lista_columnas.append(self.column3)
self.lista_columnas.append(self.column4)
self.lista_columnas.append(self.column5)
self.lista_columnas.append(self.column6)
self.lista_columnas.append(self.column7)
self.lista_columnas.append(self.cell)
self.lista_columnas.append(self.cellpb)
self.setear_filas()
self.window.show_all()
def __init__(self, exaile, doubanfm_plugin):
self.exaile = exaile
self.dbfm_plugin = doubanfm_plugin
self.builder = gtk.Builder()
self.builder.add_from_file(get_resource_path('doubanfm_mode.ui'))
self.builder.connect_signals({
'on_bookmark_button_clicked':
self.on_bookmark_button_clicked,
'on_skip_button_clicked':
self.on_skip_button_clicked,
'on_delete_button_clicked':
self.on_delete_button_clicked,
'on_go_home_button_clicked':
self.on_go_home_button_clicked,
'on_item_setting_clicked':
self.on_button_setting_clicked,
'on_item_album_clicked':
self.on_button_album_clicked,
'on_item_report_clicked':
self.on_button_report_clicked,
'on_menu_toggle':
self.on_menu_toggle,
'on_quit':
self.on_quit,
'on_pausebutton_clicked':
self.on_pausebutton_clicked,
'on_recommend_song':
self.on_recommend_song,
'on_share_sina':
self.on_share_sina,
'on_share_renren':
self.on_share_renren,
'on_share_kaixin001':
self.on_share_kaixin001,
'on_share_twitter':
self.on_share_twitter,
'on_share_fanfou':
self.on_share_fanfou,
'on_copy_permalink':
self.on_copy_permalink,
})
self.window = self.builder.get_object('doubanfm_mode_window')
self.window.connect('destroy', self.hide)
volume = settings.get_option('player/volume', 1)
self.volume_control = playback.VolumeControl(player.PLAYER)
self.builder.get_object('hbox2').pack_start(self.volume_control)
self.cover_box = self.builder.get_object('cover_eventbox1')
self.info_area = info.TrackInfoPane(player.PLAYER)
self.cover = cover.CoverWidget(self.cover_box, player.PLAYER)
# self.cover_box.add(self.cover)
self.track_title_label = self.builder.get_object('track_title_label')
attr = pango.AttrList()
attr.change(pango.AttrWeight(pango.WEIGHT_BOLD, 0, 800))
attr.change(pango.AttrSize(12500, 0, 600))
self.track_title_label.set_attributes(attr)
self.track_info_label = self.builder.get_object('track_info_label')
self.bookmark_button = self.builder.get_object('bookmark_button')
self.trash_button = self.builder.get_object('delete_button')
self.skip_button = self.builder.get_object('skip_button')
self.pause_button = self.builder.get_object('pause_button')
self.popup_menu = self.builder.get_object('moremenu')
self.report_menuitem = self.builder.get_object('menuitem1')
self.album_menuitem = self.builder.get_object('menuitem2')
self.recmd_menuitem = self.builder.get_object('menuitem10')
self.sensitive_widgets = [
self.bookmark_button,
self.trash_button,
self.skip_button,
self.pause_button,
self.report_menuitem,
self.album_menuitem,
self.recmd_menuitem,
]
self.progress_bar = playback.PlaybackProgressBar(player.PLAYER)
self.builder.get_object('vbox2').pack_start(self.progress_bar)
self.visible = False
self.active = False
self._build_channel_menu()
event.add_callback(self.on_playback_start, 'playback_track_start',
player.PLAYER)
event.add_callback(self.on_playback_stop, 'playback_track_end',
player.PLAYER)
event.add_callback(self.on_pausebutton_toggled,
'playback_toggle_pause', player.PLAYER)
event.add_callback(self.on_tag_update, 'track_tags_changed')
self._toggle_id = self.exaile.gui.main.connect('main-visible-toggle',
self.toggle_visible)
## added for 0.3.2
self._init_alpha()
