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 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 _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 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_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 _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_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 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_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 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_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 on_entry_changed(self, entry: Gtk.Entry) -> None:
"""React to an entry being changed.
Removes the 'error' CSS class from the entry.
Args:
entry (Gtk.Entry): The changed entry
"""
if entry is self.password_entry:
entry.get_style_context().remove_class("error")
if entry.get_text() == self.password_confirm_entry.get_text():
self.password_confirm_entry.get_style_context().remove_class(
"error")
if entry.get_text() == "":
entry.set_progress_fraction(0)
else:
strength, improvements = passwordmeter.test(entry.get_text())
entry.set_progress_fraction(strength)
if strength > 2 / 3.0:
entry.get_style_context().remove_class("bad")
entry.get_style_context().remove_class("medium")
entry.get_style_context().add_class("good")
elif strength > 1 / 3.0:
entry.get_style_context().remove_class("bad")
entry.get_style_context().add_class("medium")
entry.get_style_context().remove_class("good")
else:
entry.get_style_context().add_class("bad")
entry.get_style_context().remove_class("medium")
entry.get_style_context().remove_class("good")
elif entry is self.password_confirm_entry:
if entry.get_text() == self.password_entry.get_text():
entry.get_style_context().remove_class("error")
else:
entry.get_style_context().add_class("error")
elif entry is self.username_entry:
entry.get_style_context().remove_class("error")
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 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 _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 _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 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 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 _update_lang_short_desc_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.ITEM_SHORT_DESCRIPTIONS,
self.item_id)] = w.get_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 _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 on_enter(entry: Gtk.Entry):
val = int(entry.get_text())
entry.set_text(str(val))
self.emit('completed', val)
def on_partner_start_level_changed(self, w: Gtk.Entry):
try:
val = int(w.get_text())
except ValueError:
return
self.module.set_starter_level_partner(val)
def on_default_team_name_changed(self, w: Gtk.Entry):
for lang in self.string_provider.get_languages():
self.string_provider.get_model(lang).strings[
self.string_provider.get_index(StringType.DEFAULT_TEAM_NAMES,
2)] = w.get_text()
self.module.mark_str_as_modified()
def on_var_changed_entry(self, var: Pmd2ScriptGameVar, offset: int,
wdg: Gtk.Entry, *args):
if self._suppress_events:
return
with variables_lock:
self.variables_changed_but_not_saved = True
try:
try:
value = int(wdg.get_text())
except ValueError as err:
raise ValueError(
"The variable must have a number as value.") from err
if var.type == GameVariableType.BIT:
if value < 0 or value > 1:
raise ValueError(
"This variable must have one of these values: 0, 1."
)
elif var.type == GameVariableType.UINT8:
if value < 0 or value > 255:
raise ValueError(
"This variable must have a value between: 0 and 255."
)
elif var.type == GameVariableType.INT8:
if value < -128 or value > 127:
raise ValueError(
"This variable must have a value between: -128 and 127."
)
elif var.type == GameVariableType.UINT16:
if value < 0 or value > 65535:
raise ValueError(
"This variable must have a value between: 0 and 65535."
)
elif var.type == GameVariableType.INT16:
if value < -32768 or value > 32767:
raise ValueError(
"This variable must have a value between: -32768 and 32767."
)
elif var.type == GameVariableType.UINT32:
if value < 0 or value > 4294967295:
raise ValueError(
"This variable must have a value between: 0 and 4294967295."
)
elif var.type == GameVariableType.INT32:
if value < -2147483648 or value > 2147483647:
raise ValueError(
"This variable must have a value between: -2147483648 and 2147483647."
)
except ValueError as err:
md = Gtk.MessageDialog(
self.builder.get_object('main_window'),
Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.ERROR,
Gtk.ButtonsType.OK,
f"Invalid variable value:\n{err}\nThe value was not written to RAM.",
title="Error!")
md.set_position(Gtk.WindowPosition.CENTER)
md.run()
md.destroy()
return True
self._queue_variable_write(var.id, offset, value)
return True
def _update_lang_cat_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.POKEMON_CATEGORIES, self.entry.md_index_base)
] = w.get_text()
def _on_create_task(self, new_task_entry: Gtk.Entry):
description = new_task_entry.get_text()
if description != "":
self.emit("new_task_created", description)
def on_name_changed(entry: Gtk.Entry) -> None:
adapter['Alias'] = entry.get_text()
