ericbsd
708aed30d6
Replace the swap size text entry with a SpinButton capped to the selected disk size, consolidate _disk_count_valid and _update_next_button into a single _is_ready method that checks all preconditions, update the Next button from on_password_changed so it disables when passwords stop matching, re-enable the Next button in back_page so navigating back no longer leaves it stuck disabled, reduce the left panel gap, and fix a startup crash from mirror_selection firing before swap_entry was created.
569 lines
22 KiB
Python
569 lines
22 KiB
Python
from gi.repository import Gtk, Gdk
|
|
from install_station.common import password_strength
|
|
from install_station.data import InstallationData, zfs_datasets, be_name, logo, get_text
|
|
from install_station.partition import bios_or_uefi
|
|
from install_station.system_calls import (
|
|
get_ram_size_mb,
|
|
zfs_disk_query,
|
|
zfs_disk_size_query,
|
|
)
|
|
from install_station.interface_controller import Button
|
|
|
|
|
|
cssProvider = Gtk.CssProvider()
|
|
cssProvider.load_from_path('/usr/local/lib/install-station/ghostbsd-style.css')
|
|
screen = Gdk.Screen.get_default()
|
|
styleContext = Gtk.StyleContext()
|
|
styleContext.add_provider_for_screen(
|
|
screen,
|
|
cssProvider,
|
|
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
|
|
)
|
|
|
|
|
|
class ZFS:
|
|
"""
|
|
Utility class for ZFS configuration and disk management following the utility class pattern.
|
|
|
|
This class provides a GTK+ interface for configuring ZFS installations including:
|
|
- Disk selection and validation
|
|
- Pool type configuration (stripe, mirror, RAIDZ1/2/3)
|
|
- Partition scheme selection (GPT/MBR)
|
|
- Disk encryption setup with password verification
|
|
- ZFS pool name configuration
|
|
|
|
The class follows a utility pattern with class methods and variables for state management,
|
|
designed to integrate with the InstallationData system for configuration persistence.
|
|
"""
|
|
# Class variables instead of instance variables
|
|
zfs_disk_list = []
|
|
pool_type = 'stripe'
|
|
scheme = 'GPT'
|
|
disk_encrypt = False
|
|
mirror = 'stripe'
|
|
vbox1 = None
|
|
|
|
# UI elements as class variables
|
|
pool = None
|
|
swap_entry = None
|
|
password = None
|
|
repassword = None
|
|
mirrorTips = None
|
|
strenght_label = None
|
|
img = None
|
|
check_cell = None
|
|
store = None
|
|
|
|
@classmethod
|
|
def save_selection(cls):
|
|
"""
|
|
Save the current ZFS configuration to InstallationData.
|
|
|
|
Validates required fields and generates ZFS configuration data including:
|
|
- Pool name and type (stripe, mirror, RAIDZ1/2/3)
|
|
- Disk partitioning scheme and encryption settings
|
|
- Boot environment and dataset configuration
|
|
|
|
Raises:
|
|
ValueError: If required fields are missing or invalid
|
|
"""
|
|
# Validate required fields are populated
|
|
if not cls.zfs_disk_list:
|
|
raise ValueError("No disks selected for ZFS configuration")
|
|
|
|
if cls.disk_encrypt and not cls.password.get_text().strip():
|
|
raise ValueError("Password cannot be empty when disk encryption is enabled")
|
|
|
|
size = int(cls.zfs_disk_list[0].partition('-')[2].rstrip()) - 512
|
|
swap_size = cls.swap_entry.get_value_as_int()
|
|
zfs_num = size - swap_size
|
|
dgeli = '.eli' if cls.disk_encrypt else ''
|
|
|
|
# Store configuration data in InstallationData instead of writing to file
|
|
InstallationData.zfs_config_data = []
|
|
|
|
InstallationData.zfs_config_data.append(f"zpoolName={cls.pool.get_text()}\n")
|
|
InstallationData.zfs_config_data.append(f"beName={be_name}\n")
|
|
InstallationData.zfs_config_data.append('ashift=12\n\n')
|
|
disk = cls.zfs_disk_list[0].partition('-')[0].rstrip()
|
|
InstallationData.zfs_config_data.append(f'disk0={disk}\n')
|
|
InstallationData.zfs_config_data.append('partition=ALL\n')
|
|
InstallationData.zfs_config_data.append(f'partscheme={cls.scheme}\n')
|
|
InstallationData.zfs_config_data.append('commitDiskPart\n\n')
|
|
if len(cls.zfs_disk_list) <= 1:
|
|
pool_disk = '\n'
|
|
else:
|
|
zfs_disk = cls.zfs_disk_list
|
|
mirror_dsk = ''
|
|
for i in range(1, len(zfs_disk)):
|
|
mirror_dsk += ' ' + zfs_disk[i].partition('-')[0].rstrip()
|
|
pool_disk = f' ({cls.pool_type}:{mirror_dsk})\n'
|
|
if bios_or_uefi() == "UEFI":
|
|
zfs_num = zfs_num - 100
|
|
else:
|
|
zfs_num = zfs_num - 1
|
|
# adding zero to use remaining space
|
|
zfs_part = f'disk0-part=ZFS{dgeli} {zfs_num} {zfs_datasets}{pool_disk}'
|
|
InstallationData.zfs_config_data.append(zfs_part)
|
|
# encpass must be on the line immediately after the .eli partition
|
|
if cls.disk_encrypt:
|
|
InstallationData.zfs_config_data.append(f'encpass={cls.password.get_text()}\n')
|
|
else:
|
|
InstallationData.zfs_config_data.append('#encpass=None\n')
|
|
if swap_size != 0:
|
|
if cls.disk_encrypt:
|
|
InstallationData.zfs_config_data.append('disk0-part=SWAP.eli 0 none\n')
|
|
else:
|
|
InstallationData.zfs_config_data.append('disk0-part=SWAP 0 none\n')
|
|
InstallationData.zfs_config_data.append('commitDiskLabel\n')
|
|
|
|
@classmethod
|
|
def _is_ready(cls):
|
|
"""
|
|
Check if all conditions are met to proceed to the next page.
|
|
|
|
Returns:
|
|
bool: True if disk count, swap entry, and encryption requirements are all satisfied.
|
|
"""
|
|
count = len(cls.zfs_disk_list)
|
|
if cls.mirror == "stripe":
|
|
disks_ok = count >= 1
|
|
elif cls.mirror == "mirror":
|
|
disks_ok = count >= 2
|
|
elif cls.mirror == "raidz1":
|
|
disks_ok = count == 3
|
|
elif cls.mirror == "raidz2":
|
|
disks_ok = count == 4
|
|
elif cls.mirror == "raidz3":
|
|
disks_ok = count == 5
|
|
else:
|
|
disks_ok = False
|
|
if cls.disk_encrypt:
|
|
encrypt_ok = (cls.password.get_text() == cls.repassword.get_text()
|
|
and len(cls.password.get_text()) > 0)
|
|
else:
|
|
encrypt_ok = True
|
|
return disks_ok and encrypt_ok
|
|
|
|
@classmethod
|
|
def scheme_selection(cls, combobox):
|
|
"""
|
|
Handle partition scheme selection from combo box.
|
|
|
|
Args:
|
|
combobox: ComboBox widget containing scheme options (GPT/MBR)
|
|
"""
|
|
model = combobox.get_model()
|
|
index = combobox.get_active()
|
|
data = model[index][0]
|
|
cls.scheme = data.partition(':')[0]
|
|
|
|
@classmethod
|
|
def mirror_selection(cls, combobox):
|
|
"""
|
|
Handle pool type selection and update UI accordingly.
|
|
|
|
Sets the pool type (stripe, mirror, RAIDZ1/2/3) and updates the tip text
|
|
and next button sensitivity based on the number of selected disks.
|
|
|
|
Args:
|
|
combobox: ComboBox widget containing pool type options
|
|
"""
|
|
model = combobox.get_model()
|
|
index = combobox.get_active()
|
|
data = model[index][0]
|
|
cls.mirror = data
|
|
smallest_msg = get_text("(select the smallest disk first)")
|
|
if cls.mirror == "stripe":
|
|
cls.pool_type = 'stripe'
|
|
cls.mirrorTips.set_text(
|
|
get_text("Select 1 or more drives, no redundancy") + " " + smallest_msg)
|
|
elif cls.mirror == "mirror":
|
|
cls.pool_type = 'mirror'
|
|
cls.mirrorTips.set_text(
|
|
get_text("Select 2 or more drives for mirroring") + " " + smallest_msg)
|
|
elif cls.mirror == "raidz1":
|
|
cls.pool_type = 'raidz1'
|
|
cls.mirrorTips.set_text(
|
|
get_text("Select 3 drives for RAIDZ1") + " " + smallest_msg)
|
|
elif cls.mirror == "raidz2":
|
|
cls.pool_type = 'raidz2'
|
|
cls.mirrorTips.set_text(
|
|
get_text("Select 4 drives for RAIDZ2") + " " + smallest_msg)
|
|
elif cls.mirror == "raidz3":
|
|
cls.pool_type = 'raidz3'
|
|
cls.mirrorTips.set_text(
|
|
get_text("Select 5 drives for RAIDZ3") + " " + smallest_msg)
|
|
Button.next_button.set_sensitive(cls._is_ready())
|
|
|
|
@classmethod
|
|
def on_check_encrypt(cls, widget):
|
|
"""
|
|
Handle disk encryption checkbox toggle.
|
|
|
|
Enables or disables password fields and updates next button sensitivity
|
|
based on encryption state and current disk selection.
|
|
|
|
Args:
|
|
widget: CheckButton widget for disk encryption enable/disable
|
|
"""
|
|
if widget.get_active():
|
|
cls.password.set_sensitive(True)
|
|
cls.repassword.set_sensitive(True)
|
|
cls.disk_encrypt = True
|
|
Button.next_button.set_sensitive(False)
|
|
else:
|
|
cls.password.set_sensitive(False)
|
|
cls.repassword.set_sensitive(False)
|
|
cls.disk_encrypt = False
|
|
Button.next_button.set_sensitive(cls._is_ready())
|
|
|
|
@classmethod
|
|
def on_password_changed(cls, _widget):
|
|
"""
|
|
Handle password entry changes and update strength display.
|
|
|
|
Wraps the common password_strength function to extract the text
|
|
from the Entry widget and pass it with the strength label.
|
|
|
|
Args:
|
|
_widget: Entry widget that triggered the change (unused)
|
|
"""
|
|
password_strength(cls.password.get_text(), cls.strenght_label)
|
|
Button.next_button.set_sensitive(cls._is_ready())
|
|
|
|
@classmethod
|
|
def initialize(cls):
|
|
"""
|
|
Initialize the ZFS configuration UI following the utility class pattern.
|
|
|
|
Creates the main interface including:
|
|
- Disk selection tree view with checkboxes
|
|
- Pool type selection (stripe, mirror, RAIDZ1/2/3)
|
|
- Pool name configuration
|
|
- Partition scheme selection (GPT/MBR)
|
|
- Disk encryption options with password fields
|
|
|
|
This method is called automatically by get_model() when the interface is first accessed.
|
|
"""
|
|
cls.vbox1 = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, homogeneous=False, spacing=0)
|
|
cls.vbox1.show()
|
|
|
|
# Disk list in a scrolled window
|
|
sw = Gtk.ScrolledWindow(hexpand=True, vexpand=True)
|
|
sw.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
|
|
sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
|
|
cls.store = Gtk.TreeStore(str, str, str, 'gboolean')
|
|
for disk in zfs_disk_query():
|
|
dsk = disk.partition(':')[0].rstrip()
|
|
dsk_name = disk.partition(':')[2].rstrip()
|
|
dsk_size = zfs_disk_size_query(dsk).rstrip()
|
|
cls.store.append(None, [dsk, dsk_size, dsk_name, False])
|
|
treeview = Gtk.TreeView()
|
|
treeview.set_model(cls.store)
|
|
treeview.set_rules_hint(True)
|
|
cls.check_cell = Gtk.CellRendererToggle()
|
|
cls.check_cell.set_property('activatable', True)
|
|
cls.check_cell.connect('toggled', cls.col1_toggled_cb, cls.store)
|
|
cell = Gtk.CellRendererText()
|
|
column = Gtk.TreeViewColumn(None, cell, text=0)
|
|
column_header = Gtk.Label(label=get_text('Disk'))
|
|
column_header.set_use_markup(True)
|
|
column_header.show()
|
|
column.set_widget(column_header)
|
|
column.set_sort_column_id(0)
|
|
cell2 = Gtk.CellRendererText()
|
|
column2 = Gtk.TreeViewColumn(None, cell2, text=0)
|
|
column_header2 = Gtk.Label(label=get_text('Size(MB)'))
|
|
column_header2.set_use_markup(True)
|
|
column_header2.show()
|
|
column2.set_widget(column_header2)
|
|
cell3 = Gtk.CellRendererText()
|
|
column3 = Gtk.TreeViewColumn(None, cell3, text=0)
|
|
column_header3 = Gtk.Label(label=get_text('Name'))
|
|
column_header3.set_use_markup(True)
|
|
column_header3.show()
|
|
column3.set_widget(column_header3)
|
|
column1 = Gtk.TreeViewColumn(get_text("Check"), cls.check_cell)
|
|
column1.add_attribute(cls.check_cell, "active", 3)
|
|
column.set_attributes(cell, text=0)
|
|
column2.set_attributes(cell2, text=1)
|
|
column3.set_attributes(cell3, text=2)
|
|
treeview.append_column(column1)
|
|
treeview.append_column(column)
|
|
treeview.append_column(column2)
|
|
treeview.append_column(column3)
|
|
tree_selection = treeview.get_selection()
|
|
tree_selection.set_mode(Gtk.SelectionMode.SINGLE)
|
|
sw.add(treeview)
|
|
sw.show()
|
|
|
|
cls.mirrorTips = Gtk.Label(label=get_text('Please select one drive'))
|
|
cls.mirrorTips.set_justify(Gtk.Justification.LEFT)
|
|
cls.mirrorTips.set_alignment(0.01, 0.5)
|
|
|
|
# Pool Layout
|
|
cls.mirror = 'stripe'
|
|
mirror_label = Gtk.Label(label=get_text('Pool Layout'))
|
|
mirror_label.set_use_markup(True)
|
|
mirror_box = Gtk.ComboBoxText()
|
|
mirror_box.append_text("stripe")
|
|
mirror_box.append_text("mirror")
|
|
mirror_box.append_text("raidz1")
|
|
mirror_box.append_text("raidz2")
|
|
mirror_box.append_text("raidz3")
|
|
mirror_box.set_active(0)
|
|
mirror_box.connect('changed', cls.mirror_selection)
|
|
|
|
# Pool Name (always editable)
|
|
pool_label = Gtk.Label(label=get_text('Pool Name'))
|
|
pool_label.set_use_markup(True)
|
|
cls.pool = Gtk.Entry()
|
|
cls.pool.set_text('zroot')
|
|
|
|
# Swap Size
|
|
swap_label = Gtk.Label(label=get_text('Swap Size(MB)'))
|
|
swap_label.set_use_markup(True)
|
|
ram_mb = get_ram_size_mb()
|
|
adj = Gtk.Adjustment(ram_mb, 0, ram_mb, 1, 100, 0)
|
|
cls.swap_entry = Gtk.SpinButton(adjustment=adj, numeric=True)
|
|
cls.swap_entry.set_editable(True)
|
|
|
|
# Creating MBR or GPT drive
|
|
cls.scheme = 'GPT'
|
|
shemebox = Gtk.ComboBoxText()
|
|
shemebox.append_text("GPT")
|
|
shemebox.append_text("MBR")
|
|
shemebox.connect('changed', cls.scheme_selection)
|
|
shemebox.set_active(0)
|
|
if bios_or_uefi() == "UEFI":
|
|
shemebox.set_sensitive(False)
|
|
else:
|
|
shemebox.set_sensitive(True)
|
|
|
|
# GELI Disk encryption
|
|
cls.disk_encrypt = False
|
|
encrypt_check = Gtk.CheckButton(label=get_text("Encrypt Disk (GELI)"))
|
|
encrypt_check.connect("toggled", cls.on_check_encrypt)
|
|
encrypt_check.set_sensitive(True)
|
|
|
|
# Password
|
|
cls.passwd_label = Gtk.Label(label=get_text("Password"))
|
|
cls.password = Gtk.Entry()
|
|
cls.password.set_sensitive(False)
|
|
cls.password.set_visibility(False)
|
|
cls.password.connect("changed", cls.on_password_changed)
|
|
cls.strenght_label = Gtk.Label()
|
|
cls.strenght_label.set_alignment(0.1, 0.5)
|
|
cls.strenght_label.set_size_request(-1, 20)
|
|
|
|
# Verify password
|
|
cls.vpasswd_label = Gtk.Label(label=get_text("Confirm"))
|
|
cls.repassword = Gtk.Entry()
|
|
cls.repassword.set_sensitive(False)
|
|
cls.repassword.set_visibility(False)
|
|
cls.repassword.connect("changed", cls.password_verification)
|
|
|
|
# Password match image
|
|
cls.img = Gtk.Image()
|
|
cls.img.set_size_request(20, 20)
|
|
|
|
# Two-column layout: left settings, right disk list
|
|
hbox_main = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, homogeneous=False, spacing=10)
|
|
|
|
# Left panel: settings grid
|
|
left_grid = Gtk.Grid()
|
|
left_grid.set_row_spacing(4)
|
|
left_grid.set_column_spacing(6)
|
|
left_grid.set_hexpand(False)
|
|
|
|
mirror_label.set_alignment(0, 0.5)
|
|
pool_label.set_alignment(0, 0.5)
|
|
swap_label.set_alignment(0, 0.5)
|
|
cls.passwd_label.set_alignment(0, 0.5)
|
|
cls.vpasswd_label.set_alignment(0, 0.5)
|
|
|
|
# Row 0-1: Pool Layout
|
|
left_grid.attach(mirror_label, 0, 0, 2, 1)
|
|
left_grid.attach(mirror_box, 0, 1, 2, 1)
|
|
# Row 2-3: Pool Name
|
|
left_grid.attach(pool_label, 0, 2, 2, 1)
|
|
left_grid.attach(cls.pool, 0, 3, 2, 1)
|
|
# Row 4-5: Swap Size
|
|
left_grid.attach(swap_label, 0, 4, 2, 1)
|
|
left_grid.attach(cls.swap_entry, 0, 5, 2, 1)
|
|
# Row 6: Separator
|
|
sep = Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL)
|
|
left_grid.attach(sep, 0, 6, 2, 1)
|
|
# Row 7: Encrypt Disk checkbox
|
|
left_grid.attach(encrypt_check, 0, 7, 2, 1)
|
|
# Row 8: Password label + strength indicator
|
|
left_grid.attach(cls.passwd_label, 0, 8, 1, 1)
|
|
left_grid.attach(cls.strenght_label, 1, 8, 1, 1)
|
|
# Row 9: Password input
|
|
left_grid.attach(cls.password, 0, 9, 2, 1)
|
|
# Row 10: Confirm label + match icon
|
|
left_grid.attach(cls.vpasswd_label, 0, 10, 1, 1)
|
|
left_grid.attach(cls.img, 1, 10, 1, 1)
|
|
# Row 11: Confirm input
|
|
left_grid.attach(cls.repassword, 0, 11, 2, 1)
|
|
|
|
hbox_main.pack_start(left_grid, False, False, 10)
|
|
|
|
# Right panel: tips + disk list
|
|
right_panel = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, homogeneous=False, spacing=0)
|
|
cls.mirrorTips.set_alignment(0, 0.5)
|
|
right_panel.pack_start(cls.mirrorTips, False, False, 0)
|
|
right_panel.pack_start(sw, True, True, 0)
|
|
|
|
hbox_main.pack_start(right_panel, True, True, 10)
|
|
|
|
cls.vbox1.pack_start(hbox_main, True, True, 10)
|
|
return
|
|
|
|
@classmethod
|
|
def get_model(cls):
|
|
"""
|
|
Return the GTK widget model for the ZFS configuration interface.
|
|
|
|
Creates and initializes the UI if it doesn't exist yet.
|
|
|
|
Returns:
|
|
Gtk.Box: The main container widget for the ZFS configuration interface
|
|
"""
|
|
if cls.vbox1 is None:
|
|
cls.initialize()
|
|
return cls.vbox1
|
|
|
|
@classmethod
|
|
def check_if_small_disk(cls, size):
|
|
"""
|
|
Check if any selected disk is larger than the specified size.
|
|
|
|
Used to enforce the requirement that the smallest disk must be selected first
|
|
for ZFS pool configurations.
|
|
|
|
Args:
|
|
size: Size in MB to compare against selected disks
|
|
|
|
Returns:
|
|
bool: True if any selected disk is larger than the specified size
|
|
"""
|
|
if len(cls.zfs_disk_list) != 0:
|
|
for line in cls.zfs_disk_list:
|
|
if int(line.partition('-')[2]) > int(size):
|
|
return True
|
|
else:
|
|
return False
|
|
else:
|
|
return False
|
|
|
|
@classmethod
|
|
def col1_toggled_cb(cls, _cell, path, model):
|
|
"""
|
|
Handle disk selection checkbox toggle events.
|
|
|
|
Manages the disk selection list and updates next button sensitivity
|
|
based on pool type requirements. Enforces the rule that the smallest
|
|
disk must be selected first.
|
|
|
|
Args:
|
|
_cell: CellRendererToggle that was clicked (unused)
|
|
path: TreePath of the toggled row
|
|
model: TreeStore model containing disk data
|
|
|
|
Returns:
|
|
bool: Always returns True to indicate the event was handled
|
|
"""
|
|
model[path][3] = not model[path][3]
|
|
if model[path][3] is False:
|
|
cls.zfs_disk_list.remove(model[path][0] + "-" + model[path][1])
|
|
else:
|
|
if cls.check_if_small_disk(model[path][1]) is False:
|
|
cls.zfs_disk_list.extend([model[path][0] + "-" + model[path][1]])
|
|
else:
|
|
cls.check_cell.set_sensitive(False)
|
|
cls.small_disk_warning()
|
|
return True
|
|
|
|
# Update swap SpinButton upper limit based on first selected disk
|
|
if cls.zfs_disk_list:
|
|
disk_size = int(cls.zfs_disk_list[0].partition('-')[2].rstrip()) - 512
|
|
cls.swap_entry.get_adjustment().set_upper(disk_size)
|
|
else:
|
|
cls.swap_entry.get_adjustment().set_upper(get_ram_size_mb())
|
|
Button.next_button.set_sensitive(cls._is_ready())
|
|
|
|
print(cls.zfs_disk_list)
|
|
return True
|
|
|
|
@classmethod
|
|
def small_disk_warning(cls):
|
|
"""
|
|
Display a warning dialog when disks are selected out of size order.
|
|
|
|
Shows a dialog informing the user that the smallest disk must be
|
|
selected first and offers to reset all selections.
|
|
"""
|
|
window = Gtk.Window()
|
|
window.set_title(get_text("Warning"))
|
|
window.set_border_width(0)
|
|
# window.set_size_request(480, 200)
|
|
window.set_icon_from_file(logo)
|
|
box1 = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, homogeneous=False, spacing=0)
|
|
window.add(box1)
|
|
box1.show()
|
|
box2 = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, homogeneous=False, spacing=10)
|
|
box2.set_border_width(10)
|
|
box1.pack_start(box2, True, True, 0)
|
|
box2.show()
|
|
warning_text = get_text("Smallest disk need to be SELECTED first!\n")
|
|
warning_text += get_text("All the disk selected will reset.")
|
|
label = Gtk.Label(label=warning_text)
|
|
# Add button
|
|
box2.pack_start(label, True, True, 0)
|
|
bbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, homogeneous=False, spacing=10)
|
|
bbox.set_border_width(5)
|
|
button = Gtk.Button(stock=Gtk.STOCK_OK)
|
|
button.connect("clicked", cls.resset_selection, window)
|
|
bbox.add(button)
|
|
box2.pack_end(bbox, True, True, 5)
|
|
window.show_all()
|
|
|
|
@classmethod
|
|
def resset_selection(cls, _widget, window):
|
|
"""
|
|
Reset all disk selections and close the warning dialog.
|
|
|
|
Clears the disk selection list and unchecks all checkboxes in the tree view.
|
|
|
|
Args:
|
|
_widget: Button widget that triggered the reset (unused)
|
|
window: Warning dialog window to close
|
|
"""
|
|
cls.zfs_disk_list = []
|
|
rows = len(cls.store)
|
|
for row in range(0, rows):
|
|
cls.store[row][3] = False
|
|
row += 1
|
|
cls.check_cell.set_sensitive(True)
|
|
window.hide()
|
|
|
|
@classmethod
|
|
def password_verification(cls, _widget):
|
|
"""
|
|
Verify that password and confirmation password fields match.
|
|
|
|
Updates the verification image and next button sensitivity based on
|
|
password match status and current disk selection requirements.
|
|
|
|
Args:
|
|
_widget: Entry widget that triggered the verification (unused)
|
|
"""
|
|
if cls.password.get_text() == cls.repassword.get_text():
|
|
cls.img.set_from_icon_name("gtk-yes", Gtk.IconSize.MENU)
|
|
Button.next_button.set_sensitive(cls._is_ready())
|
|
else:
|
|
cls.img.set_from_icon_name("gtk-no", Gtk.IconSize.MENU)
|
|
Button.next_button.set_sensitive(False)
|