513 lines
19 KiB
Python
513 lines
19 KiB
Python
# -*- coding: utf-8 -*-
|
|
#
|
|
# gPodder - A media aggregator and podcast client
|
|
# Copyright (c) 2005-2018 The gPodder Team
|
|
#
|
|
# gPodder is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# gPodder is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
|
|
|
|
#
|
|
# draw.py -- Draw routines for gPodder-specific graphics
|
|
# Thomas Perl <thp@perli.net>, 2007-11-25
|
|
#
|
|
|
|
import io
|
|
import math
|
|
|
|
import cairo
|
|
|
|
import gi # isort:skip
|
|
gi.require_version('Gdk', '3.0') # isort:skip
|
|
gi.require_version('Gtk', '3.0') # isort:skip
|
|
gi.require_version('PangoCairo', '1.0') # isort:skip
|
|
from gi.repository import Gdk, GdkPixbuf, Gtk, Pango, PangoCairo # isort:skip
|
|
|
|
|
|
class TextExtents(object):
|
|
def __init__(self, ctx, text):
|
|
tuple = ctx.text_extents(text)
|
|
(self.x_bearing, self.y_bearing, self.width, self.height, self.x_advance, self.y_advance) = tuple
|
|
|
|
|
|
EPISODE_LIST_ICON_SIZE = 16
|
|
|
|
RRECT_LEFT_SIDE = 1
|
|
RRECT_RIGHT_SIDE = 2
|
|
|
|
|
|
def draw_rounded_rectangle(ctx, x, y, w, h, r=10, left_side_width=None,
|
|
sides_to_draw=0, close=False):
|
|
assert left_side_width is not None
|
|
|
|
x = int(x)
|
|
offset = 0
|
|
if close: offset = 0.5
|
|
|
|
if sides_to_draw & RRECT_LEFT_SIDE:
|
|
ctx.move_to(x + int(left_side_width) - offset, y + h)
|
|
ctx.line_to(x + r, y + h)
|
|
ctx.curve_to(x, y + h, x, y + h, x, y + h - r)
|
|
ctx.line_to(x, y + r)
|
|
ctx.curve_to(x, y, x, y, x + r, y)
|
|
ctx.line_to(x + int(left_side_width) - offset, y)
|
|
if close:
|
|
ctx.line_to(x + int(left_side_width) - offset, y + h)
|
|
|
|
if sides_to_draw & RRECT_RIGHT_SIDE:
|
|
ctx.move_to(x + int(left_side_width) + offset, y)
|
|
ctx.line_to(x + w - r, y)
|
|
ctx.curve_to(x + w, y, x + w, y, x + w, y + r)
|
|
ctx.line_to(x + w, y + h - r)
|
|
ctx.curve_to(x + w, y + h, x + w, y + h, x + w - r, y + h)
|
|
ctx.line_to(x + int(left_side_width) + offset, y + h)
|
|
if close:
|
|
ctx.line_to(x + int(left_side_width) + offset, y)
|
|
|
|
|
|
def rounded_rectangle(ctx, x, y, width, height, radius=4.):
|
|
"""Simple rounded rectangle algorithmn
|
|
|
|
http://www.cairographics.org/samples/rounded_rectangle/
|
|
"""
|
|
degrees = math.pi / 180.
|
|
ctx.new_sub_path()
|
|
if width > radius:
|
|
ctx.arc(x + width - radius, y + radius, radius, -90. * degrees, 0)
|
|
ctx.arc(x + width - radius, y + height - radius, radius, 0, 90. * degrees)
|
|
ctx.arc(x + radius, y + height - radius, radius, 90. * degrees, 180. * degrees)
|
|
ctx.arc(x + radius, y + radius, radius, 180. * degrees, 270. * degrees)
|
|
ctx.close_path()
|
|
|
|
|
|
def draw_text_box_centered(ctx, widget, w_width, w_height, text, font_desc=None, add_progress=None):
|
|
style_context = widget.get_style_context()
|
|
text_color = style_context.get_color(Gtk.StateFlags.PRELIGHT)
|
|
|
|
if font_desc is None:
|
|
font_desc = style_context.get_font(Gtk.StateFlags.NORMAL)
|
|
font_desc.set_size(14 * Pango.SCALE)
|
|
|
|
pango_context = widget.create_pango_context()
|
|
layout = Pango.Layout(pango_context)
|
|
layout.set_font_description(font_desc)
|
|
layout.set_text(text, -1)
|
|
width, height = layout.get_pixel_size()
|
|
|
|
ctx.move_to(w_width / 2 - width / 2, w_height / 2 - height / 2)
|
|
ctx.set_source_rgba(text_color.red, text_color.green, text_color.blue, 0.5)
|
|
PangoCairo.show_layout(ctx, layout)
|
|
|
|
# Draw an optional progress bar below the text (same width)
|
|
if add_progress is not None:
|
|
bar_height = 10
|
|
ctx.set_source_rgba(*text_color)
|
|
ctx.set_line_width(1.)
|
|
rounded_rectangle(ctx,
|
|
w_width / 2 - width / 2 - .5,
|
|
w_height / 2 + height - .5, width + 1, bar_height + 1)
|
|
ctx.stroke()
|
|
rounded_rectangle(ctx,
|
|
w_width / 2 - width / 2,
|
|
w_height / 2 + height, int(width * add_progress) + .5, bar_height)
|
|
ctx.fill()
|
|
|
|
|
|
def draw_cake(percentage, text=None, emblem=None, size=None):
|
|
# Download percentage bar icon - it turns out the cake is a lie (d'oh!)
|
|
# ..but the inital idea was to have a cake-style indicator, but that
|
|
# didn't work as well as the progress bar, but the name stuck..
|
|
|
|
if size is None:
|
|
size = EPISODE_LIST_ICON_SIZE
|
|
|
|
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, size, size)
|
|
ctx = cairo.Context(surface)
|
|
|
|
bgc = get_background_color(Gtk.StateFlags.ACTIVE)
|
|
fgc = get_background_color(Gtk.StateFlags.SELECTED)
|
|
txc = get_foreground_color(Gtk.StateFlags.NORMAL)
|
|
|
|
border = 1.5
|
|
height = int(size * .4)
|
|
width = size - 2 * border
|
|
y = (size - height) / 2 + .5
|
|
x = border
|
|
|
|
# Background
|
|
ctx.rectangle(x, y, width, height)
|
|
ctx.set_source_rgb(bgc.red, bgc.green, bgc.blue)
|
|
ctx.fill()
|
|
|
|
# Filling
|
|
if percentage > 0:
|
|
fill_width = max(1, min(width - 2, (width - 2) * percentage + .5))
|
|
ctx.rectangle(x + 1, y + 1, fill_width, height - 2)
|
|
ctx.set_source_rgb(0.289, 0.5625, 0.84765625)
|
|
ctx.fill()
|
|
|
|
# Border
|
|
ctx.rectangle(x, y, width, height)
|
|
ctx.set_source_rgb(txc.red, txc.green, txc.blue)
|
|
ctx.set_line_width(1)
|
|
ctx.stroke()
|
|
|
|
del ctx
|
|
return surface
|
|
|
|
|
|
def draw_text_pill(left_text, right_text, x=0, y=0, border=2, radius=14,
|
|
widget=None, scale=1):
|
|
|
|
# Padding (in px) at the right edge of the image (for Ubuntu; bug 1533)
|
|
padding_right = 7
|
|
|
|
x_border = border * 2
|
|
|
|
if widget is None:
|
|
# Use GTK+ style of a normal Button
|
|
widget = Gtk.Label()
|
|
|
|
style_context = widget.get_style_context()
|
|
font_desc = style_context.get_font(Gtk.StateFlags.NORMAL)
|
|
font_desc.set_weight(Pango.Weight.BOLD)
|
|
|
|
pango_context = widget.create_pango_context()
|
|
layout_left = Pango.Layout(pango_context)
|
|
layout_left.set_font_description(font_desc)
|
|
layout_left.set_text(left_text, -1)
|
|
layout_right = Pango.Layout(pango_context)
|
|
layout_right.set_font_description(font_desc)
|
|
layout_right.set_text(right_text, -1)
|
|
|
|
width_left, height_left = layout_left.get_pixel_size()
|
|
width_right, height_right = layout_right.get_pixel_size()
|
|
|
|
text_height = max(height_left, height_right)
|
|
|
|
left_side_width = width_left + x_border * 2
|
|
right_side_width = width_right + x_border * 2
|
|
|
|
image_height = int(scale * (y + text_height + border * 2))
|
|
image_width = int(scale * (x + left_side_width + right_side_width
|
|
+ padding_right))
|
|
|
|
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, image_width, image_height)
|
|
surface.set_device_scale(scale, scale)
|
|
|
|
ctx = cairo.Context(surface)
|
|
|
|
# Clip so as to not draw on the right padding (for Ubuntu; bug 1533)
|
|
ctx.rectangle(0, 0, image_width - padding_right, image_height)
|
|
ctx.clip()
|
|
|
|
if left_text == '0':
|
|
left_text = None
|
|
if right_text == '0':
|
|
right_text = None
|
|
|
|
rect_width = left_side_width + right_side_width
|
|
rect_height = text_height + border * 2
|
|
if left_text is not None:
|
|
draw_rounded_rectangle(ctx, x, y, rect_width, rect_height, radius,
|
|
left_side_width, RRECT_LEFT_SIDE, right_text is None)
|
|
linear = cairo.LinearGradient(x, y, x + left_side_width / 2, y + rect_height / 2)
|
|
linear.add_color_stop_rgba(0, .8, .8, .8, .5)
|
|
linear.add_color_stop_rgba(.4, .8, .8, .8, .7)
|
|
linear.add_color_stop_rgba(.6, .8, .8, .8, .6)
|
|
linear.add_color_stop_rgba(.9, .8, .8, .8, .8)
|
|
linear.add_color_stop_rgba(1, .8, .8, .8, .9)
|
|
ctx.set_source(linear)
|
|
ctx.fill()
|
|
xpos, ypos, width_left, height = x + 1, y + 1, left_side_width, rect_height - 2
|
|
if right_text is None:
|
|
width_left -= 2
|
|
draw_rounded_rectangle(ctx, xpos, ypos, rect_width, height, radius, width_left, RRECT_LEFT_SIDE, right_text is None)
|
|
ctx.set_source_rgba(1., 1., 1., .3)
|
|
ctx.set_line_width(1)
|
|
ctx.stroke()
|
|
draw_rounded_rectangle(ctx, x, y, rect_width, rect_height, radius,
|
|
left_side_width, RRECT_LEFT_SIDE, right_text is None)
|
|
ctx.set_source_rgba(.2, .2, .2, .6)
|
|
ctx.set_line_width(1)
|
|
ctx.stroke()
|
|
|
|
ctx.move_to(x + x_border, y + 1 + border)
|
|
ctx.set_source_rgba(0, 0, 0, 1)
|
|
PangoCairo.show_layout(ctx, layout_left)
|
|
ctx.move_to(x - 1 + x_border, y + border)
|
|
ctx.set_source_rgba(1, 1, 1, 1)
|
|
PangoCairo.show_layout(ctx, layout_left)
|
|
|
|
if right_text is not None:
|
|
draw_rounded_rectangle(ctx, x, y, rect_width, rect_height, radius, left_side_width, RRECT_RIGHT_SIDE, left_text is None)
|
|
linear = cairo.LinearGradient(
|
|
x + left_side_width,
|
|
y,
|
|
x + left_side_width + right_side_width / 2,
|
|
y + rect_height)
|
|
linear.add_color_stop_rgba(0, .2, .2, .2, .9)
|
|
linear.add_color_stop_rgba(.4, .2, .2, .2, .8)
|
|
linear.add_color_stop_rgba(.6, .2, .2, .2, .6)
|
|
linear.add_color_stop_rgba(.9, .2, .2, .2, .7)
|
|
linear.add_color_stop_rgba(1, .2, .2, .2, .5)
|
|
ctx.set_source(linear)
|
|
ctx.fill()
|
|
xpos, ypos, width, height = x, y + 1, rect_width - 1, rect_height - 2
|
|
if left_text is None:
|
|
xpos, width = x + 1, rect_width - 2
|
|
draw_rounded_rectangle(ctx, xpos, ypos, width, height, radius, left_side_width, RRECT_RIGHT_SIDE, left_text is None)
|
|
ctx.set_source_rgba(1., 1., 1., .3)
|
|
ctx.set_line_width(1)
|
|
ctx.stroke()
|
|
draw_rounded_rectangle(ctx, x, y, rect_width, rect_height, radius, left_side_width, RRECT_RIGHT_SIDE, left_text is None)
|
|
ctx.set_source_rgba(.1, .1, .1, .6)
|
|
ctx.set_line_width(1)
|
|
ctx.stroke()
|
|
|
|
ctx.move_to(x + left_side_width + x_border, y + 1 + border)
|
|
ctx.set_source_rgba(0, 0, 0, 1)
|
|
PangoCairo.show_layout(ctx, layout_right)
|
|
ctx.move_to(x - 1 + left_side_width + x_border, y + border)
|
|
ctx.set_source_rgba(1, 1, 1, 1)
|
|
PangoCairo.show_layout(ctx, layout_right)
|
|
|
|
return surface
|
|
|
|
|
|
def draw_cake_pixbuf(percentage, text=None, emblem=None, size=None):
|
|
return cairo_surface_to_pixbuf(draw_cake(percentage, text, emblem, size=size))
|
|
|
|
|
|
def draw_pill_pixbuf(left_text, right_text, widget=None, scale=1):
|
|
return cairo_surface_to_pixbuf(draw_text_pill(left_text, right_text,
|
|
widget=widget, scale=scale))
|
|
|
|
|
|
def cake_size_from_widget(widget=None):
|
|
if widget is None:
|
|
# Use GTK+ style of a normal Button
|
|
widget = Gtk.Label()
|
|
style_context = widget.get_style_context()
|
|
font_desc = style_context.get_font(Gtk.StateFlags.NORMAL)
|
|
pango_context = widget.create_pango_context()
|
|
layout = Pango.Layout(pango_context)
|
|
layout.set_font_description(font_desc)
|
|
layout.set_text("1", -1)
|
|
# use text height as size
|
|
return layout.get_pixel_size()[1]
|
|
|
|
|
|
def cairo_surface_to_pixbuf(s):
|
|
"""
|
|
Converts a Cairo surface to a Gtk Pixbuf by
|
|
encoding it as PNG and using the PixbufLoader.
|
|
"""
|
|
bio = io.BytesIO()
|
|
try:
|
|
s.write_to_png(bio)
|
|
except:
|
|
# Write an empty PNG file to the StringIO, so
|
|
# in case of an error we have "something" to
|
|
# load. This happens in PyCairo < 1.1.6, see:
|
|
# http://webcvs.cairographics.org/pycairo/NEWS?view=markup
|
|
# Thanks to Chris Arnold for reporting this bug
|
|
bio.write('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4'
|
|
'c6QAAAAZiS0dEAP8A\n/wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAA'
|
|
'AAd0SU1FB9cMEQkqIyxn3RkAAAAZdEVYdENv\nbW1lbnQAQ3JlYXRlZCB3a'
|
|
'XRoIEdJTVBXgQ4XAAAADUlEQVQI12NgYGBgAAAABQABXvMqOgAAAABJ\nRU'
|
|
'5ErkJggg==\n'.decode('base64'))
|
|
|
|
pbl = GdkPixbuf.PixbufLoader()
|
|
pbl.write(bio.getvalue())
|
|
pbl.close()
|
|
|
|
pixbuf = pbl.get_pixbuf()
|
|
return pixbuf
|
|
|
|
|
|
def progressbar_pixbuf(width, height, percentage):
|
|
COLOR_BG = (.4, .4, .4, .4)
|
|
COLOR_FG = (.2, .9, .2, 1.)
|
|
COLOR_FG_HIGH = (1., 1., 1., .5)
|
|
COLOR_BORDER = (0., 0., 0., 1.)
|
|
|
|
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
|
|
ctx = cairo.Context(surface)
|
|
|
|
padding = int(width / 8.0)
|
|
bar_width = 2 * padding
|
|
bar_height = height - 2 * padding
|
|
bar_height_fill = bar_height * percentage
|
|
|
|
# Background
|
|
ctx.rectangle(padding, padding, bar_width, bar_height)
|
|
ctx.set_source_rgba(*COLOR_BG)
|
|
ctx.fill()
|
|
|
|
# Foreground
|
|
ctx.rectangle(padding, padding + bar_height - bar_height_fill, bar_width, bar_height_fill)
|
|
ctx.set_source_rgba(*COLOR_FG)
|
|
ctx.fill()
|
|
ctx.rectangle(padding + bar_width / 3,
|
|
padding + bar_height - bar_height_fill,
|
|
bar_width / 4,
|
|
bar_height_fill)
|
|
ctx.set_source_rgba(*COLOR_FG_HIGH)
|
|
ctx.fill()
|
|
|
|
# Border
|
|
ctx.rectangle(padding - .5, padding - .5, bar_width + 1, bar_height + 1)
|
|
ctx.set_source_rgba(* COLOR_BORDER)
|
|
ctx.set_line_width(1.)
|
|
ctx.stroke()
|
|
|
|
return cairo_surface_to_pixbuf(surface)
|
|
|
|
|
|
def get_background_color(state=Gtk.StateFlags.NORMAL, widget=Gtk.TreeView()):
|
|
"""
|
|
@param state state flag (e.g. Gtk.StateFlags.SELECTED to get selected background)
|
|
@param widget specific widget to get info from.
|
|
defaults to TreeView which has all one usually wants.
|
|
@return background color from theme for widget or from its parents if transparent.
|
|
"""
|
|
p = widget
|
|
color = Gdk.RGBA(0, 0, 0, 0)
|
|
while p is not None and color.alpha == 0:
|
|
style_context = p.get_style_context()
|
|
color = style_context.get_background_color(state)
|
|
p = p.get_parent()
|
|
return color
|
|
|
|
|
|
def get_foreground_color(state=Gtk.StateFlags.NORMAL, widget=Gtk.TreeView()):
|
|
"""
|
|
@param state state flag (e.g. Gtk.StateFlags.SELECTED to get selected text color)
|
|
@param widget specific widget to get info from
|
|
defaults to TreeView which has all one usually wants.
|
|
@return text color from theme for widget or its parents if transparent
|
|
"""
|
|
p = widget
|
|
color = Gdk.RGBA(0, 0, 0, 0)
|
|
while p is not None and color.alpha == 0:
|
|
style_context = p.get_style_context()
|
|
color = style_context.get_color(state)
|
|
p = p.get_parent()
|
|
return color
|
|
|
|
|
|
def investigate_widget_colors(type_classes_and_widgets):
|
|
"""
|
|
investigate using Gtk.StyleContext to get widget style properties
|
|
I tried to compare gettings values from static and live widgets.
|
|
To sum up, better use the live widget, because you'll get the correct path, classes, regions automatically.
|
|
See "CSS Nodes" in widget documentation for classes and sub-nodes (=regions).
|
|
WidgetPath and Region are replaced by CSSNodes in gtk4.
|
|
Not sure it's legitimate usage, though: I got different results from one run to another.
|
|
Run `GTK_DEBUG=interactive ./bin/gpodder` for gtk widget inspection
|
|
"""
|
|
def investigate_stylecontext(style_ctx, label):
|
|
style_ctx.save()
|
|
for statename, state in [
|
|
('normal', Gtk.StateFlags.NORMAL),
|
|
('active', Gtk.StateFlags.ACTIVE),
|
|
('link', Gtk.StateFlags.LINK),
|
|
('visited', Gtk.StateFlags.VISITED)]:
|
|
f.write("<dt>%s %s</dt><dd>\n" % (label, statename))
|
|
colors = {
|
|
'get_color': style_ctx.get_color(state),
|
|
'get_background_color': style_ctx.get_background_color(state),
|
|
'color': style_ctx.get_property('color', state),
|
|
'background-color': style_ctx.get_property('background-color', state),
|
|
'outline-color': style_ctx.get_property('outline-color', state),
|
|
}
|
|
f.write("<p>PREVIEW: <span style='background-color: %s; color: %s'>get_color + get_background_color</span>"
|
|
% (colors['get_background_color'].to_string(),
|
|
colors['get_color'].to_string()))
|
|
f.write("<span style='background-color: %s; color: %s; border solid 2px %s;'>color + background-color properties</span></p>\n"
|
|
% (colors['background-color'].to_string(),
|
|
colors['color'].to_string(),
|
|
colors['outline-color'].to_string()))
|
|
f.write("<p>VALUES: ")
|
|
for p, v in colors.items():
|
|
f.write("%s=<span style='background-color: %s;'>%s</span>" % (p, v.to_string(), v.to_string()))
|
|
f.write("</p></dd>\n")
|
|
style_ctx.restore()
|
|
|
|
with open('/tmp/colors.html', 'w') as f:
|
|
f.write("""<html>
|
|
<style type='text/css'>
|
|
body {color: red; background: yellow;}
|
|
span { display: inline-block; margin-right: 1ch; }
|
|
dd { margin-bottom: 1em; }
|
|
td { vertical-align: top; }
|
|
</style>
|
|
<table>""")
|
|
for type_and_class, w in type_classes_and_widgets:
|
|
f.write("<tr><td><dl>\n")
|
|
# Create an empty style context
|
|
style_ctx = Gtk.StyleContext()
|
|
# Create an empty widget path
|
|
widget_path = Gtk.WidgetPath()
|
|
# Specify the widget class type you want to get colors from
|
|
for t, c, r in type_and_class:
|
|
widget_path.append_type(t)
|
|
if c:
|
|
widget_path.iter_add_class(widget_path.length() - 1, c)
|
|
if r:
|
|
widget_path.iter_add_region(widget_path.length() - 1, r, 0)
|
|
style_ctx.set_path(widget_path)
|
|
|
|
investigate_stylecontext(
|
|
style_ctx,
|
|
'STATIC {}'.format(' '.join('{}.{}({})'.format(t.__name__, c, r) for t, c, r in type_and_class)))
|
|
|
|
f.write("</dl></td><td><dl>\n")
|
|
|
|
investigate_stylecontext(w.get_style_context(), 'LIVE {}'.format(type(w).__name__))
|
|
|
|
f.write("</dl></td></tr>\n")
|
|
f.write("</table></html>\n")
|
|
|
|
|
|
def draw_iconcell_scale(column, cell, model, iter, scale):
|
|
"""
|
|
Draw cell's pixbuf to a surface with proper scaling for high resolution
|
|
displays. To be used as gtk.TreeViewColumn.set_cell_data_func.
|
|
|
|
:param column: gtk.TreeViewColumn (ignored)
|
|
:param cell: gtk.CellRenderer
|
|
:param model: gtk.TreeModel (ignored)
|
|
:param iter: gtk.TreeIter (ignored)
|
|
:param scale: factor of the target display (e.g. 1 or 2)
|
|
"""
|
|
pixbuf = cell.props.pixbuf
|
|
if not pixbuf:
|
|
return
|
|
|
|
width = pixbuf.get_width()
|
|
height = pixbuf.get_height()
|
|
scale_inv = 1 / scale
|
|
|
|
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
|
|
surface.set_device_scale(scale, scale)
|
|
|
|
cr = cairo.Context(surface)
|
|
cr.scale(scale_inv, scale_inv)
|
|
Gdk.cairo_set_source_pixbuf(cr, cell.props.pixbuf, 0, 0)
|
|
cr.paint()
|
|
|
|
cell.props.surface = surface
|