def on_enter(self): """ Put parsed damper info into the EditDamperScreen fields. """ damper = Damper() try: self.d_types = damper.get_types() except sqlite3.DatabaseError: toast("GetTypesError") else: # Read DB and output data into dampers_container. if not self.d_types: toast(MDApp.get_running_app().tr._("No Types in the DB")) else: menu_items = [{"text": d_type} for d_type in self.d_types] self.menu = MDDropdownMenu(caller=self.ids["dditm_type"], items=menu_items, position="center", width_mult=4, callback=self.set_item) self.tf_number.text = self.old_number # To show correct current_item in the MDDropDownItem (dditm_type). self.dditm_type.current_item = self.old_d_type self.dditm_type.ids["label_item"].text = self.old_d_type self.lbl_choose_date.text = "[u]{}[/u]".format( self.old_check_date) self.tf_location.text = self.old_location self.chbx_isreleased.active = self.old_is_released self.tf_notes.text = self.old_notes
def on_enter(self): """Read DB and output data into types_container.""" # Creating DeleteEditTypeToolbar dots menus. self.menu_dots = MDDropdownMenu( caller=self.ids["tb_deleteedittype"].ids["ibtn_dots"], items=self.menu_items_dots, callback=self.callback_menu_dots, # position="bottom", hor_growth="left", ver_growth="down", width_mult=7) damper = Damper() try: self.d_types = damper.get_types() except sqlite3.DatabaseError: toast("GetTypesError") else: # Read DB and output data into dampers_container. if not self.d_types: toast(MDApp.get_running_app().tr._("No Types in the DB")) else: for d_type in self.d_types: a_type_list_item = TypeListItem(text=d_type) self.ids["types_container"].add_widget(a_type_list_item) # Add all adding TypeListItem to the list for # getting access to right_checkbox_types in the future. self.all_types_in_container.append(a_type_list_item)
def clear_db(self, text_of_selection, *args): """Delete ALL date from the DB.""" if text_of_selection == self.tr._("Clear"): damper = Damper() try: damper.clear_db() except sqlite3.DatabaseError: toast("ClearDBError") else: toast(self.tr._("Cleared")) # Delay for showing toast("Cleared") Clock.schedule_once(self.get_dampers, 1)
def get_dampers(self, order="no order", *args): """ Get all dampers from the DB and store them into self.dampers. :param order: str for sorting can be: "by number", "by location", "by check date", by is released", "no order" """ self.damper = Damper() try: self.dampers = self.damper.get_dampers(order) except sqlite3.DatabaseError: toast(self.tr._("Can't get dampers from the DB")) else: # Not to show_dampers in the first start # because it'll be done in change_screen. if not self.is_first_started: self.show_dampers()
def on_enter(self): """Get damper types and put them into self.d_types.""" damper = Damper() try: self.d_types = damper.get_types() except sqlite3.DatabaseError: toast("GetTypesError") else: # Read DB and output data into dampers_container. if not self.d_types: toast(MDApp.get_running_app().tr._("No Types in the DB")) else: menu_items = [{"text": d_type} for d_type in self.d_types] self.menu = MDDropdownMenu(caller=self.ids["dditm_type"], items=menu_items, position="center", width_mult=4, callback=self.set_item) self.ids["dditm_type"].text = self.d_types[0]
def delete_selected_types(self, text_of_selection, *args): """ Delete selected d_types from DB and types_container. """ if text_of_selection == MDApp.get_running_app().tr._("Delete"): # if self.selected_types: for d_type in self.selected_types: damper = Damper() try: damper.delete_type(d_type.text) except sqlite3.DatabaseError: toast("DeleteTypeError") else: self.types_container.remove_widget(d_type) self.d_types.remove(d_type.text) toast(MDApp.get_running_app().tr._("Deleted")) # After all deleting clear self.selected_types. self.selected_types.clear()
def delete_selected_dampers(self, text_of_selection, *args): """ Delete selected items from DB and _item_container. """ if text_of_selection == self.tr._("Delete"): # if self.selected_dampers: for selected_damper in self.selected_dampers: # Get the damper the_number. damper_number = selected_damper.text.split()[0] damper = Damper() try: damper.delete_damper(damper_number) except sqlite3.DatabaseError: toast("DeleteDamperError") else: self.dampers_container.remove_widget(selected_damper) toast(self.tr._("Deleted")) self.get_dampers()
def add_type(self, d_type): """Add d_type into DB.""" if not d_type: # if empty string. toast(MDApp.get_running_app().tr._("Fill the field")) else: damper = Damper() try: is_exists = damper.is_the_d_type_exists(d_type) except sqlite3.DatabaseError: toast("IsTypeExistsError") else: if is_exists: toast(MDApp.get_running_app().tr._( "{} already exists").format(d_type)) else: try: damper.add_type(d_type) except sqlite3.DatabaseError: toast("AddTypeError") else: toast(MDApp.get_running_app().tr._( "Added new type: {}").format(d_type))
def edit_type(self, new_type): if self.old_type == new_type: toast(MDApp.get_running_app().tr._("Nothing to change")) elif not new_type: # if empty string. toast(MDApp.get_running_app().tr._("Fill the field")) else: damper = Damper() try: is_exists = damper.is_the_d_type_exists(new_type) except sqlite3.DatabaseError: toast("IsTypeExistsError") else: if is_exists: toast(MDApp.get_running_app().tr._( "{} already exists").format(new_type)) else: try: damper.edit_type(self.old_type, new_type) except sqlite3.DatabaseError: toast("EditTypeError") else: toast(MDApp.get_running_app().tr._("Edited"))
def edit_damper(self, new_number, new_d_type, new_check_date, new_location, new_is_released=False, new_notes=""): """Edit the damper.""" # Delete [u][/u] from the check_date. check_date_regex = re.compile(r"[0-9]{4}-[0-9]{2}-[0-9]{1,2}") mo = check_date_regex.search(new_check_date) if mo is not None: new_check_date = mo.group() self.is_the_number_exists = False self.is_the_location_exists = False if not self.d_types: # TODO: delete if doesn't need. toast(MDApp.get_running_app().tr._( "First add damper types into the DB")) else: if not new_number or not new_location: toast(MDApp.get_running_app().tr._("Fill all needed fields")) else: damper = Damper() if new_number != self.old_number: # if equal (the same damper) can be updated! try: self.is_the_number_exists = damper.is_the_number_exists( new_number) except sqlite3.DatabaseError: toast("IsNumberExistsError") else: if self.is_the_number_exists: toast(MDApp.get_running_app().tr._( "{} already exists").format(new_number)) # To avoid itersetion of toasts already exists for number and location # added (and not self.is_the_number_exists). if new_location != self.old_location and not self.is_the_number_exists: # if equal (the same damper) can be updated! try: self.is_the_location_exists = damper.is_the_location_exists( new_location) except sqlite3.DatabaseError: toast("IsLocationExistsError") else: if self.is_the_location_exists: toast(MDApp.get_running_app().tr._( "{} already exists").format(new_location)) if not self.is_the_number_exists and not self.is_the_location_exists: try: damper.edit_damper(self.old_number, new_number, new_d_type, new_check_date, new_location, new_is_released, new_notes) except sqlite3.DatabaseError: toast("EditDamperError") else: toast(MDApp.get_running_app().tr._("Edited"))
def add_damper(self, number, d_type, check_date, location, is_released=False, notes=""): """Add new damper into the MDList and DB.""" # Delete [u][/u] from the check_date. check_date_regex = re.compile(r"[0-9]{4}-[0-9]{2}-[0-9]{1,2}") mo = check_date_regex.search(check_date) if mo is not None: check_date = mo.group() if not self.d_types: toast(MDApp.get_running_app().tr._( "First add damper types into the DB")) else: if not number or not location: toast(MDApp.get_running_app().tr._("Fill all needed fields")) else: damper = Damper() try: is_exists = damper.is_the_number_exists(number) except sqlite3.DatabaseError: toast("IsNumberExistsError") else: if is_exists: toast(MDApp.get_running_app().tr._( "{} already exists").format(number)) else: try: is_exists = damper.is_the_location_exists(location) except sqlite3.DatabaseError: toast("IsLocationExistsError") else: if is_exists: toast(MDApp.get_running_app().tr._( "{} already exists").format(location)) else: try: damper.add_damper(number, d_type, check_date, location, is_released, notes) except sqlite3.DatabaseError: toast("AddDamperError") else: toast(MDApp.get_running_app().tr._( "Added new damper: {}").format(number))
class MainApp(MDApp): # Language: get system locale. lang = StringProperty(locale.getdefaultlocale()[0][:2]) # For showing/hiding search widget. is_search_focused = BooleanProperty(False) is_first_started = BooleanProperty(True) app_primary_palette = StringProperty("Teal") def __init__(self, **kwargs): super().__init__(**kwargs) self.selected_dampers = [ ] # Every damper selected by MyRightCheckbox add to this list. self.all_dampers_in_container = [ ] # Consists of all adding DamperListItem. self.damper = None self.dampers = [ ] # Has all getting dampers (class Damper) from the DB. self.found_dampers = [] # Has all found in searching dampers. self.menu_sort = None self.menu_dots = None # For exit on double tap on the buttnon back. self.is_back_clicked_once = False # My config. self.config = ConfigParser() # App theme. self.primary_palette = "Teal" self.accent_palette = "Amber" self.theme_style = "Light" # To avoid multi chosen right_checkbox_lang. self.lang_checkboxes_dict = dict() # Handling the back button. Window.bind(on_keyboard=self.key_input) # The current target TextInput widget requesting the keyboard # is presented just above the soft keyboard. Window.softinput_mode = "below_target" def build_config(self, config): """Default config.""" self.config.setdefaults( "currenttheme", { "primary_palette": "Teal", "accent_palette": "Amber", "theme_style": "Light" }) self.config.setdefaults("applanguage", {"language": self.lang}) def save_config(self): """Save the App config.""" self.config.set("currenttheme", "primary_palette", self.primary_palette) self.config.set("currenttheme", "accent_palette", self.accent_palette) self.config.set("currenttheme", "theme_style", self.theme_style) self.config.set("applanguage", "language", self.lang) self.config.write() def my_load_config(self): """Load the App config.""" self.primary_palette = self.config.get("currenttheme", "primary_palette") self.accent_palette = self.config.get("currenttheme", "accent_palette") self.theme_style = self.config.get("currenttheme", "theme_style") self.lang = self.config.get("applanguage", "language") def apply_mytoolbar_theme(self): """Apply loaded theme for MyToolbar.""" self.theme_cls.primary_palette = self.primary_palette self.theme_cls.accent_palette = self.accent_palette self.theme_cls.theme_style = self.theme_style def build(self): # Loading and applying the App config. # Impossible to execute self.my_load_config() in __init__ # because of configparser.NoSectionError: No section: 'currenttheme'. self.my_load_config() # Instantiate an instance of Lang. self.tr = Lang(self.lang) self.title = self.tr._("Dampers") self.menu_items_dots = [{ "text": self.tr._("Select all"), "icon": "select-all" }, { "text": self.tr._("Cancel all selection"), "icon": "select-off" }, { "text": self.tr._("Add type"), "icon": "plus" }, { "text": self.tr._("Delete/Edit type"), "icon": "delete-outline" }, { "text": self.tr._("Add damper"), "icon": "plus" }, { "text": self.tr._("Edit selected damper"), "icon": "square-edit-outline" }, { "text": self.tr._("Delete selected dampers"), "icon": "delete-outline" }, { "text": self.tr._("Backup Database"), "icon": "content-save-outline" }, { "text": self.tr._("Restore Database"), "icon": "backup-restore" }, { "text": self.tr._("Clear DB"), "icon": "delete-forever-outline" }, { "text": self.tr._("Language"), "icon": "web" }, { "text": self.tr._("Change theme"), "icon": "theme-light-dark" }, { "text": self.tr._("Exit"), "icon": "exit-to-app" }] # Dict to process callback_menu_dots like switch in C++. self.dict_menu_dots_funcs = { self.tr._("Select all"): self.select_all, self.tr._("Cancel all selection"): self.cancel_all_selection, self.tr._("Add type"): partial(self.change_screen, "add_type_screen"), self.tr._("Delete/Edit type"): partial(self.change_screen, "delete_edit_type_screen"), self.tr._("Add damper"): partial(self.change_screen, "add_damper_screen"), self.tr._("Edit selected damper"): self.edit_selected_damper, self.tr._("Delete selected dampers"): self.show_delete_dampers_dialog, self.tr._("Backup Database"): self.choose, self.tr._("Restore Database"): partial(self.choose, False), self.tr._("Clear DB"): self.show_clear_db_dialog, self.tr._("Language"): partial(self.change_screen, "language_screen"), self.tr._("Change theme"): self.show_themepicker, self.tr._("Exit"): self.stop } self.menu_items_sort = [{ "text": self.tr._("By 'number'"), "icon": "sort-numeric" }, { "text": self.tr._("By 'location'"), "icon": "format-columns" }, { "text": self.tr._("By 'check date'"), "icon": "calendar-month" }, { "text": self.tr._("By 'is released'"), "icon": "check-outline" }, { "text": self.tr._("By 'no order'"), "icon": "not-equal-variant" } # "icon": "sort-variant-remove"} ] # Dict to process callback_menu_sort like switch in C++.. self.dict_menu_sort_funcs = { self.tr._("By 'number'"): partial(self.get_dampers, "by number"), self.tr._("By 'location'"): partial(self.get_dampers, "by location"), self.tr._("By 'check date'"): partial(self.get_dampers, "by check date"), self.tr._("By 'is released'"): partial(self.get_dampers, "by is released"), self.tr._("By 'no order'"): self.get_dampers } # Handling the back button. # Window.bind(on_keyboard=self.key_input) # The current target TextInput widget requesting the keyboard # is presented just above the soft keyboard. # Window.softinput_mode = "below_target" return Container() def on_start(self): if platform == "android": # Runtime permissions. from android.permissions import request_permissions, Permission request_permissions([ Permission.WRITE_EXTERNAL_STORAGE, Permission.READ_EXTERNAL_STORAGE ]) self.apply_mytoolbar_theme() self.screen_manager = self.root.ids["screen_manager"] self.home_screen = self.root.ids["home_screen"] self.dampers_container = self.home_screen.ids["dampers_container"] self.tf_search = self.home_screen.ids["tf_search"] self.container = self.home_screen.ids["container"] self.lang_screen = self.root.ids["language_screen"] # For passing old_damper info into the EditDamperScreen. self.edit_damper_screen = self.root.ids["edit_damper_screen"] # Creating MyToolbar dots and sort menus. self.menu_dots = MDDropdownMenu( caller=self.home_screen.ids["tb_home"].ids["ibtn_dots"], items=self.menu_items_dots, callback=self.callback_menu_dots, position="bottom", hor_growth="right", # ver_growth="down", width_mult=10) self.menu_sort = MDDropdownMenu( caller=self.home_screen.ids["tb_home"].ids["ibtn_sort"], items=self.menu_items_sort, callback=self.callback_menu_sort, position="bottom", hor_growth="right", # ver_growth="up", width_mult=7) self.change_toolbar_theme() self.add_lang_checkboxes_into_dict() self.lang_checkboxes_dict[self.lang].active = True self.get_dampers() self.is_first_started = False def add_lang_checkboxes_into_dict(self): """ Store all right_checkbox_(lang) into the lang_checkboxes_dict to control which right_checkbox is chosen. """ self.lang_checkboxes_dict["en"] = self.lang_screen.ids[ "right_checkbox_en"] self.lang_checkboxes_dict["ru"] = self.lang_screen.ids[ "right_checkbox_ru"] def on_stop(self): """Save config.""" self.save_config() def on_pause(self): return True def on_resume(self): pass def on_lang(self, instance, lang): """User changed language.""" # Skip the first tr.switch_lang # because self.tr is not defined yet. # The first switch will be in the build method: self.tr = Lang(self.lang) # after self.my_load_config(). if not self.is_first_started: self.tr.switch_lang(lang) dialog = MDDialog(title=self.tr._("Change language"), size_hint=(.7, .4), text_button_ok=self.tr._("Ok"), auto_dismiss=False, events_callback=self.stop, text=self.tr._( "You have to restart the app" "\nto change the language completely.")) dialog.open() def key_input(self, window, key, scancode, codepoint, modifier): def reset_btn_back_clicked(*args): """ Set is_back_clicked_once to False. There was no double click on the button back for exit. """ self.is_back_clicked_once = False if key == 27: # (the back button key is 27, codepoint is 270). if self.screen_manager.current != "home_screen": self.change_screen("home_screen") elif self.is_back_clicked_once: self.stop() else: self.is_back_clicked_once = True toast(self.tr._("Tap BACK again to exit"), duration=1) Clock.schedule_once(reset_btn_back_clicked, 3) return True return False def callback_menu_sort(self, instance): """ Check what item in the menu_sort pressed and do the action according pressed menu item. Actions are in the self.dict_menu_sort. """ self.dict_menu_sort_funcs.get(instance.text)() def callback_menu_dots(self, instance): """ Check what item in the menu_dots pressed and do the action according pressed menu item. Actions are in the self.dict_menu_dots. """ self.dict_menu_dots_funcs.get(instance.text)() def get_dampers(self, order="no order", *args): """ Get all dampers from the DB and store them into self.dampers. :param order: str for sorting can be: "by number", "by location", "by check date", by is released", "no order" """ self.damper = Damper() try: self.dampers = self.damper.get_dampers(order) except sqlite3.DatabaseError: toast(self.tr._("Can't get dampers from the DB")) else: # Not to show_dampers in the first start # because it'll be done in change_screen. if not self.is_first_started: self.show_dampers() def show_dampers(self, is_search=False, *args): """ Get all dampers from the DB and show them. :param args: for Clock.schedule_once(self.set_field_focus, 1) in self.clear_db :param is_search: if True show only found dampers in self.found_dampers. """ # Hide search if not search. if not is_search: self.hide_search() if self.all_dampers_in_container: for damper in self.all_dampers_in_container: self.dampers_container.remove_widget(damper) # Clear all selections. self.selected_dampers.clear() self.all_dampers_in_container.clear() # If search show only found dampers in self.found_dampers. dampers = self.found_dampers if is_search else self.dampers if self.dampers: for self.damper in dampers: # Format for output damper data. released = "Released" if self.damper.is_released else "Not released" text = "{} {}".format(self.damper.number, self.damper.location) secondary_text = "{} {}".format(self.damper.check_date, released) tertiary_text = "{} {}".format( self.damper.d_type, self.damper.notes) a_damper_list_item = DamperListItem( text=text, secondary_text=secondary_text, tertiary_text=tertiary_text) self.dampers_container.add_widget(a_damper_list_item) # Add all adding DamperListItem to the list for # getting access to right_checkbox_dampers in the future. self.all_dampers_in_container.append(a_damper_list_item) else: # Clock.schedule_once(lambda x: (toast("No dampers in the DB")), 4) toast(self.tr._("No dampers in the DB")) def show_search(self, *args): """Show search.""" self.tf_search.focused = True self.is_search_focused = True # Slide tf_search top down from .96 to .9 anim_search = Animation(top_hint_search=.9) anim_search.start(self.tf_search) # Slide container(GridLayout) top down from .9 to .84 anim_container = Animation(top_hint_container=.84) anim_container.start(self.container) def hide_search(self, *args): """Hide search.""" self.is_search_focused = False # Clear tf_search when hiding. self.tf_search.text = "" # Slide tf_search top up from .9 to .96 anim_search = Animation(top_hint_search=.96) anim_search.start(self.tf_search) # Slide container(GridLayout) top up from .84 to .9 anim_container = Animation(top_hint_container=.9) anim_container.start(self.container) def search_text_changed(self, finding_text): """ Search dampers by finding_text, add filtered dampers to the self.found_dampers and output them in self.show_dampers. :param finding_text: """ self.found_dampers = [] for self.damper in self.dampers: if (finding_text in self.damper.number or finding_text in self.damper.location or finding_text in self.damper.check_date): self.found_dampers.append(self.damper) self.show_dampers(is_search=True) def choose(self, is_backup=True, *args): """ Call plyer filechooser API to run a filechooser Activity. """ if platform == "android": from android.permissions import request_permissions, Permission, check_permission # Check if the permissions still granted. if not check_permission(Permission.WRITE_EXTERNAL_STORAGE): request_permissions([Permission.WRITE_EXTERNAL_STORAGE]) else: filechooser.open_file(on_selection=self.backup_db if is_backup else self.restore_db) else: filechooser.open_file( on_selection=self.backup_db if is_backup else self.restore_db) def backup_db(self, selection): """Backup Database.""" # chosen_dir = filechooser.choose_dir(title="Choose directory") # Doesn't work on Android (why?). chosen_dirname = os.path.dirname(selection[0]) now = datetime.now() now_datetime = ("{}-{}-{}_{}-{}-{}".format(now.year, str(now.month).zfill(2), str(now.day).zfill(2), str(now.hour).zfill(2), str(now.minute).zfill(2), str(now.second).zfill(2))) # dirname = os.path.dirname(__file__) # doesn't work on Android. dirname = os.getcwd() src_db_path = "{}{}dampers.db".format(dirname, os.sep) dst_filename = "{}{}{}_{}".format(chosen_dirname, os.sep, now_datetime, "dampers.db") try: shutil.copyfile(src_db_path, dst_filename) except OSError as err: toast(str(err)) # toast("SaveBackupError") else: toast(self.tr._("Backup file saved")) def restore_db(self, selection): """Restore Database.""" # dst_db_path = os.path.dirname(__file__) # doesn't work on Android. dst_db_path = os.getcwd() try: shutil.copyfile(selection[0], "{}{}{}".format(dst_db_path, os.sep, "dampers.db")) except OSError as err: toast(str(err)) # toast("RestoreBackupError") else: toast(self.tr._("Backup file restored")) # Get and show dampers after restoring. self.get_dampers() def show_themepicker(self, *args): picker = MDThemePicker() picker.open() picker.bind(on_dismiss=self.themepicker_dismiss) def themepicker_dismiss(self, instance): """ Changing the App primary_palette, accent_palette and theme_style. :param instance: current MDThemePicker. """ self.primary_palette = self.theme_cls.primary_palette self.accent_palette = self.theme_cls.accent_palette self.theme_style = self.theme_cls.theme_style self.change_toolbar_theme() self.save_config() def change_toolbar_theme(self): """Changing tb_primary_palette for all MyToolbars.""" self.home_screen.ids[ "tb_home"].tb_primary_palette = self.primary_palette self.root.ids["add_type_screen"].ids[ "tb_addedit"].tb_primary_palette = self.primary_palette self.root.ids["edit_type_screen"].ids[ "tb_addedit"].tb_primary_palette = self.primary_palette self.root.ids["delete_edit_type_screen"].ids[ "tb_deleteedittype"].tb_primary_palette = self.primary_palette self.root.ids["add_damper_screen"].ids[ "tb_addedit"].tb_primary_palette = self.primary_palette self.root.ids["edit_damper_screen"].ids[ "tb_addedit"].tb_primary_palette = self.primary_palette self.root.ids["language_screen"].ids[ "tb_addedit"].tb_primary_palette = self.primary_palette def change_screen(self, screen_name, *args): if screen_name == "home_screen": self.tf_search.focused = False self.tf_search.text = "" self.get_dampers() self.screen_manager.current = screen_name def show_delete_dampers_dialog(self, *args): """Show delete damper dialog.""" if self.selected_dampers: dialog = MDDialog(title=self.tr._("Delete damper"), size_hint=(.7, .4), text_button_ok=self.tr._("Delete"), text_button_cancel=self.tr._("Cancel"), auto_dismiss=False, events_callback=self.delete_selected_dampers, text=self.tr._( "This action will delete selected dampers" "\nfrom the Database." "\nDo you really want to do this?")) dialog.open() def delete_selected_dampers(self, text_of_selection, *args): """ Delete selected items from DB and _item_container. """ if text_of_selection == self.tr._("Delete"): # if self.selected_dampers: for selected_damper in self.selected_dampers: # Get the damper the_number. damper_number = selected_damper.text.split()[0] damper = Damper() try: damper.delete_damper(damper_number) except sqlite3.DatabaseError: toast("DeleteDamperError") else: self.dampers_container.remove_widget(selected_damper) toast(self.tr._("Deleted")) self.get_dampers() def edit_selected_damper(self, *args): """Edit selected damper.""" if self.selected_dampers: # if self.selected_dampers is not empty. if len(self.selected_dampers) > 1: toast(self.tr._("Select one for editing")) else: number_location = self.selected_dampers[0].text.split() checkdate_isreleased = self.selected_dampers[ 0].secondary_text.split() dtype_notes = self.selected_dampers[0].tertiary_text.split() self.edit_damper_screen.old_number = number_location[0] self.edit_damper_screen.old_location = number_location[1] self.edit_damper_screen.old_check_date = checkdate_isreleased[ 0] self.edit_damper_screen.old_is_released = True if checkdate_isreleased[ 1] == "Released" else False self.edit_damper_screen.old_d_type = dtype_notes[0] self.edit_damper_screen.old_notes = dtype_notes[1] if len( dtype_notes) == 2 else "" self.change_screen("edit_damper_screen") def show_clear_db_dialog(self, *args): """Show clear DB dialog.""" dialog = MDDialog( title=self.tr._("Clear Database"), size_hint=(.7, .4), text_button_ok=self.tr._("Clear"), text_button_cancel=self.tr._("Cancel"), auto_dismiss=False, events_callback=self.clear_db, text=self.tr._( "[color={}]This action will delete " "\n[b]ALL[/b] data from the Database." "\nDo you really want to do this?[/color]").format("#FF0000")) dialog.open() def clear_db(self, text_of_selection, *args): """Delete ALL date from the DB.""" if text_of_selection == self.tr._("Clear"): damper = Damper() try: damper.clear_db() except sqlite3.DatabaseError: toast("ClearDBError") else: toast(self.tr._("Cleared")) # Delay for showing toast("Cleared") Clock.schedule_once(self.get_dampers, 1) def select_all(self, *args): """Select all elements.""" for damper_list_item in self.all_dampers_in_container: damper_list_item.ids["right_checkbox_dampers"].active = True def cancel_all_selection(self, *args): """Cancel selection of all elements.""" for damper_list_item in self.all_dampers_in_container: damper_list_item.ids["right_checkbox_dampers"].active = False def add_into_selected_dampers(self, instance): """Add selected item into the list: selected_dampers.""" self.selected_dampers.append(instance) def del_from_selected_dampers(self, instance): """Delete selected item from the list: selected_dampers.""" self.selected_dampers.remove(instance)