def _update_lang_desc_from_buffer(self, w: Gtk.TextBuffer, lang_index):
lang = self._string_provider.get_languages()[lang_index]
self._string_provider.get_model(lang).strings[
self._string_provider.get_index(StringType.MOVE_DESCRIPTIONS,
self.move_id)] = w.get_text(
w.get_start_iter(),
w.get_end_iter(), False)
def buffer_changed(self, buffer: Gtk.TextBuffer):
self.show_spinner(True)
text = buffer.get_text(buffer.get_start_iter(), buffer.get_end_iter(),
True)
GObjectWorker.call(Exporter.export_html_preview, (
self.temp_file.name,
text,
), self.update_html)
def on_test_text_view_buffer_changed( # pylint: disable=no-self-use
self, widget: Gtk.TextBuffer) -> None:
'''
Called when something in the test entry has changed
'''
LOGGER.info(
'Test text view contains: “%s”',
widget.get_text(widget.get_start_iter(), widget.get_end_iter(),
True))
def save_buffer(self, buffer: Gtk.TextBuffer) -> str:
""" Saves a TextBuffer to disk
:param buffer: The buffer to be serialized
:return: The name of the path written to
"""
data = buffer.serialize(buffer, buffer.register_serialize_tagset(),
*buffer.get_bounds())
with open(self.path, 'wb') as file:
file.write(data)
return self.path
def fetch_simple_stats(_, textbuffer: Gtk.TextBuffer) -> None:
tlp_stat_cmd = which("tlp-stat")
if tlp_stat_cmd is None:
textbuffer.set_text(TLP_STAT_MISSING)
return
simple_stat_command = ["tlp-stat", "-r", "-t", "-c", "-s", "-u"]
tlpstat = check_output(simple_stat_command,
stderr=STDOUT).decode(sys.stdout.encoding)
textbuffer.set_text(tlpstat)
def fetch_simple_stats(_, textbuffer: Gtk.TextBuffer) -> None:
"""Fetch simple tlp-stat information."""
tlp_stat_cmd = which("tlp-stat")
if tlp_stat_cmd is None:
textbuffer.set_text(TLP_STAT_MISSING)
return
simple_stat_command = ["tlp-stat", "-r", "-t", "-c", "-s", "-u"]
tlp_stat_output = call_tlp_stat(simple_stat_command)
textbuffer.set_text(tlp_stat_output)
def fetch_simple_stats(_, textbuffer: Gtk.TextBuffer) -> None:
tlp_stat_cmd = which("tlp-stat")
if tlp_stat_cmd is None:
textbuffer.set_text(TLP_STAT_MISSING)
return
simple_stat_command = ["tlp-stat", "-g", "-r", "-t", "-c", "-s", "-u"]
if settings.get_installed_tlp_version().startswith("0_"):
simple_stat_command = ["tlp-stat", "-r", "-t", "-c", "-s", "-u"]
tlpstat = check_output(simple_stat_command, stderr=STDOUT).decode(sys.stdout.encoding)
textbuffer.set_text(tlpstat)
def add_buffer(self, name: Any, buffer: Gtk.TextBuffer):
with self._lock:
self.buffers[name] = buffer
if self._running:
self._signals[name] = buffer.connect(
"changed", lambda _: self._buffer_changed(name))
self._event.set()
def _editingCardBack(self, textbuffer_back: TextBuffer) -> None:
"""
Keeps track of changes at the text_buffer_back.
:param text_buffer_back: TextBuffer object.
:return:
"""
path: TreePath = self._selected_row.get_selected_rows()[1][0]
start_iter_back: TextIter = textbuffer_back.get_start_iter()
end_iter_back: TextIter = textbuffer_back.get_end_iter()
self._subtitles_liststore_back[path][1] = textbuffer_back.get_text(
start_iter_back, end_iter_back, True)
self._dict_any_change_back[path.to_string()] = serializeIt(
text_buffer=textbuffer_back)
def set_errors(self, store: GrammalecteErrorStore,
buffer: Gtk.TextBuffer) -> bool:
"""
Set the result of the request.
:param requester: The requester of the analyze.
:param result: The result of the analyze.
"""
if buffer is not self.text_buffer:
return False
self.clear_tag()
for error in store:
start = self.__convert_limits(error.start)
end = self.__convert_limits(error.end)
buffer.apply_tag(self.error_tag, start, end)
self.__cur_buffer = None
return False
def add_button_if_pos_mark(self, box: Gtk.Box, buffer: Gtk.TextBuffer):
textiter = buffer.get_iter_at_offset(buffer.props.cursor_position)
pos = self._get_start_pos_mark(textiter)
if pos is None or pos != self._active_pos:
self.reset(box)
if pos is not None and pos != self._active_pos:
self._active_pos = pos
self._active_widget: Gtk.Button = Gtk.Button.new_with_label('Edit Position Mark')
self._active_widget.connect('clicked', self.on_clicked)
box.pack_start(self._active_widget, True, False, 0)
return True
def fetch_complete_stats(_, textbuffer: Gtk.TextBuffer) -> None:
sudo_cmd = get_graphical_sudo()
tlp_stat_cmd = which("tlp-stat")
if sudo_cmd is None:
textbuffer.set_text(SUDO_MISSING_TEXT)
return
if tlp_stat_cmd is None:
textbuffer.set_text(TLP_STAT_MISSING)
return
tlpstat = check_output([sudo_cmd, "tlp-stat"], stderr=STDOUT).decode(sys.stdout.encoding)
textbuffer.set_text(tlpstat)
def fetch_complete_stats(_, textbuffer: Gtk.TextBuffer) -> None:
sudo_cmd = get_graphical_sudo()
tlp_stat_cmd = which("tlp-stat")
if sudo_cmd is None:
textbuffer.set_text(SUDO_MISSING_TEXT)
return
if tlp_stat_cmd is None:
textbuffer.set_text(TLP_STAT_MISSING)
return
tlpstat = check_output([sudo_cmd, "tlp-stat"],
stderr=STDOUT).decode(sys.stdout.encoding)
textbuffer.set_text(tlpstat)
def fetch_complete_stats(_, textbuffer: Gtk.TextBuffer) -> None:
"""Fetch complete tlp-stat information."""
sudo_cmd = get_graphical_sudo()
tlp_stat_cmd = which("tlp-stat")
if sudo_cmd is None:
textbuffer.set_text(SUDO_MISSING_TEXT)
return
if tlp_stat_cmd is None:
textbuffer.set_text(TLP_STAT_MISSING)
return
tlp_stat_output = call_tlp_stat([sudo_cmd, "tlp-stat"])
textbuffer.set_text(tlp_stat_output)
def on_tv_paste_import_buffer_paste_done(self, buff: Gtk.TextBuffer,
*args):
text = buff.get_text(buff.get_start_iter(), buff.get_end_iter(), False)
buff.delete(buff.get_start_iter(), buff.get_end_iter())
try:
self.item_effects.import_armips_effect_code(
self._get_current_effect(), text)
self.module.mark_item_effects_as_modified()
md = SkyTempleMessageDialog(MainController.window(),
Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.INFO,
Gtk.ButtonsType.OK,
_("Patch successfully imported."),
is_success=True)
md.run()
md.destroy()
except Exception as err:
display_error(sys.exc_info(), str(err),
_("Error importing ASM code."))
def _get_opcode_in_line(cls,
buffer: Gtk.TextBuffer,
line,
use_temp_markers=False) -> List[Tuple[str, int]]:
marker_prefix = 'opcode_'
marker_pattern = MARK_PATTERN
if use_temp_markers:
marker_prefix = 'TMP_opcode_'
marker_pattern = MARK_PATTERN_TMP
i = buffer.get_iter_at_line(line)
marks = []
while i.get_line() == line:
marks_at_pos = [
m for m in i.get_marks()
if m.get_name() and m.get_name().startswith(marker_prefix)
]
for m in marks_at_pos:
match = marker_pattern.match(m.get_name())
marks.append((str(match.group(1)), int(match.group(2))))
if not i.forward_char(
): # TODO: the other forwards might also work!
return marks
return marks
def description(description: str, text_buffer: Gtk.TextBuffer) -> None:
if description:
center = text_buffer.create_tag('description', justification=Gtk.Justification.CENTER)
text_buffer.insert_with_tags(TextFormat.__pos(text_buffer), '\n\n' + description, center)
def on_title_spanish_changed(self, buffer: TextBuffer):
(start, end) = buffer.get_bounds()
self.icon_banner.title_spanish = buffer.get_text(start, end, True)
self.module.mark_as_modified()
def __pos(text_buffer: Gtk.TextBuffer) -> Gtk.TextIter:
return text_buffer.get_end_iter()
def headline(headline: str, text_buffer: Gtk.TextBuffer) -> None:
if headline:
center = text_buffer.create_tag('center', justification=Gtk.Justification.CENTER, weight=Pango.Weight.BOLD)
text_buffer.insert_with_tags(TextFormat.__pos(text_buffer), headline, center)
def start_playback(wdg):
# Create GStreamer instance
self.gst = GStreamer()
self.gst.set_playback('gapless')
self.gst.player.connect('about-to-finish', self.song_nearly_ended)
self.gst.stop()
self.current_song = False
self.current_album = False
# Prepare buttons
self.btn_playpause = wdg[0][7]
self.btn_previous = wdg[0][5]
self.btn_next = wdg[0][8]
self.btn_stop = wdg[0][6]
self.btn_previous.connect('clicked', self.previous_pressed)
self.btn_stop.connect('clicked', self.stop_pressed)
self.btn_playpause.connect('clicked', self.play_pressed)
self.btn_next.connect('clicked', self.next_pressed)
self.btn_player = wdg[0][9]
self.headerbar = wdg[0][0]
# Create the player box and popover
gtkpla = join(self.functions.datadir, 'glade', 'playerbar.ui')
win = gtk_builder()
win.set_translation_domain('bluemindo')
win.add_from_file(gtkpla)
basebox = win.get_object('playerbox')
wdg[0][0].add(basebox)
self.player_event = win.get_object('player_event')
self.player_event.set_size_request(32, 32)
self.player_button_img = win.get_object('image_cover')
self.player_event.connect('button-press-event', self.show_player)
default = join(self.functions.datadir, 'image', 'logo_head_big.png')
cover_px = Pixbuf.new_from_file_at_scale(default, 20, 20, True)
self.player_button_img.set_from_pixbuf(cover_px)
self.player_event.set_sensitive(False)
self.player_scalab = win.get_object('label_scale')
self.player_scalab.set_markup('<span size="small">00:00</span>')
self.player_sca = win.get_object('scale')
self.player_sca.connect('change-value', self.on_change_value)
self.player_sca.set_sensitive(False)
# Create the player popover
gtkpla = join(self.functions.datadir, 'glade', 'playerpopover.ui')
win = gtk_builder()
win.add_from_file(gtkpla)
hbox = win.get_object('box-player')
self.player_img = win.get_object('image')
self.player_pop = Popover.new(self.player_event)
self.player_pop.set_size_request(200, 200)
self.player_pop.add(hbox)
self.lyrics_button = wdg[1].get_object('tool-lyrics')
self.lyrics_pop = Popover.new(self.lyrics_button)
self.lyrics_pop.set_size_request(400, 600)
box = Box(1, 0)
self.lyrics_swin = ScrolledWindow()
lyrics_tview = TextView()
lyrics_tview.set_editable(False)
self.lyrics_buffer = TextBuffer()
lyrics_tview.set_buffer(self.lyrics_buffer)
self.lyrics_swin.add(lyrics_tview)
box.add(self.lyrics_swin)
self.lyrics_wait = Spinner()
self.lyrics_wait.props.active = True
box.add(self.lyrics_wait)
self.lyrics_pop.add(box)
def show_lyrics(widget):
if self.current_song:
title = self.current_song.title
artist = self.current_song.artist
album = self.current_song.album
filename = self.current_song.filename
sn = self.functions.get_hash(title, artist)
lyrics_file = join(self.userconf.datadir, '%s.lyrics' % sn)
lyrics = self.lyrics_downloader.get_lyrics(title,
artist,
True)
self.lyrics_pop.show_all()
if lyrics is not None:
self.lyrics_wait.hide()
self.lyrics_swin.show()
self.lyrics_buffer.set_text(lyrics)
else:
self.lyrics_swin.hide()
self.lyrics_wait.show()
self.lyrics_buffer.set_text('')
self.lyrics_button.connect('clicked', show_lyrics)
self.lyrics_button.set_sensitive(False)
class Player:
def __init__(self, extensionsloader):
self.extensions = extensionsloader
self.module = {'name': 'Player'}
self.config = {}
self.functions = Functions()
self.userconf = ConfigLoader()
self.lyrics_downloader = LyricsDownloader()
def start_playback(wdg):
# Create GStreamer instance
self.gst = GStreamer()
self.gst.set_playback('gapless')
self.gst.player.connect('about-to-finish', self.song_nearly_ended)
self.gst.stop()
self.current_song = False
self.current_album = False
# Prepare buttons
self.btn_playpause = wdg[0][7]
self.btn_previous = wdg[0][5]
self.btn_next = wdg[0][8]
self.btn_stop = wdg[0][6]
self.btn_previous.connect('clicked', self.previous_pressed)
self.btn_stop.connect('clicked', self.stop_pressed)
self.btn_playpause.connect('clicked', self.play_pressed)
self.btn_next.connect('clicked', self.next_pressed)
self.btn_player = wdg[0][9]
self.headerbar = wdg[0][0]
# Create the player box and popover
gtkpla = join(self.functions.datadir, 'glade', 'playerbar.ui')
win = gtk_builder()
win.set_translation_domain('bluemindo')
win.add_from_file(gtkpla)
basebox = win.get_object('playerbox')
wdg[0][0].add(basebox)
self.player_event = win.get_object('player_event')
self.player_event.set_size_request(32, 32)
self.player_button_img = win.get_object('image_cover')
self.player_event.connect('button-press-event', self.show_player)
default = join(self.functions.datadir, 'image', 'logo_head_big.png')
cover_px = Pixbuf.new_from_file_at_scale(default, 20, 20, True)
self.player_button_img.set_from_pixbuf(cover_px)
self.player_event.set_sensitive(False)
self.player_scalab = win.get_object('label_scale')
self.player_scalab.set_markup('<span size="small">00:00</span>')
self.player_sca = win.get_object('scale')
self.player_sca.connect('change-value', self.on_change_value)
self.player_sca.set_sensitive(False)
# Create the player popover
gtkpla = join(self.functions.datadir, 'glade', 'playerpopover.ui')
win = gtk_builder()
win.add_from_file(gtkpla)
hbox = win.get_object('box-player')
self.player_img = win.get_object('image')
self.player_pop = Popover.new(self.player_event)
self.player_pop.set_size_request(200, 200)
self.player_pop.add(hbox)
self.lyrics_button = wdg[1].get_object('tool-lyrics')
self.lyrics_pop = Popover.new(self.lyrics_button)
self.lyrics_pop.set_size_request(400, 600)
box = Box(1, 0)
self.lyrics_swin = ScrolledWindow()
lyrics_tview = TextView()
lyrics_tview.set_editable(False)
self.lyrics_buffer = TextBuffer()
lyrics_tview.set_buffer(self.lyrics_buffer)
self.lyrics_swin.add(lyrics_tview)
box.add(self.lyrics_swin)
self.lyrics_wait = Spinner()
self.lyrics_wait.props.active = True
box.add(self.lyrics_wait)
self.lyrics_pop.add(box)
def show_lyrics(widget):
if self.current_song:
title = self.current_song.title
artist = self.current_song.artist
album = self.current_song.album
filename = self.current_song.filename
sn = self.functions.get_hash(title, artist)
lyrics_file = join(self.userconf.datadir, '%s.lyrics' % sn)
lyrics = self.lyrics_downloader.get_lyrics(title,
artist,
True)
self.lyrics_pop.show_all()
if lyrics is not None:
self.lyrics_wait.hide()
self.lyrics_swin.show()
self.lyrics_buffer.set_text(lyrics)
else:
self.lyrics_swin.hide()
self.lyrics_wait.show()
self.lyrics_buffer.set_text('')
self.lyrics_button.connect('clicked', show_lyrics)
self.lyrics_button.set_sensitive(False)
# Acquire the songs tree
def acquire_tree(st):
self.songs_tree = st
self.extensions.connect('OnSongsTreeCreated', acquire_tree)
self.extensions.connect('OnBluemindoStarted', start_playback)
self.extensions.connect('OnPlayNewSong', self.on_play_new_song)
self.extensions.connect('OnPlayNewAlbum', self.on_play_new_album)
self.extensions.connect('OnAbortPlayback', self.on_abort_playback)
self.extensions.connect('OnPlayPressed', self.play_pressed)
self.extensions.connect('OnStopPressed', self.stop_pressed)
self.extensions.connect('OnNextPressed', self.next_pressed)
self.extensions.connect('OnPreviousPressed', self.previous_pressed)
def previous_pressed(self, wdg=None):
if self.current_album:
# We are listening an album: move to previous song
album_items = len(self.current_album.tracks) - 1
a = -1
for sng in self.current_album.tracks:
a += 1
if sng.track == self.current_song.track:
item_in_album = a
if item_in_album > 0:
self.on_play_new_song(self.current_album.tracks[item_in_album - 1])
else:
self.stop_pressed(None)
else:
# We were a listening to a single song, try to ask another one
self.extensions.load_event('AskPreviousSong', self.current_song)
def stop_pressed(self, wdg=None):
# Aborting playback
cur = self.gst.getnow()
self.gst.stop()
# Update global vars
self.current_song = False
self.current_album = False
# Update file
current_playing = join(self.userconf.datadir, 'current-playing')
if exists(current_playing):
os_remove(current_playing)
# Update user interface
self.btn_playpause.set_image(Image.new_from_gicon(ThemedIcon(
name='media-playback-start-symbolic'), IconSize.BUTTON))
self.headerbar.props.subtitle = ''
default = join(self.functions.datadir, 'image', 'logo_head_big.png')
cover_px = Pixbuf.new_from_file_at_scale(default, 20, 20, True)
self.player_button_img.set_from_pixbuf(cover_px)
self.player_event.set_sensitive(False)
self.lyrics_button.set_sensitive(False)
self.player_sca.set_sensitive(False)
# Do we have to send the signal?
if wdg is not None:
self.extensions.load_event('OnStopPressed')
def play_pressed(self, wdg=None):
# Get GStreamer status, don't do anything if playser is stopped
first_state = self.gst.getstatus()
if first_state == 'STOP':
return
# Toggles play/pause
self.gst.playpause(None)
new_state = self.gst.getstatus()
# Update user interface
if new_state == 'PAUSED':
self.btn_playpause.set_image(Image.new_from_gicon(ThemedIcon(
name='media-playback-start-symbolic'), IconSize.BUTTON))
else:
self.btn_playpause.set_image(Image.new_from_gicon(ThemedIcon(
name='media-playback-pause-symbolic'), IconSize.BUTTON))
def next_pressed(self, wdg=None):
if self.current_album:
# We are listening an album: move to next song
album_items = len(self.current_album.tracks) - 1
a = -1
for sng in self.current_album.tracks:
a += 1
if sng.track == self.current_song.track:
item_in_album = a
if item_in_album < album_items:
self.on_play_new_song(self.current_album.tracks[item_in_album + 1])
else:
self.stop_pressed(None)
else:
# We were a listening to a single song, try to ask another one
self.extensions.load_event('AskNextSong', self.current_song)
def on_abort_playback(self):
self.stop_pressed(None)
def on_play_new_song(self, song):
# Guess ReplayGain mode
if hasattr(song, 'rg_mode_guess') and song.rg_mode_guess == 'album':
self.gst.change_rg_mode('album')
else:
if not self.current_album:
self.gst.change_rg_mode('track')
else:
if song in self.current_album.tracks:
self.gst.change_rg_mode('album')
else:
self.current_album = False
self.gst.change_rg_mode('track')
# Play the song
cur = self.gst.getnow()
self.gst.playpause(song.filename)
# Update global vars
self.current_song = song
# Update user interface
self.btn_playpause.set_image(Image.new_from_gicon(ThemedIcon(
name='media-playback-pause-symbolic'), IconSize.BUTTON))
title = song.title
artist = song.artist
album = song.album
filename = song.filename
self.headerbar.props.subtitle = title + ' - ' + artist
default = join(self.functions.datadir, 'image', 'logo_head_big.png')
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, 32, 32, True)
else:
cover_px = Pixbuf.new_from_file_at_scale(default, 20, 20, True)
self.player_button_img.set_from_pixbuf(cover_px)
self.player_event.set_sensitive(True)
self.lyrics_button.set_sensitive(True)
# Update file
current_playing = join(self.userconf.datadir, 'current-playing')
file_ = open(current_playing, 'w')
file_.write(title + ' - ' + artist + ' (from: ' + album + ')')
file_.close()
# Update player informations
if isfile(cover):
cover_px = Pixbuf.new_from_file_at_scale(cover, 200, 200, True)
else:
cover_px = Pixbuf.new_from_file_at_scale(default, 120, 120, True)
self.player_img.set_from_pixbuf(cover_px)
# Create the scale
self.player_sca.set_sensitive(True)
self.player_sca.set_range(0, float(song.length))
timeout_add(500, self.scale_timer)
# Download lyrics
thread = Thread(group=None, target=self.lyrics_downloader.get_lyrics,
name='lyrics', args=(title, artist))
thread.start()
# Send notification to extensions about this new song
self.extensions.load_event('HasStartedSong', song)
def on_play_new_album(self, album):
self.current_album = album
self.on_play_new_song(album.tracks[0])
def song_nearly_ended(self, *args):
idle_add(self.next_pressed, True)
def show_player(self, widget, ka):
self.player_pop.show_all()
def scale_timer(self):
pos = self.gst.getposition()
position = int(self.gst.getposition() / 1000000000)
self.player_scalab.set_markup('<span size="small">' +
self.functions.human_length(position) +
'</span>')
self.player_sca.set_value(position)
return True
def on_change_value(self, widget, scroll, value):
seconds = int(value)
self.gst.seek(seconds)
def get_text(buffer: Gtk.TextBuffer):
"""Get the full content of a GtkTextBuffer"""
return buffer.get_text(buffer.get_start_iter(), buffer.get_end_iter(),
True)
def article(article: str, text_buffer: Gtk.TextBuffer) -> None:
if article:
text_buffer.insert(TextFormat.__pos(text_buffer), '\n')
paragraph = text_buffer.create_tag('paragraph')
text_buffer.insert_with_tags(TextFormat.__pos(text_buffer), '\n' + article + '\n', paragraph)
def user_action(buffer: Gtk.TextBuffer):
buffer.begin_user_action()
yield buffer
buffer.end_user_action()
def on_text_buffer_modified(self, buffer: Gtk.TextBuffer, *args):
if self._modified_handler:
self._modified_handler(self, buffer.get_modified())
def tab_suggest(buff: Gtk.TextBuffer, listore=None):
global store
text = str(
buff.get_text(buff.get_start_iter(),
buff.get_iter_at_mark(buff.get_insert()), False))
completions = None
for _ in range(5):
try:
completions = Script(text).complete()
break
except:
return
if len(completions) == 1:
com = str(completions[0].name)
text = buff.get_insert()
start_it = buff.get_start_iter()
text = str(buff.get_text(start_it, buff.get_iter_at_mark(text), False))
sp1 = text.split(' ')[-1].split('.')
it1 = buff.get_iter_at_mark(buff.get_insert())
it2 = buff.get_iter_at_mark(buff.get_insert())
lin = it1.get_line()
while 1:
_k = it1.backward_char()
if not _k:
break
#if sp1[-1] == it1.get_char():
# break
if it1.get_line() < lin:
it1.forward_char()
break
if it1.get_char().isspace():
it1.forward_char()
break
if '\n' in list(it1.get_char()):
it1.forward_char()
break
if it1.get_char() != "_" and it1.get_char().isalnum() is False:
it1.forward_char()
break
buff.delete(it1, it2)
buff.insert_at_cursor(com)
store = 0
elif completions is not None and len(completions) > 0:
store = [x.name for x in completions if x]
