def _set_label_markup(label: Gtk.Label, markup: Optional[str], *args: Any) -> None:
if markup is not None and None not in args:
label.set_sensitive(True)
label.set_markup(markup.format(*args))
else:
label.set_sensitive(False)
label.set_markup('')
def make_group(self, group_label, widget, add_widget_to_size_group=True):
self.size_groups = getattr(self, "size_groups", [SizeGroup.new(SizeGroupMode.HORIZONTAL) for x in range(2)])
box = SettingsWidget()
label = Label()
label.set_markup(group_label)
label.props.xalign = 0.0
self.size_groups[0].add_widget(label)
box.pack_start(label, False, False, 0)
if add_widget_to_size_group:
self.size_groups[1].add_widget(widget)
box.pack_end(widget, False, False, 0)
return box
class Renderer(Overlay):
def __init__(self, win, parser='rst', writer='html4', style=''):
super(Renderer, self).__init__()
scrolled = ScrolledWindow.new(None, None)
scrolled.set_policy(PolicyType.AUTOMATIC, PolicyType.AUTOMATIC)
self.sb = scrolled.get_vscrollbar()
self.add(scrolled)
self.webview = WebView()
self.webview.connect("mouse-target-changed", self.on_mouse)
scrolled.add(self.webview)
self.label = Label()
self.label.set_halign(Align.START)
self.label.set_valign(Align.END)
self.add_overlay(self.label)
self.set_writer(writer)
self.set_parser(parser)
self.style = style
self.tab_width = 8
self.__win = win
def on_mouse(self, web_view, hit_test_result, modifiers):
if hit_test_result.context_is_link():
text = "link: %s" % hit_test_result.get_link_uri()
elif hit_test_result.context_is_image():
text = "image: %s" % hit_test_result.get_image_uri()
elif hit_test_result.context_is_media():
text = "media: %s" % hit_test_result.get_media_uri()
else:
if self.label.is_visible():
self.label.hide()
return
self.label.set_markup(MARKUP % text)
self.label.show()
def set_writer(self, writer):
assert writer in WRITERS
self.__writer = WRITERS[writer]
klass = self.__writer['class']
self.writer_instance = klass() if klass is not None else None
idle_add(self.do_render)
def get_writer(self):
return self.__writer['key']
def set_parser(self, parser):
assert parser in PARSERS
self.__parser = PARSERS[parser]
klass = self.__parser['class']
self.parser_instance = klass() if klass is not None else None
idle_add(self.do_render)
def get_parser(self):
return self.__parser['key']
def set_style(self, style):
self.style = style
idle_add(self.do_render)
def get_style(self):
return self.style
def set_tab_width(self, width):
self.tab_width = width
def render_output(self):
if getattr(self, 'src', None) is None:
return False, "", "text/plain"
try:
if self.__parser['class'] is None:
html = NOT_FOUND.format(**self.__parser)
elif self.__writer['class'] is None:
html = NOT_FOUND.format(**self.__writer)
elif issubclass(self.__parser['class'], JSONPreview):
try:
json = loads(self.src)
return (False, dumps(json, sort_keys=True,
ensure_ascii=False,
indent=4, separators=(',', ': ')),
'application/json')
except ValueError as e:
return False, DATA_ERROR % ('JSON', str(e)), "text/html"
else:
if not issubclass(self.__parser['class'], HtmlPreview):
settings = {
'warning_stream': StringIO(),
'embed_stylesheet': True,
'tab_width': self.tab_width
}
if self.style:
settings['stylesheet'] = self.style
settings['stylesheet_path'] = []
kwargs = {'source': self.src,
'parser': self.parser_instance,
'writer': self.writer_instance,
'writer_name': 'html',
'settings_overrides': settings}
if self.__writer['key'] == 'pep':
kwargs['reader_name'] = 'pep'
kwargs.pop('parser') # pep is allways rst
html = publish_string(**kwargs).decode('utf-8')
return True, html, 'text/html'
else:
if version_info.major == 2:
html = self.src.decode("utf-8")
else:
html = self.src
# output to file or html preview
return False, html, 'text/html'
except DataError as e:
return False, DATA_ERROR % ('Data', e), 'text/html'
except BaseException:
exc_str = format_exc()
return False, EXCEPTION_ERROR % exc_str, 'text/html'
def do_render(self):
state, html, mime_type = self.render_output()
if state:
a, b = len(self.src[:self.pos]), len(self.src[self.pos:])
position = (float(a)/(a+b)) if a or b else 0
html += SCROLL % position
if html and self.__win.runing:
file_name = self.file_name or get_home_dir()
self.webview.load_bytes(Bytes(html.encode("utf-8")),
mime_type, "UTF-8", "file://"+file_name)
def render(self, src, file_name, pos=0):
self.src = src
self.pos = pos
self.file_name = file_name
idle_add(self.do_render)
def print_page(self):
po = PrintOperation.new(self.webview)
po.connect("failed", self.on_print_failed)
po.run_dialog(self.__win)
def on_print_failed(self, po, error):
# FIXME: if dialog is used, application will lock :-(
log_default_handler("Application", LogLevelFlags.LEVEL_WARNING,
error.message)
def on_selection_changed(self, icon_view, album=None):
popup = Popover.new(self.albumview)
popup.set_size_request(810, 240)
if album is None:
selection = icon_view.get_selected_items()
if len(selection) != 1:
return
path = selection[0]
treeiter = self.albumfilter.get_iter(path)
isset, path, cell = icon_view.get_cursor()
isset, rect = icon_view.get_cell_rect(path, cell)
popup.set_pointing_to(rect)
album_id = self.albumfilter.get_value(treeiter, 4)
album_obj = self.albums[album_id]
else:
album_obj = album
popup.set_relative_to(self.search_entry)
# Handle double clicks
def empty_dblclick():
self.dblclick = None
if self.dblclick is None:
self.dblclick = album_obj
timeout_add(1000, empty_dblclick)
elif self.dblclick == album_obj:
self.play(album_obj)
return
album = album_obj.name
artist = album_obj.artist
glade_album = join(self.functions.datadir, 'glade', 'albumview.ui')
box = gtk_builder()
box.set_translation_domain('bluemindo')
box.add_from_file(glade_album)
popup.add(box.get_object('box1'))
box.get_object('label_album').set_text(album)
box.get_object('label_artist').set_text(artist)
bdir = join(self.userconf.datadir, 'modules', 'player', 'covers')
cover = join(bdir, self.functions.get_hash(album, artist))
if isfile(cover):
cover_px = Pixbuf.new_from_file_at_scale(cover, 180, 180, True)
else:
cover_px = Pixbuf.new_from_file(join(self.functions.datadir,
'image', 'logo_head_big.png'))
box.get_object('album_cover').set_from_pixbuf(cover_px)
def play_album(wdg, album):
self.play(album)
def queue_album(wdg, album):
self.queue(album)
def change_cover(wdg, ka, album):
artist_name = album.artist
album_name = album.name
fcdialog = FileChooserDialog(
title=_('Change the cover picture for this album'),
buttons=(_('Select'), ResponseType.OK))
fcdialog.set_transient_for(self.widgets[0][11])
response = fcdialog.run()
if response == ResponseType.OK:
filename = fcdialog.get_filename()
datadir = self.userconf.datadir
hash_a = self.functions.get_hash(album_name, artist_name)
pictures_dir = join(datadir, 'modules', 'player', 'covers')
album_file = join(pictures_dir, hash_a)
copyfile(filename, album_file)
new = Pixbuf.new_from_file_at_scale(album_file, 180, 180, True)
box.get_object('album_cover').set_from_pixbuf(new)
fcdialog.destroy()
box.get_object('button_play').connect('clicked', play_album, album_obj)
box.get_object('button_add').connect('clicked', queue_album, album_obj)
box.get_object('coverevent').connect('button-press-event',
change_cover, album_obj)
i = 0
a = -1
previous_column = 0
grid_songs = box.get_object('grid_songs')
grid_songs.set_size_request(-1, 200)
grid_songs.set_column_spacing(5)
try:
kids = grid_songs.get_children()
for kid in kids:
grid_songs.remove(kid)
except IndexError:
pass
for song in album_obj.tracks:
i += 1
a += 1
def queue(wdg, song):
self.queue(song)
def play(wdg, song):
self.play(song)
song_wdg = Box(spacing=0)
song_btr = Button()
song_btr.connect('clicked', play, song)
song_btr.set_relief(ReliefStyle.NONE)
song_btr_content = Box(spacing=0)
song_btr.add(song_btr_content)
song_tr = Label()
song_tr.set_markup('<span foreground="grey">' + str(song.track)
+ '</span>')
song_tr.set_width_chars(3)
song_btr_content.pack_start(song_tr, False, True, 0)
song_ti = Label()
song_ti.set_markup('<b>' + self.functions.view_encode(song.title, 22)
+ '</b>')
song_ti.set_alignment(0.0, 0.5)
song_ti.set_size_request(190, -1)
song_btr_content.pack_start(song_ti, False, False, 0)
length = self.functions.human_length(song.length)
song_le = Label()
song_le.set_markup('<span foreground="grey">' + length
+ '</span>')
song_le.set_width_chars(5)
song_btr_content.pack_start(song_le, False, True, 0)
song_wdg.pack_start(song_btr, False, False, 0)
song_add = Button.new_from_icon_name('list-add-symbolic', 0)
song_add.set_property('relief', 2)
song_add.set_size_request(14, 14)
song_add.connect('clicked', queue, song)
song_wdg.pack_start(song_add, False, False, 0)
if i <= len(album_obj.tracks)/2:
column = 0
previous_column = 0
row = a
else:
if previous_column == 0:
a = 0
column = 1
previous_column = 1
row = a
grid_songs.attach(song_wdg, column, row, 1, 1)
popup.show_all()
class Renderer(Overlay):
def __init__(self, win, parser='rst', writer='html4', style=''):
super(Renderer, self).__init__()
self.webview = WebView()
self.webview.connect("mouse-target-changed", self.on_mouse)
self.webview.connect("context-menu", self.on_context_menu)
self.webview.connect("button-release-event", self.on_button_release)
self.add(self.webview)
controller = self.webview.get_find_controller()
self.search_done = None
controller.connect("found-text", self.on_found_text)
controller.connect("failed-to-find-text", self.on_faild_to_find_text)
self.label = Label()
self.label.set_halign(Align.START)
self.label.set_valign(Align.END)
self.add_overlay(self.label)
self.link_uri = None
self.context_button = 3 # will be rewrite by real value
self.set_writer(writer)
self.set_parser(parser)
self.style = style
self.tab_width = 8
self.__win = win
@property
def position(self):
self.__position = -1
self.webview.run_javascript(JS_POSITION, None,
self.on_position_callback, None)
while self.__position < 0:
# this call at this place do problem, when Gdk.threads_init
main_iteration()
return self.__position
def on_position_callback(self, webview, result, data):
try:
js_res = webview.run_javascript_finish(result)
self.__position = js_res.get_js_value().to_double()
except Error:
self.__position = 0
def on_mouse(self, webview, hit_test_result, modifiers):
self.link_uri = None
if hit_test_result.context_is_link():
self.link_uri = hit_test_result.get_link_uri()
text = "link: %s" % self.link_uri
elif hit_test_result.context_is_image():
text = "image: %s" % hit_test_result.get_image_uri()
elif hit_test_result.context_is_media():
text = "media: %s" % hit_test_result.get_media_uri()
else:
if self.label.is_visible():
self.label.hide()
return
self.label.set_markup(MARKUP % text.replace("&", "&"))
self.label.show()
def on_context_menu(self, webview, menu, event, hit_test_result):
self.context_button = event.button.button
return True # disable context menu for now
def on_button_release(self, webview, event):
"""Catch release-button only when try to follow link.
Context menu is catch by webview before this callback.
"""
if event.button == self.context_button:
return True
if self.link_uri:
if self.link_uri.startswith("file://"): # try to open source
self.find_and_opendocument(self.link_uri[7:].split('#')[0])
else:
show_uri_on_window(None, self.link_uri, 0)
return True
def find_and_opendocument(self, file_path):
ext = splitext(file_path)[1]
if not ext:
for EXT in LANGS.keys():
tmp = file_path + EXT
if exists(tmp):
file_path = tmp
ext = EXT
break
if ext in LANGS:
self.__win.open_document(file_path)
elif exists(file_path):
show_uri_on_window(None, "file://" + file_path, 0)
else:
dialog = FileNotFoundDialog(self.__win, file_path)
dialog.run()
dialog.destroy()
def set_writer(self, writer):
assert writer in WRITERS
self.__writer = WRITERS[writer]
klass = self.__writer['class']
self.writer_instance = klass() if klass is not None else None
idle_add(self.do_render)
def get_writer(self):
return self.__writer['key']
def set_parser(self, parser):
assert parser in PARSERS
self.__parser = PARSERS[parser]
klass = self.__parser['class']
self.parser_instance = klass() if klass is not None else None
idle_add(self.do_render)
def get_parser(self):
return self.__parser['key']
def set_style(self, style):
self.style = style
idle_add(self.do_render)
def get_style(self):
return self.style
def set_tab_width(self, width):
self.tab_width = width
def render_output(self):
if getattr(self, 'src', None) is None:
return False, "", "text/plain"
try:
if self.__parser['class'] is None:
html = NOT_FOUND.format(**self.__parser)
elif self.__writer['class'] is None:
html = NOT_FOUND.format(**self.__writer)
elif issubclass(self.__parser['class'], JSONPreview):
try:
json = loads(self.src)
return (False,
dumps(json,
sort_keys=True,
ensure_ascii=False,
indent=4,
separators=(',', ': ')), 'application/json')
except ValueError as e:
return False, DATA_ERROR % ('JSON', str(e)), "text/html"
else:
if not issubclass(self.__parser['class'], HtmlPreview):
settings = {
'warning_stream': StringIO(),
'embed_stylesheet': True,
'tab_width': self.tab_width,
'file_name': self.file_name
}
if self.style:
settings['stylesheet'] = self.style
settings['stylesheet_path'] = []
kwargs = {
'source': self.src,
'parser': self.parser_instance,
'writer': self.writer_instance,
'writer_name': 'html',
'settings_overrides': settings
}
if self.__writer['key'] == 'pep':
kwargs['reader_name'] = 'pep'
kwargs.pop('parser') # pep is allways rst
html = publish_string(**kwargs).decode('utf-8')
return True, html, 'text/html'
else:
if version_info.major == 2:
html = self.src.decode("utf-8")
else:
html = self.src
# output to file or html preview
return False, html, 'text/html'
except DataError as e:
return False, DATA_ERROR % ('Data', e), 'text/html'
except NotImplementedError:
exc_str = format_exc()
return False, NOT_IMPLEMENTED_ERROR % exc_str, 'text/html'
except BaseException:
exc_str = format_exc()
return False, EXCEPTION_ERROR % exc_str, 'text/html'
def do_render(self):
state, html, mime_type = self.render_output()
if state:
if self.pos > 1: # vim
a, b = len(self.src[:self.pos]), len(self.src[self.pos:])
position = (float(a) / (a + b)) if a or b else 0
else:
position = self.pos
html += SCROLL % position
if html and self.__win.runing:
file_name = self.file_name or get_home_dir()
self.webview.load_bytes(Bytes(html.encode("utf-8")), mime_type,
"UTF-8", "file://" + file_name)
def render(self, src, file_name, pos=0):
self.src = src
self.pos = pos
self.file_name = file_name
idle_add(self.do_render)
def print_page(self):
po = PrintOperation.new(self.webview)
po.connect("failed", self.on_print_failed)
po.run_dialog(self.__win)
def on_print_failed(self, po, error):
# FIXME: if dialog is used, application will lock :-(
log_default_handler("Application", LogLevelFlags.LEVEL_WARNING,
error.message)
def do_next_match(self, text):
controller = self.webview.get_find_controller()
if controller.get_search_text() != text:
self.search_done = None
controller.search(text, FindOptions.WRAP_AROUND, MAXUINT)
while self.search_done is None:
main_iteration()
elif self.search_done:
controller.search_next()
return self.search_done
def do_previous_match(self, text):
controller = self.webview.get_find_controller()
if controller.get_search_text() != text:
self.search_done = None
controller.search(text,
FindOptions.WRAP_AROUND | FindOptions.BACKWARDS,
MAXUINT)
while self.search_done is None:
main_iteration()
elif self.search_done:
controller.search_previous()
return self.search_done
def stop_search(self):
controller = self.webview.get_find_controller()
controller.search_finish()
def on_found_text(self, controller, count):
self.search_done = True
def on_faild_to_find_text(self, controller):
self.search_done = False
def scroll_to_position(self, position):
if position is not None:
self.pos = position
if self.pos > 1: # vim
a, b = len(self.src[:self.pos]), len(self.src[self.pos:])
position = (float(a) / (a + b)) if a or b else 0
else:
position = self.pos
self.webview.run_javascript(JS_SCROLL % position, None, None, None)
