def onAddZoneButtonClicked(self, button):
"""
1) Display a dialog where the user can input the new zone name.
2) Handle user input.
Trigger:
User clicks the "+" button in Zones header bar.
"""
entry = Entry()
addZoneDialog = self.view.dialogs.AddZone(self.view, entry)
while True:
response = addZoneDialog.run()
if response == ResponseType.OK:
# Get user input from the dialog
zoneName = entry.get_text()
if not self.model.zoneExistsInDatabase(zoneName):
# Ζone is absent from the database.
# Αdd it and try to load it with the default playlists.
self.model.addZoneToDatabase(zoneName)
self.model.attemptToAddDefaultPlaylistsToZone(zoneName)
break
else:
# Zone already exists in database.
# Notify the user and let him retry.
self.view.dialogs.MessagePopup(
addZoneDialog, MessageType.ERROR, 'Error',
'Zone already exists.').show()
else:
break
addZoneDialog.destroy()
def on_id_code_changed(self, entry: Entry):
try:
self.project.set_id_code(entry.get_text())
self.module.mark_as_modified()
except:
# Invalid input, e.g. non-ASCII characters
entry.set_text(self.project.get_id_code())
def check_input(
self,
entry: Gtk.Entry,
leading_zeroes: int = 0,
places: int = 0,
minimum: Optional[Union[int, float, Decimal]] = None,
maximum: Optional[Union[int, float, Decimal]] = None,
):
"""Validate the entry text.
This inserts leading zeroes, ensures the number is within a given
range and inserts omitted year digits.
Args:
entry (Gtk.Entry): The focused entry.
event (Gdk.EventFocus): The focus event.
leading_zeroes (int, optional): Up to which length to insert
leading zeroes.
E.g. leading_zeroes=4, entry_text="75" -> "0075"
minimum (Union[Callable[..., Number], Number], optional): The
minimum value of the text or a function that returns the
minimum/maximum value. Defaults to None
maximum (Union[Callable[..., Number], Number], optional): The
maximum value of the text or a function that returns the
minimum/maximum value. Defaults to None
year (bool, optional): Whether the number is a year
"""
if self.editable:
text: str = entry.get_text()
if text == "":
return
text = text.replace(",", ".").zfill(1)
value: Union[int, Decimal]
if places > 0:
value = Decimal(text)
q: Decimal = Decimal(10)**-places
if minimum is not None:
value = max(value, Decimal(minimum))
if maximum is not None:
value = min(value, Decimal(maximum))
value = value.quantize(q)
entry.set_text(
str(value).replace(".", ",").zfill(leading_zeroes + 2))
else: # Int
value = int(text)
if minimum is not None:
value = int(max(value, minimum))
if maximum is not None:
value = int(min(value, maximum))
entry.set_text(format(int(value), f"0{leading_zeroes}d"))
def set_text_entry_string(text_entry: Gtk.Entry, text: str) -> None:
"""
Sets the current text of a text entry widget
:param text_entry: the text entry widget to be modified
:param text: the text to be entered into th widget
:return: void
"""
text_entry.set_text(text)
def on_entry_changed(self, entry: Gtk.Entry) -> None:
"""React to the text of an entry changing. Removes the 'error' CSS
class from the entry.
Args:
entry (Gtk.Entry): The changed entry
"""
entry.get_style_context().remove_class("error")
def on_medium_token(self, sender: Gtk.Entry) -> None:
token = sender.get_text().strip()
self.settings.set_string("medium-personal-token", token)
if token:
sender.set_sensitive(False)
medium_client = Medium(access_token=token)
GObjectWorker.call(medium_client.get_user, callback=self.on_medium_callback)
else:
self.settings.set_string("medium-user-id", "")
def on_digit_only_setting_changed(entry: Gtk.Entry) -> None:
current_value = entry.get_text()
section = entry.get_section_name()
option = entry.get_name()
if current_value.isdigit():
config.new(section, option, int(current_value))
else:
entry.set_text(utils.remove_letters(current_value))
def _validate_completed(self, entry: Gtk.Entry, focus: Gdk.EventFocus):
text = entry.get_text()
context = entry.get_style_context()
error = self.find_completed_errors(text)
if error:
context.add_class('error')
self.set_warning_text(error)
self._show_warning()
else:
self._hide_warning_slowly()
context.remove_class('error')
def _setTextEntry(self) -> None:
"""
Sets the text entry for deck name.
:return:
"""
self._entry = Entry(placeholder_text='Deck name...')
setMargin(self._entry, 10, 5, 10, 5)
self._fst_grid.attach(self._entry, 1, 4, 1, 1)
def _set_entry_text(label: Gtk.Entry, text: Optional[str], *args: Any) -> None:
if text is not None and None not in args:
label.set_sensitive(True)
label.set_text(text.format(*args))
else:
label.set_sensitive(False)
label.set_text('')
def _update_lang_from_entry(self, w: Gtk.Entry, string_type, lang_index):
if not self._is_loading:
sp = self.module.project.get_string_provider()
lang = sp.get_languages()[lang_index]
sp.get_model(lang).strings[
sp.get_index(string_type, self.dungeon_info.dungeon_id)
] = w.get_text().replace('\\n', '\n')
def on_entry_max_party_members_changed(self, w: Gtk.Entry, *args):
try:
value = int(w.get_text())
except ValueError:
return
self.restrictions.max_party_members = value
self._save_dungeon_restrictions()
def on_entry_max_items_allowed_changed(self, w: Gtk.Entry, *args):
try:
value = int(w.get_text())
except ValueError:
return
self.restrictions.max_items_allowed = value
self._save_dungeon_restrictions()
def on_entry_turn_limit_changed(self, w: Gtk.Entry, *args):
try:
value = int(w.get_text())
except ValueError:
return
self.restrictions.turn_limit = value
self._save_dungeon_restrictions()
def _validate(self, entry: Gtk.Entry):
text = entry.get_text()
context = entry.get_style_context()
error = self.find_errors_in_progress(text)
if error is not None:
self.valid = False
self.warn = True
self.set_warning_text(error)
self._show_warning()
context.add_class('error')
else:
self.valid = True
self.warn = False
self._hide_warning()
context.remove_class('error')
def _update_from_entry(self, w: Gtk.Entry):
attr_name = Gtk.Buildable.get_name(w)[6:]
try:
val = int(w.get_text())
except ValueError:
return
setattr(self.move, attr_name, val)
def on_entry_turn_limit_changed(self, w: Gtk.Entry, *args):
assert self.restrictions is not None
try:
value = i16_checked(int(w.get_text()))
except ValueError:
return
self.restrictions.turn_limit = value
self._save_dungeon_restrictions()
def on_entry_max_rescue_attempts_changed(self, w: Gtk.Entry, *args):
assert self.restrictions is not None
try:
value = i8_checked(int(w.get_text()))
except ValueError:
return
self.restrictions.max_rescue_attempts = value
self._save_dungeon_restrictions()
def on_command_entry_keyevent(self, entry: Gtk.Entry, event):
if event.hardware_keycode == 111:
# cursor up key
if self._commandhistory:
if self._historyindex is None:
self._historyindex = len(self._commandhistory)
self._historyindex = max(0, self._historyindex - 1)
entry.set_text(self._commandhistory[self._historyindex])
return True # inhibit further processing of this key event
elif event.hardware_keycode == 116:
# cursor down key
if self._commandhistory:
if self._historyindex is None:
self._historyindex = -1
self._historyindex = min(self._historyindex + 1, len(self._commandhistory) - 1)
entry.set_text(self._commandhistory[self._historyindex])
return True # inhibit further processing of this key event
return False
def on_port_name_changed(self, entry: Gtk.Entry):
"""Signal handler: Port name entry text changed."""
if self.updating_widgets > 0:
return
val = entry.get_text()
logging.debug('PreferencesDialog.on_port_name_changed(`%s`)', val)
cfg = self.get_current_port_config()
if cfg is not None:
cfg['name'] = val or None
self.schedule_refresh()
def get_completion_liststore(entry: Gtk.Entry) -> Gtk.ListStore:
"""
Create a completion model for entry widget completion list consists of
(Pixbuf, Text) rows
"""
completion = Gtk.EntryCompletion()
liststore = Gtk.ListStore(str, str)
render_pixbuf = Gtk.CellRendererPixbuf()
completion.pack_start(render_pixbuf, False)
completion.add_attribute(render_pixbuf, 'icon_name', 0)
render_text = Gtk.CellRendererText()
completion.pack_start(render_text, True)
completion.add_attribute(render_text, 'text', 1)
completion.set_property('text_column', 1)
completion.set_model(liststore)
entry.set_completion(completion)
return liststore
def __init__(self, *args, **kwargs):
Window.__init__(self, *args, **kwargs)
icon = lambda x: IconTheme.get_default().load_icon((name), x, 0)
icons = [icon(size) for size in [32, 48, 64, 96]]
self.set_icon_list(icons)
self.credentials.set_header_func(self.update_header)
self.languages.set_header_func(self.update_header)
for key in self.config.data['credentials']:
row = ListBoxRow()
grid = Grid()
grid.props.column_homogeneous = True
label = Label()
label.set_text(key)
label.props.halign = Align(1)
context = label.get_style_context()
resource = "/ml/prevete/Daty/gtk/value.css"
set_style(context, resource, "dim-label", True)
entry = Entry()
entry.set_text(self.config.data['credentials'][key])
context = entry.get_style_context()
set_style(context, resource, "flat", True)
grid.attach(label, 0, 0, 1, 1)
grid.attach(entry, 1, 0, 2, 1)
row.add(grid)
self.credentials.add(row)
self.credentials.show_all()
query = """SELECT ?item ?itemLabel ?c
{
?item wdt:P424 ?c .
MINUS{?item wdt:P31/wdt:P279* wd:Q14827288} #exclude Wikimedia projects
MINUS{?item wdt:P31/wdt:P279* wd:Q17442446} #exclude Wikimedia internal stuff
SERVICE wikibase:label { bd:serviceParam wikibase:language "your_first_language". }
}
"""
query = sub("your_first_language", self.config.data['languages'][0],
query)
self.retrieve(query, self.languages_callback)
def check_position(self, entry: Gtk.Entry):
pos = entry.get_text().strip()
if pos:
try:
val = int(float(pos))
assert val >= 0
except (AssertionError, ValueError):
entry.set_icon_from_icon_name(Gtk.EntryIconPosition.SECONDARY,
"error-app-symbolic")
entry.set_icon_tooltip_text(
Gtk.EntryIconPosition.SECONDARY,
"Value should be a positive integer",
)
else:
entry.set_icon_from_icon_name(Gtk.EntryIconPosition.SECONDARY,
None)
else:
entry.set_icon_from_icon_name(Gtk.EntryIconPosition.SECONDARY,
None)
def enter_pressed(self, entry: Gtk.Entry) -> None:
"""
When Enter pressed, verify the passphrase (if able),
close the window and return entered passphrase
"""
passphrase = entry.get_text()
if self.verify_passphrase_fn:
self.show_verifying_passphrase()
if self.verify_passphrase_fn(passphrase):
self.passphrase = passphrase
self.close_window()
else:
self.show_incorrect_passphrase()
else:
self.passphrase = passphrase
self.close_window()
def _link_gtk_entry_to_settings(settings, entry: Gtk.Entry, settings_id: str):
"""
Link a Gtk.Entry to a GSettings ID, so any change in one of
them will be reflected in the other one.
"""
name = entry.get_name()
logging.debug(f"[LINK] settings::{settings_id} <-> entry {name} [str]")
curr_value = settings.get_safe_string(settings_id)
if curr_value:
entry.set_text(curr_value)
settings.connect(
f"changed::{settings_id}",
lambda s, k: entry.set_text(settings.get_safe_string(settings_id)))
entry.connect(
"changed",
lambda e: settings.set_string(settings_id, str(entry.get_text())))
def add_usb_item(self, entry: Gtk.Entry, grid: Gtk.Grid, allitems: list, selecteditems: list):
"""Add usb config item."""
key = entry.get_text()
if key in allitems:
return
allitems.append(key)
toggle = Gtk.ToggleButton(key)
toggle.connect('toggled', on_button_toggled, key, selecteditems)
toggle.set_active(True)
label = Gtk.Label('')
label.set_halign(Gtk.Align.START)
global indexstore
grid.attach(toggle, 1, indexstore, 1, 1)
grid.attach(label, 2, indexstore, 1, 1)
indexstore += 1
grid.show_all()
def send_note_cb(dialog: Gtk.Dialog, response_id: int, device_address: str,
text_view: Gtk.Entry) -> None:
text = text_view.get_buffer().props.text
dialog.destroy()
if response_id == Gtk.ResponseType.CANCEL:
return
date = datetime.datetime.now().strftime('%Y%m%dT%H%M00')
data = ('BEGIN:VNOTE \n'
'VERSION:1.1 \n'
'BODY;CHARSET=UTF-8: %s \n'
'DCREATED:%s \n'
'LAST-MODIFIED:%s \n'
'CLASS:PUBLIC \n'
'X-IRMC-LUID:000001000000 \n'
'END:VNOTE \n' % (' '.join(text.splitlines()), date, date))
tempfile = NamedTemporaryFile(suffix='.vnt', prefix='note', delete=False)
tempfile.write(data.encode('utf-8'))
tempfile.close()
launch(f"blueman-sendto --delete --device={device_address}",
paths=[tempfile.name])
def _entry_changed_cb(self, entry: Gtk.Entry, param_name: str):
#pylint: disable=used-before-assignment
self._params[param_name] = tmp if (tmp := entry.get_text().strip(
)) != "" else entry.get_placeholder_text()
def _update_lang_from_entry(self, w: Gtk.Entry, lang_index):
lang = self._string_provider.get_languages()[lang_index]
self._string_provider.get_model(lang).strings[
self._string_provider.get_index(StringType.MOVE_NAMES,
self.move_id)] = w.get_text()
def _update_from_switch(self, w: Gtk.Entry):
attr_name = Gtk.Buildable.get_name(w)[7:]
setattr(self.move, attr_name, w.get_active())
def on_secondary_icon_pressed(entry: Gtk.Entry, pos: Gtk.EntryIconPosition,
event: Gdk.EventButton):
visible = entry.get_visibility()
entry.set_visibility(not visible)
