"""

menu = tk.Menu(main_window, tearoff=0)

if not history.is_history_enabled():

menu.add_command(label="(History Disabled - Enable in Settings)", state="disabled")

else:

paths = history.get_input_paths() if path_type == 'input' else history.get_output_paths()

if not paths:

menu.add_command(label="(No recent paths)", state="disabled")

for path in paths:

def set_path(p=path):

if path_type == 'input':

set_input_selection([p])

else:

output_entry.delete(0, tk.END)

output_entry.insert(0, p)

menu.add_command(label=history.format_path_for_display(path), command=set_path)

if path_type == 'input':

# images given together in a run; the ones found beside them are found again

for input_set in history.get_input_sets():

given = [p for p in input_set.get('paths', [])

if p not in input_set.get('found_automatically', [])]

if len(given) > 1:

menu.add_command(

label=selection_text([history.format_path_for_display(p) for p in given]),

command=lambda g=given: set_input_selection(g))

x = input_entry.winfo_rootx()

y = button.winfo_rooty() + button.winfo_height()

'''Create a list of available modules:

global mlist

for plugin in sorted(loader.plugins, key=lambda p: p.category.upper()):

if (plugin.module_name == 'iTunesBackupInfo'

or plugin.name == 'last_build'

or plugin.module_name == 'logarchive' and plugin.name != 'logarchive'):

continue

# Items that take a long time to execute are deselected by default

# and referenced in the modules_to_exclude list in an external file (modules_to_exclude.py).

plugin_enabled = tk.BooleanVar(value=False) if plugin.module_name in modules_to_exclude else tk.BooleanVar(value=True)

plugin_module_name = plugin.artifact_info.get('name', plugin.name) if hasattr(plugin, 'artifact_info') else plugin.name

'''Update the number and return the list of selected modules'''

selected_modules = []

for artifact_name, module_infos in mlist.items():

if module_infos[-1].get():

selected_modules.append(artifact_name)

selected_modules_label.config(text=f'Number of selected modules: {len(selected_modules)} / {len(mlist)}')

'''Return True when a module matches the active filter, meaning it is one of the modules

if filter_term is None:

filter_term = modules_filter_var.get().lower()

'''Select the modules currently shown in the list and execute get_selected_modules'''

for module_infos in mlist.values():

if module_matches_filter(module_infos):

module_infos[-1].set(True)

'''Unselect the modules currently shown in the list and execute get_selected_modules'''

for module_infos in mlist.values():

if module_matches_filter(module_infos):

module_infos[-1].set(False)

mlist_text.config(state='normal')

filter_term = modules_filter_var.get().lower()

mlist_text.delete('0.0', tk.END)

for artifact_name, module_infos in mlist.items():

if module_matches_filter(module_infos, filter_term):

if is_platform_macos():

cb = ttk.Checkbutton(

mlist_text,

name=f'mcb_{artifact_name}',

text=f'{module_infos[0]} [{module_infos[1]} | {module_infos[2]}.py]',

variable=module_infos[-1],

onvalue=True,

offvalue=False,

command=get_selected_modules,

style='Module.TCheckbutton')

else:

cb = tk.Checkbutton(

mlist_text,

name=f'mcb_{artifact_name}',

text=f'{module_infos[0]} [{module_infos[1]} | {module_infos[2]}.py]',

variable=module_infos[-1],

onvalue=True,

offvalue=False,

command=get_selected_modules)

cb.config(

background=theme_bgcolor,

fg=theme_fgcolor,

selectcolor=theme_inputcolor,

highlightthickness=0,

activebackground=theme_bgcolor,

activeforeground=theme_fgcolor)

mlist_text.window_create('insert', window=cb)

mlist_text.insert('end', '\n')

'''Select modules from a profile file'''

global profile_filename

destination_path = tk_filedialog.askopenfilename(parent=main_window,

title='Load a profile',

filetypes=(('iLEAPP Profile', '*.ilprofile'),))

if destination_path and os.path.exists(destination_path):

profile_load_error = None

with open(destination_path, 'rt', encoding='utf-8') as profile_in:

try:

profile = json.load(profile_in)

except:

profile_load_error = 'File was not a valid profile file: invalid format'

if not profile_load_error:

if isinstance(profile, dict):

if profile.get('leapp') != 'ileapp' or profile.get('format_version') != 1:

profile_load_error = 'File was not a valid profile file: incorrect LEAPP or version'

else:

deselect_all()

ticked = set(profile.get('plugins', []))

for artifact_name, module_infos in mlist.items():

if artifact_name in ticked:

module_infos[-1].set(True)

get_selected_modules()

else:

profile_load_error = 'File was not a valid profile file: invalid format'

if profile_load_error:

tk_msgbox.showerror(title='Error', message=profile_load_error, parent=main_window)

else:

profile_filename = destination_path

tk_msgbox.showinfo(

'''Save selected modules in a profile file'''

destination_path = tk_filedialog.asksaveasfilename(parent=main_window,

title='Save a profile',

filetypes=(('iLEAPP Profile', '*.ilprofile'),),

defaultextension='.ilprofile')

if destination_path:

selected_modules = get_selected_modules()

with open(destination_path, 'wt', encoding='utf-8') as profile_out:

json.dump({'leapp': 'ileapp', 'format_version': 1, 'plugins': selected_modules}, profile_out)

tk_msgbox.showinfo(

'''Show the files picked in the input field: one path, or the first and how many more.'''

input_selection[:] = list(paths) if len(paths) > 1 else []

input_entry.delete(0, 'end')

'''Returns tuple (success, extraction_type)'''

i_path = input_entry.get() # input file/folder

several = input_paths()

if len(several) > 1:

# The member images of a RAID set, read together as raw images

missing = [p for p in several if not os.path.isfile(p) and not names_an_image_folder(p)]

if missing:

tk_msgbox.showerror(title='Error', message=f'INPUT file does not exist: {missing[0]}',

parent=main_window)

return False, '', None

if not names_raw_images(several):

tk_msgbox.showerror(title='Error', message='Several files are read together only as disk '

'images, the member images of a RAID set.', parent=main_window)

return False, '', None

logical = logical_among(several)

if logical is not None:

tk_msgbox.showerror(title='Error', message=logical_refusal(logical), parent=main_window)

return False, '', None

i_path = several[0]

o_path = output_entry.get() # output folder

ext_type = ''

# check input

if len(i_path) == 0:

tk_msgbox.showerror(title='Error', message='No INPUT file or folder selected!', parent=main_window)

return False, ext_type, None

elif not os.path.exists(i_path):

tk_msgbox.showerror(title='Error', message='INPUT file/folder does not exist!', parent=main_window)

return False, ext_type, None

elif names_an_image_folder(i_path):

# an Apple sparse bundle or an AFD folder is one disk image, not a folder

# of extracted files

ext_type = 'raw'

elif os.path.isdir(i_path):

itunes_backup_type = get_itunes_backup_type(i_path)

if itunes_backup_type:

supported, encrypted, message = check_itunes_backup_status(

i_path, itunes_backup_type)

if not supported:

tk_msgbox.showerror(title='Error', message=message,

parent=main_window)

return False, ext_type, None

else:

if encrypted:

decryption_keys = None

while not decryption_keys:

password = tk.simpledialog.askstring(

"Detected encrypted iTunes backup",

"iTunes Backup password:",

show='*',

parent=main_window)

decryption_keys, message = decrypt_itunes_backup(i_path, password)

if not decryption_keys:

tk_msgbox.showerror(title='Error', message=message,

parent=main_window)

return False, ext_type, decryption_keys

else:

return True, 'itunes', decryption_keys

ext_type = 'itunes'

else:

ext_type = 'fs'

else:

# one segment of a split raw image (.001 beside .002) is accepted as it

# is: the vendored reader joins the set and the run log says so

ext_type = Path(i_path).suffix[1:].lower()

# A raw disk image has no type of its own, only a conventional extension,

# so the suffix taken literally ('img', 'bin') matches no branch in

# crunch_artifacts and the run stops with nothing parsed. Map the

# conventional ones onto the input type that reads them.

if ext_type in RAW_IMAGE_SUFFIXES:

ext_type = 'raw'

# An xz-compressed tar ends in 'xz', which matches no branch either. The

# tar seeker opens it through tarfile's compression detection.

elif i_path.lower().endswith('.tar.xz'):

ext_type = 'tar'

if len(several) > 1:

ext_type = 'raw'

# check output now

if len(o_path) == 0: # output path

tk_msgbox.showerror(title='Error', message='No output path provided!', parent=main_window)

return False, ext_type, None

folder_name = output_folder_name_entry.get().strip()

if not folder_name:

tk_msgbox.showerror(title='Error', message='Output folder name cannot be empty!', parent=main_window)

return False, ext_type, None

folder_name_valid, folder_name_error = validate_output_folder_available(o_path, folder_name)

if not folder_name_valid:

tk_msgbox.showerror(title='Error', message=folder_name_error, parent=main_window)

return False, ext_type, None

# check if at least one module is selected

if len(get_selected_modules()) == 0:

tk_msgbox.showerror(title='Error', message='No module selected for processing!', parent=main_window)

return False, ext_type, None

'''Open the generated project in LAVA and quit after processing completed.'''

try:

open_lava_project(project_path, launcher, logfunc)

except (OSError, ValueError) as ex:

tk_msgbox.showerror(

title='Unable to open LAVA',

message=f'iLEAPP could not open the project in LAVA:\n{ex}',

parent=main_window)

return

'''Open the generated output folder.'''

try:

open_output_folder(output_path)

except OSError as ex:

tk_msgbox.showerror(

title='Unable to open output folder',

message=f'iLEAPP could not open the output folder:\n{ex}',

'''Open Settings modal window'''

settings_window = tk.Toplevel(main_window)

settings_window.transient(main_window)

settings_window_width = 400

settings_window_height = 260

#### Places Case Data window in the center of the main window

main_window.update_idletasks()

main_x = main_window.winfo_x()

main_y = main_window.winfo_y()

main_w = main_window.winfo_width()

main_h = main_window.winfo_height()

margin_width = main_x + (main_w - settings_window_width) // 2

margin_height = main_y + (main_h - settings_window_height) // 2

settings_window.geometry(f'{settings_window_width}x{settings_window_height}+{margin_width}+{margin_height}')

settings_window.resizable(False, False)

settings_window.configure(bg=theme_bgcolor)

settings_window.title('Settings')

settings_window.grid_columnconfigure(0, weight=1)

def on_main_focus(event):

if settings_window.winfo_exists():

settings_window.bell()

settings_window.lift()

settings_window.focus_force()

main_window.bind("<FocusIn>", on_main_focus)

def close_settings_window():

main_window.unbind("<FocusIn>")

settings_window.destroy()

settings_window.protocol("WM_DELETE_WINDOW", close_settings_window)

settings_title_label = ttk.Label(settings_window, text='Settings', font='Helvetica 18')

settings_title_label.grid(row=0, column=0, padx=14, pady=7, sticky='w')

history_enabled_var = tk.BooleanVar(value=history.is_history_enabled())

def toggle_history():

history.set_history_enabled(history_enabled_var.get())

def update_clear_history_button():

state = tk.NORMAL if history.has_history() else tk.DISABLED

clear_history_btn.config(state=state)

def open_clear_history_window():

clear_window = tk.Toplevel(settings_window)

clear_window.transient(settings_window)

clear_window_width = 460

clear_window_height = 220

settings_window.update_idletasks()

settings_x = settings_window.winfo_x()

settings_y = settings_window.winfo_y()

settings_w = settings_window.winfo_width()

settings_h = settings_window.winfo_height()

margin_width = settings_x + (settings_w - clear_window_width) // 2

margin_height = settings_y + (settings_h - clear_window_height) // 2

clear_window.geometry(f'{clear_window_width}x{clear_window_height}+{margin_width}+{margin_height}')

clear_window.resizable(False, False)

clear_window.configure(bg=theme_bgcolor)

clear_window.title('Clear History')

clear_window.grid_columnconfigure(0, weight=1)

def on_settings_focus(event):

if clear_window.winfo_exists():

clear_window.bell()

clear_window.lift()

clear_window.focus_force()

settings_window.bind("<FocusIn>", on_settings_focus)

def close_clear_window():

settings_window.unbind("<FocusIn>")

clear_window.destroy()

clear_window.protocol("WM_DELETE_WINDOW", close_clear_window)

clear_title_label = ttk.Label(clear_window, text='Clear History', font='Helvetica 18')

clear_title_label.grid(row=0, column=0, padx=14, pady=7, sticky='w')

clear_message = (

'History is stored in shared LEAPP files. Input and output paths are shared by all '

'LEAPP tools, while recent runs are tagged by tool.'

)

clear_message_label = ttk.Label(clear_window, text=clear_message, wraplength=420)

clear_message_label.grid(row=1, column=0, padx=14, pady=10, sticky='w')

button_frame = ttk.Frame(clear_window)

button_frame.grid(row=2, column=0, padx=14, pady=18, sticky='e')

def clear_single_leapp_history():

if not tk_msgbox.askyesno(

title=f'Clear {leapp_name} history',

message=(

f'Clear shared recent input/output paths and '

f'{leapp_name} recent run entries?'

),

parent=clear_window):

return

history.clear_single_leapp_history(leapp_name.lower())

update_clear_history_button()

close_clear_window()

def clear_all_history():

if not tk_msgbox.askyesno(

title='Clear all LEAPP history',

message='Clear all shared LEAPP history, including recent input and output paths?',

parent=clear_window):

return

history.clear_history()

update_clear_history_button()

close_clear_window()

clear_single_leapp_btn = ttk.Button(

button_frame,

text=f'Clear {leapp_name} History',

command=clear_single_leapp_history)

clear_single_leapp_btn.pack(side='left', padx=5)

if not history.has_single_leapp_history(leapp_name.lower()):

clear_single_leapp_btn.config(state=tk.DISABLED)

clear_all_btn = ttk.Button(

button_frame,

text='Clear All History',

command=clear_all_history)

clear_all_btn.pack(side='left', padx=5)

cancel_btn = ttk.Button(button_frame, text='Cancel', command=close_clear_window)

cancel_btn.pack(side='left', padx=5)

if is_platform_macos():

clear_window.grab_set_global()

else:

clear_window.grab_set()

history_check = tk.Checkbutton(

settings_window,

text='Enable saving paths as recent history',

variable=history_enabled_var,

command=toggle_history,

background=theme_bgcolor,

fg=theme_fgcolor,

selectcolor=theme_inputcolor,

activebackground=theme_bgcolor,

activeforeground=theme_fgcolor,

highlightthickness=0,

)

history_check.grid(row=1, column=0, padx=14, pady=20, sticky='w')

clear_history_btn = ttk.Button(

settings_window,

text='Clear History',

command=open_clear_history_window)

clear_history_btn.grid(row=2, column=0, padx=14, pady=10, sticky='w')

update_clear_history_button()

close_btn = ttk.Button(settings_window, text='Close', command=close_settings_window)

close_btn.grid(row=3, column=0, padx=14, pady=20, sticky='e')

if is_platform_macos():

settings_window.grab_set_global()

else:

try:

base_path = sys._MEIPASS

except Exception:

base_path = os.path.abspath(".")

'''Execute selected modules and create reports'''

# check if selections made properly; if not we will return to input form without exiting app altogether

is_valid, extracttype, decryption_keys = ValidateInput()

if is_valid:

# An encrypted image opens only with what locked it, and a BitLocker, APFS or

# LUKS volume in an image with its own key: asked for here, checked against the image,

# and handed to the run, never stored.

# One image that holds a RAID member has the other members looked for beside it,

# and the examiner is asked before files found that way are read.

image_password = None

found_members = None

input_path = input_entry.get()

if extracttype == 'raw':

raw_input = ask_raw_input(main_window, input_paths())

if raw_input is None:

return

image_password = raw_input.keys

input_path = raw_input.input_path

# what was found beside the image picked, and any image picked twice

found_members = raw_input

GuiWindow.window_handle = main_window

output_folder = output_entry.get()

# ios file system extractions contain paths > 260 char, which causes problems

# This fixes the problem by prefixing \\?\ on each windows path.

if is_platform_windows():

if input_path[1] == ':' and extracttype == 'fs': input_path = '\\\\?\\' + input_path.replace('/', '\\')

if output_folder[1] == ':': output_folder = '\\\\?\\' + output_folder.replace('/', '\\')

# re-create modules list based on user selection

selected_modules = get_selected_modules()

selected_modules = [loader[module] for module in selected_modules]

progress_bar.config(maximum=len(selected_modules))

casedata = {key: value.get() for key, value in casedata.items()}

out_params = OutputParameters(output_folder, output_folder_name_entry.get().strip())

Context.set_output_params(out_params)

keychain_path = keychain_entry.get().strip()

if keychain_path and not os.path.isfile(keychain_path):

tk_msgbox.showerror(title='Error',

message=f'Keychain file not found:\n{keychain_path}',

parent=main_window)

return

Context.set_keychain_path(keychain_path or None)

wrap_text = True

time_offset = timezone_set.get()

if time_offset == '':

time_offset = 'UTC'

bottom_frame.pack_forget()

mlist_frame.pack_forget()

output_frame.pack_forget()

input_frame.pack_forget()

keychain_frame.pack_forget()

logtext_frame.pack(padx=8, pady=4, expand=True, fill='both')

# Packed at the bottom, ahead of the log, so a window shorter than its contents

# shrinks the log instead of hiding the progress bar or the end-of-run buttons.

progress_bar_frame.pack(side='bottom', padx=2, pady=2, ipady=2, fill='x', before=logtext_frame)

# Record history if enabled

if isinstance(input_path, list):

history.record_input_set(input_path, getattr(found_members, 'found', found_members))

else:

history.record_input_path(input_path)

history.record_output_path(output_folder)

# crunch_artifacts blocks for the length of the run. Called here it blocks the Tk

# event loop too, and the only thing pumping that loop was log_text.update() inside

# logfunc, so Windows paints "(Not Responding)" over a run that is perfectly healthy.

# Run it on a worker thread and poll for its output instead.

GuiWindow.message_queue = queue.Queue()

worker = threading.Thread(

target=run_crunch,

args=(GuiWindow.message_queue, selected_modules, extracttype, input_path,

out_params, wrap_text, casedata, time_offset, decryption_keys,

image_password, found_members),

daemon=True)

worker.start()

case_info, time_offset, decryption_keys, image_password=None, found_members=None):

'''Do the processing off the main thread. Touches no widget; reports on the queue.'''

try:

# LAVA's SQLite connection is opened here rather than in process(): a sqlite3

# object may only be used by the thread that created it, so a connection opened

# on the main thread is unusable by the artifacts running on this one.

initialize_lava(input_text(input_path, found_members), out_params.output_folder_base,

extracttype, profile_filename)

crunch_successful = ileapp.crunch_artifacts(

selected_modules, extracttype, input_path, out_params, wrap_text,

loader, case_info, time_offset, profile_filename, None, decryption_keys,

image_password=image_password,

found_members=found_members)

lava_finalize_output(out_params.output_folder_base)

except Exception: # pylint: disable=broad-exception-caught

# Without this the GUI would poll an empty queue forever and look hung for real.

message_queue.put(('failed', traceback.format_exc()))

else:

'''Drain the worker's messages onto the widgets. The only place Tk is touched.'''

pending_logs = []

finished = None

while finished is None:

try:

kind, payload = message_queue.get_nowait()

except queue.Empty:

break

if kind == 'log':

pending_logs.append(payload)

elif kind == 'progress':

progress_bar.config(value=payload)

else:

finished = (kind, payload)

if pending_logs:

# One insert per poll, not one per line: a chatty artifact queues thousands, and

# inserting each separately costs more than the run it is reporting on.

log_text.insert('end', ''.join(pending_logs))

log_text.see('end')

if finished is None:

main_window.after(CRUNCH_POLL_MS, poll_crunch, message_queue, out_params)

return

GuiWindow.end_worker_run() # queue cleared, and print() put back on the console

kind, payload = finished

if kind == 'failed':

logfunc('Processing failed with an unhandled error:')

logfunc(payload)

finish_crunch(False, out_params)

else:

'''Report the outcome. Runs on the main thread once the worker is done.'''

if crunch_successful:

# Record the run in history

report_path = os.path.join(out_params.output_folder_base, 'index.html')

lava_project_path = os.path.join(out_params.output_folder_base, lava_json_name)

history.record_recent_run(leapp_name.lower(), leapp_version, lava_project_path)

output_folder_path = out_params.output_folder_base

if report_path.startswith('\\\\?\\'): # windows

report_path = report_path[4:]

lava_project_path = lava_project_path[4:]

output_folder_path = output_folder_path[4:]

if report_path.startswith('\\\\'): # UNC path

report_path = report_path[2:]

lava_project_path = lava_project_path[2:]

output_folder_path = output_folder_path[2:]

if lava_only_artifacts:

message = "You have selected artifacts that are likely to return too much data "

message += "to be viewed in a Web browser.\n\n"

message += "Please see the 'LAVA only artifacts' tab in the HTML report for a list of these artifacts "

message += "and instructions on how to view them."

tk_msgbox.showwarning(

title="Important information",

message=message,

parent=main_window)

progress_bar.pack_forget()

completion_button_frame = ttk.Frame(progress_bar_frame)

completion_button_frame.place(relx=0.5, rely=0.5, anchor='center')

open_report_button = ttk.Button(

completion_button_frame,

text='Open HTML in Browser & Close',

command=lambda: open_report(report_path))

open_report_button.pack(side='left', padx=5)

lava_launcher = find_lava_launcher(lava_project_path)

if lava_launcher:

lava_button = ttk.Button(

completion_button_frame,

text='Open Project in LAVA & Close',

command=lambda: open_lava(lava_project_path, lava_launcher))

else:

lava_button = ttk.Button(

completion_button_frame,

text='Explore LAVA',

command=explore_lava)

lava_button.pack(side='left', padx=5)

open_folder_button = ttk.Button(

completion_button_frame,

text='Open Output Folder',

command=lambda: open_folder(output_folder_path))

open_folder_button.pack(side='left', padx=5)

else:

log_path = out_params.screen_output_file_path

if log_path.startswith('\\\\?\\'): # windows

log_path = log_path[4:]

tk_msgbox.showerror(

title='Error',

message=f'Processing failed :( \nSee log for error details..\nLog file located at {log_path}',

'''Handle the window's close button.

if GuiWindow.message_queue is not None:

close_anyway = tk_msgbox.askokcancel(

title='Processing still running',

message='A run is still in progress.\n\n'

'Closing now stops it where it is. The report and the LAVA project '

'will be incomplete, and temporary files may be left behind.\n\n'

'Close anyway?',

icon=tk_msgbox.WARNING,

default=tk_msgbox.CANCEL,

parent=main_window)

if not close_anyway:

return

'''Select source and insert its path into input field'''

if button_type == 'file':

# Several disk images can be picked together: the member images of a RAID set

picked = tk_filedialog.askopenfilenames(parent=main_window,

title='Select a file (or the disk images of a RAID set)',

filetypes=(('All supported files',

'*.tar *.zip *.gz *.xz ' + RAW_IMAGE_FILE_PATTERNS),

('tar file', '*.tar'), ('zip file', '*.zip'),

('gz file', '*.gz'),

('tar.xz file', '*.xz'),

(RAW_IMAGE_LABEL, RAW_IMAGE_FILE_PATTERNS)))

picked = list(main_window.tk.splitlist(picked)) if picked else []

else:

folder = tk_filedialog.askdirectory(parent=main_window, title='Select a folder')

picked = [folder] if folder else []

set_input_selection(picked)

if len(picked) > 1:

history.record_input_set(picked)

elif picked:

'''Select a keychain file and insert its path into the keychain field'''

keychain_filename = tk_filedialog.askopenfilename(

parent=main_window,

title='Select a keychain file',

filetypes=(('Keychain files', '*.plist *.xml'), ('All files', '*.*')))

if keychain_filename:

keychain_entry.delete(0, 'end')

'''Select target and insert its path into output field'''

output_filename = tk_filedialog.askdirectory(parent=main_window, title='Select a folder')

output_entry.delete(0, 'end')

output_entry.insert(0, output_filename)

if output_filename:

# GUI layout

## Case Data

'''Add Case Data window'''

global casedata

def clear():

'''Remove the contents of all fields'''

case_number_entry.delete(0, 'end')

case_agency_name_entry.delete(0, 'end')

case_agency_logo_path_entry.delete(0, 'end')

case_agency_logo_mimetype.delete(0, 'end')

case_agency_logo_b64.delete(0, 'end')

case_examiner_entry.delete(0, 'end')

def save_case():

'''Save case data in a Case Data file'''

destination_path = tk_filedialog.asksaveasfilename(parent=case_window,

title='Save a case data file',

filetypes=(('LEAPP Case Data', '*.lcasedata'),),

defaultextension='.lcasedata')

if destination_path:

json_casedata = {key: value.get() for key, value in casedata.items()}

with open(destination_path, 'wt', encoding='utf-8') as case_data_out:

json.dump({'leapp': 'case_data', 'case_data_values': json_casedata}, case_data_out)

tk_msgbox.showinfo(

title='Save Case Data', message=f'Case Data saved: {destination_path}', parent=case_window)

def load_case():

'''Import case data from a Case Data file'''

destination_path = tk_filedialog.askopenfilename(parent=case_window,

title='Load case data',

filetypes=(('LEAPP Case Data', '*.lcasedata'),))

if destination_path and os.path.exists(destination_path):

case_data_load_error = None

with open(destination_path, 'rt', encoding='utf-8') as case_data_in:

try:

case_data = json.load(case_data_in)

except:

case_data_load_error = 'File was not a valid case data file: invalid format'

if not case_data_load_error:

if isinstance(case_data, dict):

if case_data.get('leapp') != 'case_data':

case_data_load_error = 'File was not a valid case data file'

else:

casedata = case_data.get('case_data_values', {})

case_number_entry.delete(0, 'end')

case_number_entry.insert(0, casedata.get('Case Number', ''))

case_agency_name_entry.delete(0, 'end')

case_agency_name_entry.insert(0, casedata.get('Agency', ''))

case_agency_logo_path_entry.delete(0, 'end')

case_agency_logo_path_entry.insert(0, casedata.get('Agency Logo Path', ''))

case_agency_logo_mimetype.delete(0, 'end')

case_agency_logo_mimetype.insert(0, casedata.get('Agency Logo mimetype', ''))

case_agency_logo_b64.delete(0, 'end')

case_agency_logo_b64.insert(0, casedata.get('Agency Logo base64', ''))

case_examiner_entry.delete(0, 'end')

case_examiner_entry.insert(0, casedata.get('Examiner', ''))

else:

case_data_load_error = 'File was not a valid case data file: invalid format'

if case_data_load_error:

tk_msgbox.showerror(title='Error', message=case_data_load_error, parent=case_window)

else:

tk_msgbox.showinfo(

title='Load Case Data', message=f'Loaded Case Data: {destination_path}', parent=case_window)

def add_agency_logo():

'''Import image file and covert it into base64'''

logo_path = tk_filedialog.askopenfilename(parent=case_window,

title='Add agency logo',

filetypes=(('All supported files', '*.png *.jpg *.gif'), ))

if logo_path and os.path.exists(logo_path):

agency_logo_load_error = None

with open(logo_path, 'rb') as agency_logo_file:

agency_logo_mimetype = guess_mime(agency_logo_file)

if agency_logo_mimetype and 'image' in agency_logo_mimetype:

try:

agency_logo_base64_encoded = base64.b64encode(agency_logo_file.read())

except:

agency_logo_load_error = 'Unable to encode the selected file in base64.'

else:

agency_logo_load_error = 'Selected file is not a valid picture file.'

if agency_logo_load_error:

tk_msgbox.showerror(title='Error', message=agency_logo_load_error, parent=case_window)

else:

case_agency_logo_path_entry.delete(0, 'end')

case_agency_logo_path_entry.insert(0, logo_path)

case_agency_logo_mimetype.delete(0, 'end')

case_agency_logo_mimetype.insert(0, agency_logo_mimetype)

case_agency_logo_b64.delete(0, 'end')

case_agency_logo_b64.insert(0, agency_logo_base64_encoded)

tk_msgbox.showinfo(

title='Add agency logo', message=f'{logo_path} was added as Agency logo', parent=case_window)

### Case Data Window creation

case_window = tk.Toplevel(main_window)

case_window.transient(main_window)

case_window_width = 560

if is_platform_linux():

case_window_height = 325

elif is_platform_macos():

case_window_height = 317

else:

case_window_height = 305

#### Places Case Data window in the center of the main window

main_window.update_idletasks()

main_x = main_window.winfo_x()

main_y = main_window.winfo_y()

main_w = main_window.winfo_width()

main_h = main_window.winfo_height()

margin_width = main_x + (main_w - case_window_width) // 2

margin_height = main_y + (main_h - case_window_height) // 2

#### Case Data window properties

case_window.geometry(

f'{case_window_width}x{case_window_height}'

f'{geometry_offset(margin_width)}{geometry_offset(margin_height)}')

case_window.resizable(False, False)

case_window.configure(bg=theme_bgcolor)

case_window.title('Add Case Data')

case_window.grid_columnconfigure(0, weight=1)

def on_main_focus(event):

if case_window.winfo_exists():

case_window.bell()

case_window.lift()

case_window.focus_force()

main_window.bind("<FocusIn>", on_main_focus)

def close_case_window():

main_window.unbind("<FocusIn>")

case_window.destroy()

case_window.protocol("WM_DELETE_WINDOW", close_case_window)

#### Layout

case_title_label = ttk.Label(case_window, text='Add Case Data', font=('Helvetica 18'))

case_title_label.grid(row=0, column=0, padx=14, pady=7, sticky='w')

case_number_frame = ttk.LabelFrame(case_window, text=' Case Number ')

case_number_frame.grid(row=1, column=0, padx=14, pady=5, sticky='we')

case_number_entry = ttk.Entry(case_number_frame, textvariable=casedata['Case Number'])

case_number_entry.pack(padx=5, pady=4, fill='x')

case_number_entry.focus()

case_agency_frame = ttk.LabelFrame(case_window, text=' Agency ')

case_agency_frame.grid(row=2, column=0, padx=14, pady=5, sticky='we')

case_agency_frame.grid_columnconfigure(1, weight=1)

case_agency_name_label = ttk.Label(case_agency_frame, text="Name:")