# Copyright (C) 2008-2010 Adam Olsen
#
# This program 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 2, or (at your option)
# any later version.
#
# This program 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
#
# The developers of the Exaile media player hereby grant permission
# for non-GPL compatible GStreamer and Exaile plugins to be used and
# distributed together with GStreamer and Exaile. This permission is
# above and beyond the permissions granted by the GPL license by which
# Exaile is covered. If you modify this code, you may extend this
# exception to your version of the code, but you are not obligated to
# do so. If you do not wish to do so, delete this exception statement
# from your version.
import hashlib
import logging
import os
from typing import Any, Callable, Optional
from gi.repository import Gdk
from gi.repository import GLib
from gi.repository import Gtk
from gi.repository import Pango
from xl.nls import gettext as _
from xl import event, main, settings
from xlgui import guiutil
from xlgui.widgets import dialogs
from xlgui.guiutil import GtkTemplate
logger = logging.getLogger(__name__)
class Preference:
"""
Representing a Gtk.Entry preferences item
"""
default: Any = ''
done: Callable[[], bool]
label_widget: Optional[Gtk.Widget]
name: str
restart_required = False
def __init__(self, preferences, widget):
"""
Initializes the preferences item
expects the name of the widget in the designer file, the default for
this setting, an optional function to be called when the value is
changed, and an optional function to be called when this setting
is applied
"""
self.widget = widget
self.preferences = preferences
if self.restart_required:
self.message = dialogs.MessageBar(
parent=preferences.builder.get_object('preferences_box'),
type=Gtk.MessageType.QUESTION,
buttons=Gtk.ButtonsType.CLOSE,
text=_('Restart Exaile?'),
)
self.message.set_secondary_text(
_('A restart is required for this change to take effect.')
)
button = self.message.add_button(_('Restart'), Gtk.ResponseType.ACCEPT)
button.set_image(
Gtk.Image.new_from_icon_name('view-refresh', Gtk.IconSize.BUTTON)
)
self.message.connect('response', self.on_message_response)
self._set_value()
self._setup_change()
def change(self, *args):
self.apply()
def _setup_change(self):
"""
Sets up the function to be called when this preference is changed
"""
self.widget.connect(
'focus-out-event', self.change, self.name, self._get_value()
)
try:
self.widget.connect(
'activate',
lambda *e: self.change(self.widget, None, self.name, self._get_value()),
)
except TypeError:
pass
def _get_value(self):
"""
Value to be stored into the settings file
"""
return self.widget.get_text()
def _set_value(self):
"""
Sets the GUI widget up for this preference
"""
if not self.widget:
logger.error("Widget not found: %s", self.name)
return
self.widget.set_text(str(settings.get_option(self.name, self.default)))
def apply(self, value=None):
"""
Applies this setting
"""
if hasattr(self, 'done') and not self.done():
return False
oldvalue = settings.get_option(self.name, self.default)
if value is None:
value = self._get_value()
if value != oldvalue:
settings.set_option(self.name, value)
if self.restart_required:
self.message.show()
return True
def on_message_response(self, widget, response):
"""
Restarts Exaile if requested
"""
widget.hide()
if response == Gtk.ResponseType.ACCEPT:
GLib.idle_add(main.exaile().quit, True)
def hide_widget(self):
'''Hides the widget and optionally its associated label'''
self.widget.hide()
if hasattr(self, 'label_widget'):
self.label_widget.hide()
def show_widget(self):
'''Shows the widget and optionally its associated label'''
self.widget.show_all()
if hasattr(self, 'label_widget'):
self.label_widget.show_all()
def set_widget_sensitive(self, value):
'''Sets sensitivity of widget and optionally its associated label'''
self.widget.set_sensitive(value)
if hasattr(self, 'label_widget'):
self.label_widget.set_sensitive(value)
class Conditional:
"""
Allows for reactions on changes
of other preference items
"""
condition_preference_name = ''
condition_widget = None
def __init__(self):
event.add_ui_callback(self.on_option_set, 'option_set')
GLib.idle_add(
self.on_option_set, 'option_set', settings, self.condition_preference_name
)
def get_condition_value(self):
"""
:returns: The currently selected value in the condition widget,
presumes it is a combo box
"""
i = self.condition_widget.get_active_iter()
return self.condition_widget.get_model().get_value(i, 0)
def on_check_condition(self):
"""
Specifies the condition to meet
:returns: Whether the condition is met or not
:rtype: bool
"""
pass
def on_condition_met(self):
"""
Called as soon as the
specified condition is met
"""
self.widget.set_sensitive(True)
def on_condition_failed(self):
"""
Called as soon as the specified
condition is not met anymore
"""
self.widget.set_sensitive(False)
def on_option_set(self, event, settings, option):
"""
Called as soon as options change
"""
if option == self.condition_preference_name:
if self.on_check_condition():
self.on_condition_met()
else:
self.on_condition_failed()
def check_condition(self):
if self.on_check_condition():
self.on_condition_met()
else:
self.on_condition_failed()
class CheckConditional(Conditional):
"""
True if the conditional widget is active
"""
def get_condition_value(self):
return self.condition_widget.get_active()
def on_check_condition(self):
"""
Specifies the condition to meet
:returns: Whether the condition is met or not
:rtype: bool
"""
return self.get_condition_value()
class MultiConditional:
"""
Allows for reactions on changes of multiple preference items
"""
condition_preference_names = []
condition_widgets = {}
def __init__(self):
event.add_ui_callback(self.on_option_set, 'option_set')
GLib.idle_add(
self.on_option_set,
'option_set',
settings,
self.condition_preference_names[0],
)
def get_condition_value(self, name):
"""
:returns: The currently selected value in the condition widget,
presumes it is a combo box
"""
widget = self.condition_widgets[name]
return widget.get_model().get_value(widget.get_active_iter(), 0)
def on_check_condition(self):
"""
Specifies the condition to meet
:returns: Whether the condition is met or not
:rtype: bool
"""
pass
def on_condition_met(self):
"""
Called as soon as the
specified condition is met
"""
self.widget.set_sensitive(True)
def on_condition_failed(self):
"""
Called as soon as the specified
condition is not met anymore
"""
self.widget.set_sensitive(False)
def on_option_set(self, event, settings, option):
"""
Called as soon as options change
"""
if option in self.condition_preference_names:
if self.on_check_condition():
self.on_condition_met()
else:
self.on_condition_failed()
def check_condition(self):
if self.on_check_condition():
self.on_condition_met()
else:
self.on_condition_failed()
class Button(Preference):
"""
Represents a button for custom usage
"""
def __init__(self, preferences, widget):
Preference.__init__(self, preferences, widget)
widget.connect('clicked', self.on_clicked)
def _setup_change(self, *e):
pass
def _get_value(self):
return None
def _set_value(self):
pass
def apply(self, *e):
return False
def on_clicked(self, button):
"""Override"""
pass
class HashedPreference(Preference):
"""
Represents a text entry with automated hashing
Options:
* type (Which hashfunction to use, default: md5)
"""
type = 'md5'
def __init__(self, preferences, widget):
Preference.__init__(self, preferences, widget)
self.widget.set_visibility(True)
self._delete_text_id = self.widget.connect('delete-text', self.on_delete_text)
self._insert_text_id = self.widget.connect('insert-text', self.on_insert_text)
def _setup_change(self):
"""
Sets up the function to be called when this preference is changed
"""
self.widget.connect('focus-out-event', lambda *e: self.apply())
def done(self):
"""
Determines if changes are to be expected
"""
if self._delete_text_id is None and self._insert_text_id is None:
return True
return False
def apply(self, value=None):
"""
Applies this setting
"""
if not self.done():
return False
if value is None:
value = self._get_value()
if value is None:
return True
if value != '':
hashfunc = hashlib.new(self.type)
hashfunc.update(value.encode('utf-8'))
value = hashfunc.hexdigest()
oldvalue = settings.get_option(self.name, self.default)
if value != oldvalue:
settings.set_option(self.name, value)
self.widget.set_text(value)
self.widget.set_visibility(True)
self._delete_text_id = self.widget.connect('delete-text', self.on_delete_text)
self._insert_text_id = self.widget.connect('insert-text', self.on_insert_text)
return True
def on_delete_text(self, widget, start, end):
"""
Clears the text entry and makes following input invisible
"""
self.widget.disconnect(self._delete_text_id)
self.widget.disconnect(self._insert_text_id)
self._delete_text_id = self._insert_text_id = None
self.widget.set_visibility(False)
self.widget.set_text('')
def on_insert_text(self, widget, text, length, position):
"""
Clears the text entry and makes following input invisible
"""
self.widget.disconnect(self._delete_text_id)
self.widget.disconnect(self._insert_text_id)
self._delete_text_id = self._insert_text_id = None
self.widget.set_visibility(False)
# Defer to after returning from this method
GLib.idle_add(self.widget.set_text, text)
GLib.idle_add(self.widget.set_position, length)
class CheckPreference(Preference):
"""
A class to represent check boxes in the preferences window
"""
def __init__(self, preferences, widget):
Preference.__init__(self, preferences, widget)
def _setup_change(self):
self.widget.connect('toggled', self.change)
def _set_value(self):
self.widget.set_active(settings.get_option(self.name, self.default))
def _get_value(self):
return self.widget.get_active()
class DirPreference(Preference):
"""
Directory chooser button
"""
def __init__(self, preferences, widget):
Preference.__init__(self, preferences, widget)
def _setup_change(self):
self.widget.connect('current-folder-changed', self.change)
def _set_value(self):
"""
Sets the current directory
"""
directory = os.path.expanduser(settings.get_option(self.name, self.default))
if not os.path.exists(directory):
os.makedirs(directory)
self.widget.set_current_folder(directory)
def _get_value(self):
return self.widget.get_filename()
class OrderListPreference(Preference):
"""
A list box with reorderable items
"""
def __init__(self, preferences, widget):
self.model = Gtk.ListStore(str)
Preference.__init__(self, preferences, widget)
widget.set_headers_visible(False)
widget.set_reorderable(True)
text = Gtk.CellRendererText()
col = Gtk.TreeViewColumn("Item", text, text=0)
self.widget.append_column(col)
self.widget.set_model(self.model)
def _setup_change(self):
self.widget.connect('drag-end', self.change)
def _set_value(self):
"""
Sets the preferences for this widget
"""
items = settings.get_option(self.name, self.default)
self.model.clear()
for item in items:
self.model.append([item])
def _get_value(self):
"""
Value to be stored into the settings file
"""
items = []
for row in self.model:
items += [row[0]]
return items
class SelectionListPreference(Preference):
"""
A list allowing for enabling/disabling
as well as reordering of items
Options:
* items: list of :class:`SelectionListPreference.Item` objects
* default: list of item ids
"""
class Item:
"""
Convenience class for preference item description
"""
def __init__(self, id, title, description=None, fixed=False):
"""
:param id: the unique identifier
:type id: string
:param title: the readable title
:type title: string
:param description: optional description of the item
:type description: string
:param fixed: whether the item should be removable
:type fixed: bool
"""
self.__id = id
self.__title = title
self.__description = description
self.__fixed = fixed
id = property(lambda self: self.__id)
title = property(lambda self: self.__title)
description = property(lambda self: self.__description)
fixed = property(lambda self: self.__fixed)
@GtkTemplate('ui', 'preferences', 'widgets', 'selection_list_preference.ui')
class InternalWidget(Gtk.ScrolledWindow):
"""
Internal class for making GtkTemplate work with subclassing
"""
__gtype_name__ = 'InternalWidget'
(
model,
tree,
toggle_renderer,
text_renderer,
enabled_column,
title_column,
) = GtkTemplate.Child.widgets(6)
selectionlp = None
def __init__(self, preference):
Gtk.ScrolledWindow.__init__(self)
self.init_template()
self.selectionlp = preference
self.tree.enable_model_drag_source(
Gdk.ModifierType.BUTTON1_MASK,
[('GTK_TREE_MODEL_ROW', Gtk.TargetFlags.SAME_WIDGET, 0)],
Gdk.DragAction.MOVE,
)
self.tree.enable_model_drag_dest(
[('GTK_TREE_MODEL_ROW', Gtk.TargetFlags.SAME_WIDGET, 0)],
Gdk.DragAction.MOVE,
)
self.tree.connect('drag-end', self.selectionlp.change)
self.enabled_column.set_cell_data_func(
self.toggle_renderer, self.enabled_data_function
)
self.title_column.set_cell_data_func(
self.text_renderer, self.title_data_function
)
@GtkTemplate.Callback
def on_row_activated(self, tree, path, column):
"""
Updates the enabled column
"""
if self.model[path][4]:
return
enabled = not self.model[path][3]
self.model[path][3] = enabled
def enabled_data_function(self, column, cell, model, iter, user_data):
"""
Prepares sensitivity
of the enabled column
"""
path = model.get_path(iter)
fixed = model[path][4]
cell.props.sensitive = not fixed
def title_data_function(self, column, cell, model, iter, user_data):
"""
Prepares the markup to be
used for the title column
"""
path = model.get_path(iter)
title, description = model[path][1], model[path][2]
markup = '%s' % title
if description is not None:
markup += '\n%s' % description
cell.props.markup = markup
def iter_prev(self, iter, model):
"""
Returns the previous iter
Taken from PyGtk FAQ 13.51
"""
path = model.get_path(iter)
position = path[-1]
if position == 0:
return None
prev_path = list(path)[:-1]
prev_path.append(position - 1)
prev = model.get_iter(tuple(prev_path))
return prev
@GtkTemplate.Callback
def on_key_press_event(self, tree, event):
"""
Allows for reordering via keyboard (Alt+)
"""
if not event.get_state() & Gdk.ModifierType.MOD1_MASK:
return
if event.keyval not in (Gdk.KEY_Up, Gdk.KEY_Down):
return
model, selected_iter = tree.get_selection().get_selected()
if event.keyval == Gdk.KEY_Up:
previous_iter = self.iter_prev(selected_iter, model)
model.move_before(selected_iter, previous_iter)
elif event.keyval == Gdk.KEY_Down:
next_iter = model.iter_next(selected_iter)
model.move_after(selected_iter, next_iter)
tree.scroll_to_cell(model.get_path(selected_iter))
self.selectionlp.apply()
@GtkTemplate.Callback
def on_toggled(self, cell, path):
"""
Updates the enabled column
"""
if self.model[path][4]:
return
active = not cell.get_active()
cell.set_active(active)
self.model[path][3] = active
self.selectionlp.apply()
def __init__(self, preferences, widget):
internal_widget = self.InternalWidget(self)
self.model = internal_widget.model
for item in self.items:
row = [item.id, item.title, item.description, True, item.fixed]
self.model.append(row)
guiutil.gtk_widget_replace(widget, internal_widget)
Preference.__init__(self, preferences, internal_widget)
def _get_value(self):
"""
Value to be stored in the settings
"""
return [row[0] for row in self.model if row[3]]
def _set_value(self):
"""
Updates the internal representation
"""
selected_items = settings.get_option(self.name, self.default)
# Get list of available items
available_items = [row[0] for row in self.model]
if not available_items:
return
# Filter out invalid items
selected_items = [item for item in selected_items if item in available_items]
# Cut out unselected items
unselected_items = [
item for item in available_items if item not in selected_items
]
# Move unselected items to the end
items = selected_items + unselected_items
new_order = [available_items.index(item) for item in items]
self.model.reorder(new_order)
# Disable unselected items
for row in self.model:
if row[0] in unselected_items and not row[4]:
row[3] = False
else:
row[3] = True
class ShortcutListPreference(Preference):
"""
A list showing available items and allowing
to assign/edit/remove key accelerators
"""
def __init__(self, preferences, widget):
self.list = Gtk.ListStore(str, str)
Preference.__init__(self, preferences, widget)
self.widget.set_model(self.list)
title_renderer = Gtk.CellRendererText()
title_column = Gtk.TreeViewColumn(_('Action'), title_renderer, text=0)
title_column.set_expand(True)
title_column.set_cell_data_func(title_renderer, self.title_data_func)
accel_renderer = Gtk.CellRendererAccel()
accel_renderer.set_property('editable', True)
accel_renderer.set_property('style', Pango.Style.OBLIQUE)
accel_renderer.connect('accel-cleared', self.on_accel_cleared)
accel_renderer.connect('accel-edited', self.on_accel_edited)
accel_column = Gtk.TreeViewColumn(_('Shortcut'), accel_renderer, text=1)
accel_column.set_expand(True)
self.widget.append_column(title_column)
self.widget.append_column(accel_column)
def title_data_func(self, celllayout, cell, model, iter, user_data):
"""
Renders human readable titles instead of the actual keys
"""
key = model.get_value(iter, 0)
try:
cell.set_property('text', self.available_items[key])
except KeyError:
pass
def on_accel_cleared(self, cellrenderer, path):
"""
Clears accelerators in the list
"""
iter = self.list.get_iter(path)
self.list.set_value(iter, 1, '')
def on_accel_edited(self, cellrenderer, path, accel_key, accel_mods, keycode):
"""
Updates accelerators display in the list
"""
accel = Gtk.accelerator_name(accel_key, accel_mods)
iter = self.list.get_iter(path)
self.list.set_value(iter, 1, accel)
def _set_value(self):
"""
Sets the preferences for this widget
"""
items = settings.get_option(self.name, self.default)
self.update_list(items)
def _get_value(self):
"""
Value to be stored into the settings file
"""
option = {}
iter = self.list.get_iter_first()
while iter:
action = self.list.get_value(iter, 0)
accel = self.list.get_value(iter, 1)
if accel:
option[action] = accel
iter = self.list.iter_next(iter)
return option
def update_list(self, items):
"""
Updates the displayed items
"""
self.list.clear()
for action in self.available_items.keys():
try:
accel = items[action]
except KeyError:
accel = ''
self.list.append([action, accel])
class TextViewPreference(Preference):
"""
Represents a Gtk.TextView
"""
def __init__(self, preferences, widget):
"""
Initializes the object
"""
Preference.__init__(self, preferences, widget)
def _setup_change(self):
self.widget.connect('focus-out-event', self.change)
def get_all_text(self):
"""
Returns the value of the text buffer
"""
buf = self.widget.get_buffer()
start = buf.get_start_iter()
end = buf.get_end_iter()
return buf.get_text(start, end, True)
def _set_value(self):
"""
Sets the value of this widget
"""
self.widget.get_buffer().set_text(
str(settings.get_option(self.name, default=self.default))
)
def _get_value(self):
"""
Applies the setting
"""
return self.get_all_text()
class ListPreference(Preference):
"""
A class to represent a space separated list in the preferences window
"""
def __init__(self, preferences, widget):
Preference.__init__(self, preferences, widget)
def _set_value(self):
items = settings.get_option(self.name, default=self.default)
try:
items = " ".join(items)
except TypeError:
items = ""
self.widget.set_text(items)
def _get_value(self):
import shlex
return shlex.split(self.widget.get_text())
class SpinPreference(Preference):
"""
A class to represent a numeric entry box with stepping buttons
"""
def __init__(self, preferences, widget):
Preference.__init__(self, preferences, widget)
def _set_value(self):
value = settings.get_option(self.name, default=self.default)
self.widget.set_value(value)
def _setup_change(self):
self.widget.connect('value-changed', self.change)
def _get_value(self):
return self.widget.get_value()
class ScalePreference(SpinPreference):
"""
Representation of Gtk.Scale widgets
"""
def __init__(self, preferences, widget):
SpinPreference.__init__(self, preferences, widget)
class FloatPreference(Preference):
"""
A class to represent a floating point number in the preferences window
"""
def __init__(self, preferences, widget):
Preference.__init__(self, preferences, widget)
def _set_value(self):
self.widget.set_text(str(settings.get_option(self.name, default=self.default)))
def _get_value(self):
return float(self.widget.get_text())
class IntPreference(FloatPreference):
def _get_value(self):
return int(self.widget.get_text())
class RGBAButtonPreference(Preference):
"""
A class to represent the color button
"""
def __init__(self, preferences, widget):
Preference.__init__(self, preferences, widget)
def _setup_change(self):
self.widget.connect('color-set', self.change)
def _set_value(self):
value = settings.get_option(self.name, self.default)
rgba = Gdk.RGBA()
rgba.parse(value)
self.widget.set_rgba(rgba)
def _get_value(self):
return self.widget.get_rgba().to_string()
class FontButtonPreference(Preference):
"""
Font button
"""
def __init__(self, preferences, widget):
Preference.__init__(self, preferences, widget)
def _setup_change(self):
self.widget.connect('font-set', self.change)
def _set_value(self):
font = settings.get_option(self.name, self.default)
self.widget.set_font_name(font)
def _get_value(self):
font = self.widget.get_font_name()
return font
class FontResetButtonPreference(Button, Conditional):
"""
A button to reset a font button to a default font
"""
def __init__(self, preferences, widget):
Button.__init__(self, preferences, widget)
Conditional.__init__(self)
def on_check_condition(self):
if self.condition_widget.get_font_name() == self.default:
return False
return True
def on_clicked(self, button):
self.condition_widget.set_font_name(self.default)
self.condition_widget.emit('font-set')
class ComboPreference(Preference):
"""
A combo box. The value stored in the settings must be the
first column of the combo box model.
"""
def __init__(self, preferences, widget):
Preference.__init__(self, preferences, widget)
def _setup_change(self):
self.widget.connect('changed', self.change)
def _set_value(self):
"""
Sets the preferences for this widget
"""
item = settings.get_option(self.name, self.default)
model = self.widget.get_model()
for row in model:
if item == row[0]:
self.widget.set_active_iter(row.iter)
def _get_value(self):
"""
Value to be stored into the settings file
"""
model = self.widget.get_model()
iter = self.widget.get_active_iter()
return model.get_value(iter, 0)
class ComboEntryPreference(Preference):
"""
A combo box allowing for user defined
values, presets and auto completion
Options:
* completion_items (List of completion items or
dictionary of items and their titles)
* preset_items (List of preset items or
dictionary of items and their titles)
"""
def __init__(self, preferences, widget):
Preference.__init__(self, preferences, widget)
self.list = Gtk.ListStore(str)
try:
try:
preset_items = list(self.preset_items.items())
self.list = Gtk.ListStore(str, str)
text_renderer = self.widget.get_cells()[0]
text_renderer.set_property('weight', Pango.Weight.BOLD)
title_renderer = Gtk.CellRendererText()
self.widget.pack_start(title_renderer, False)
self.widget.add_attribute(title_renderer, 'text', 1)
except AttributeError:
preset_items = [[item] for item in self.preset_items]
for preset in preset_items:
self.list.append(preset)
except AttributeError:
pass
self.widget.set_model(self.list)
self.widget.set_entry_text_column(0)
try:
completion = Gtk.EntryCompletion()
try:
completion_items = list(self.completion_items.items())
self.completion_list = Gtk.ListStore(str, str)
title_renderer = Gtk.CellRendererText()
completion.pack_end(title_renderer, True)
completion.add_attribute(title_renderer, 'text', 1)
except AttributeError:
completion_items = [[item] for item in self.completion_items]
self.completion_list = Gtk.ListStore(str)
keyword_renderer = Gtk.CellRendererText()
keyword_renderer.set_property('weight', Pango.Weight.BOLD)
completion.pack_end(keyword_renderer, True)
completion.add_attribute(keyword_renderer, 'text', 0)
completion.set_match_func(self.on_matching)
completion.connect('match-selected', self.on_match_selected)
completion.set_popup_single_match(True)
completion.set_model(self.completion_list)
self.widget.get_child().set_completion(completion)
for item in completion_items:
self.completion_list.append(item)
except AttributeError:
pass
def _setup_change(self):
"""
Sets up the function to be called
when this preference is changed
"""
self.widget.connect('changed', self.change, self.name, self._get_value())
def _set_value(self):
"""
Sets the preferences for this widget
"""
value = settings.get_option(self.name, self.default)
self.widget.get_child().set_text(str(value))
def _get_value(self):
"""
Value to be stored into the settings file
"""
return self.widget.get_child().get_text()
def on_matching(self, completion, text, iter):
"""
Matches the content of this box to
the list of available completions
"""
cursor_pos = self.widget.get_child().get_position()
# Ignore the rest, allows for completions in the middle
text = text[:cursor_pos]
match = self.completion_list.get_value(iter, 0)
# Try to find match, from largest to smallest
for i in range(len(match), -1, -1):
# Find from the rear
match_pos = text.rfind(match[:i])
# Matched if the match is not empty
# and equal to the text from the matched position to the end
# and not equal to the match itself
# (the latter hides the match if it was already fully typed)
if match[:i] and match[:i] == text[match_pos:] and match[:i] != match:
return True
return False
def on_match_selected(self, completion, list, iter):
"""
Inserts the selected completion
"""
cursor_pos = self.widget.get_child().get_position()
text = self.widget.get_child().get_text()[:cursor_pos]
match = list.get_value(iter, 0)
for i in range(len(match), -1, -1):
match_pos = text.rfind(match[:i])
if match[:i] and match[:i] == text[match_pos:]:
# Delete halfway typed text
self.widget.get_child().delete_text(
match_pos, match_pos + len(match[:i])
)
# Insert match at matched position
self.widget.get_child().insert_text(match, match_pos)
# Update cursor position
self.widget.get_child().set_position(match_pos + len(match))
return True
# vim: et sts=4 sw=4