redraw.py

[Uncle Buddy]

<drive>:\treebard\app\python\redraw.py Last Changed 2024-04-16

# redraw.py

from tkinter import Label, Frame
import sqlite3
from files import get_current_tree, get_current_file, appwide_db_path, tree_path
from widgets import (
   configall, make_formats_dict, EntryAutoSinglePlace, EntryAutoSource,
   get_colors_type_id, TabBook)
from query_strings import (
   select_closing_state_family_tree, select_place_details,
   select_gender, update_current_person, select_nested_place_ids,
   select_current_person_id, select_place_name_from_id_if_main,
   select_current_nested_place_source, select_source_by_id)
import dev_tools as dt
from dev_tools import look, seeline
import inspect




PLACE_DETAIL_TYPES = (
   "latitude", "longitude", "cartesian coordinates", "township",
   "range", "section", "legal subdivision", "hint", "check duplicates")

def redraw_gui(
       evt=None, main=None, family_tree=None, current_person_id=None,
       current_file=None, current_nested_place_id=None, family_tree_id=None,
       current_source_id=None, conn=None,  cur=None, formats=None):
   new_connex = False
   if current_file:
       current_tree, current_dir = current_file
   if conn is None and family_tree_id:
       conn = sqlite3.connect(appwide_db_path)
       cur = conn.cursor()
       current_tree = get_current_tree(family_tree_id, cur)[0]
       cur.execute("ATTACH ? as tree", (current_tree,))
       new_connex = True  
   if current_file is None:
       cur.execute(select_closing_state_family_tree)
       file_name = cur.fetchone()[0]
       current_dir = file_name.replace(".tbd", "")
       current_file = (
           f"{tree_path}{current_dir}/{file_name}", current_dir)
   if current_nested_place_id is None or current_source_id is None:
       cur.execute(select_current_nested_place_source)
       current_nested_place_id, current_source_id = cur.fetchone()
   redraw_place_tab(
       current_nested_place_id, family_tree, main, current_file,
       cur, formats)
   redraw_source_tab(cur, current_source_id, main)
   redraw_names_tab(current_person_id, main)
   if evt:
       redraw_person_tab(
           evt=evt, main=main, current_person_id=current_person_id,
           family_tree_id=family_tree_id, family_tree=family_tree, cur=cur,
           conn=conn, current_file=current_file)
   else:
       redraw_person_tab(
           main=main, current_person_id=current_person_id,
           family_tree_id=family_tree_id, cur=cur, conn=conn,
           family_tree=family_tree, current_file=current_file)
   if new_connex:
       cur.execute("DETACH tree")
       cur.close()
       conn.close()
   configall(family_tree, formats)

def redraw_names_tab(current_person_id, main):
   name_change_table = main.names_tab_content.make_existing_names_table(
       current_person_id)
   return name_change_table

def redraw_place_tab(
       current_nested_place_id, family_tree, main, current_file,
       cur, formats):
   cur.execute(select_nested_place_ids, (current_nested_place_id,))
   nested_places = list(cur.fetchone())
   nest0 = nested_places[0]

   cur.execute(select_place_details, (nest0,))
   details = list(cur.fetchone())
   if details[8] == 1:
       details[8] = "yes"
   elif details[8] == 0:
       details[8] = "no"
   details = tuple(details)

   for idx,idnum in enumerate(list(nested_places)):
       cur.execute(select_place_name_from_id_if_main, (idnum,))
       name = cur.fetchone()[0]
       nested_places[idx] = name
   nested_places = [i for i in nested_places if i != "unknown"]
   nested_place_name = ", ".join(nested_places)

   main.new_current_place_input.delete(0, 'end')
   main.show_top_pic_nested_place(cur)
   main.current_nested_place = current_nested_place_id
   main.current_place_display.config(
       text=f"Current Nested Place:\n{nested_place_name}")

   for child in main.current_place_details.winfo_children():
       child.destroy()
   for idx, text in enumerate(PLACE_DETAIL_TYPES):
       text = f"{text}: {details[idx]}"
       lab = Label(main.current_place_details, text=text)
       lab.grid(sticky="w")

   family_tree.place_data = family_tree.get_place_values(
       new_place=True, current_tree=current_file[0])
   family_tree.single_place_autofill_values = family_tree.create_single_place_lists(cur)
   configall(main.current_place_details, formats=formats)

def redraw_source_tab(cur, current_source_id, main):
   source_name = ""
   cur.execute(select_source_by_id, (current_source_id,))
   result = cur.fetchone()
   if result:
       source_name = result[0]
   main.new_current_source_input.delete(0, 'end')
   main.show_top_pic_source(cur)
   main.current_source = current_source_id
   main.current_source_display.config(text=f"Current Source: {source_name}")

   main.family_tree.create_source_lists(cur=cur)

def redraw_person_tab(
       evt=None, main=None, current_person_id=None, family_tree=None,
       family_tree_id=None, current_file=None, cur=None, conn=None,
       current_grid_info=None):

   # ## Don't delete this commented block*************
   # current_frame = inspect.currentframe()
   # # This test detects where this function is being called from.
   # call_frame = inspect.getouterframes(current_frame, 2)
   # print('redraw_person_tab() ran, `caller name:`', call_frame[1][3])
   # ##***********************************************

   new_connex = False

   if main:
       events_table = main.events_table
       main.update_idletasks()

   if current_file:
       current_file = current_file

   if conn is None:
       current_tree = get_current_file()[0]
       conn = sqlite3.connect(appwide_db_path)
       conn.execute("PRAGMA foreign_keys = 1")
       cur = conn.cursor()
       cur.execute("ATTACH ? as tree", (current_tree,))
       new_connex = True

   if current_person_id is None:
       cur.execute(select_current_person_id)
       current_person_id = cur.fetchone()[0]

   family_tree.person_autofill_values = family_tree.update_person_autofill_values()
   current_name = family_tree.person_autofill_values[
       current_person_id][0]["name"]

   cur.execute(update_current_person, (current_person_id,))
   conn.commit()
   colors_type_id = get_colors_type_id(family_tree_id)

   if main:
       redraw_current_person_area(
           current_person_id, main, current_name, current_file)
       redraw_families_table(
           current_grid_info, family_tree.formats, family_tree, main=main,
           current_person_id=current_person_id)
       redraw_events_table(
           events_table, main, cur, family_tree.formats, current_person_id=current_person_id)

       main.update_idletasks()
       new_height = main.winfo_reqheight()
       new_width = main.winfo_reqwidth()

       key_ht = TabBook.related_tabbooks[family_tree]["tallest"][1]
       height = TabBook.related_tabbooks[family_tree]["tallest"][2]
       key_wd= TabBook.related_tabbooks[family_tree]["widest"][1]
       width = TabBook.related_tabbooks[family_tree]["widest"][2]

       if key_wd == "person" and width > new_width:
           TabBook.related_tabbooks[family_tree]["widest"][2] = new_width
       if key_ht == "person" and height > new_height:
           TabBook.related_tabbooks[family_tree]["tallest"][2] = new_height

       TabBook.resize_scrolled_dialog_with_tabbook(
           family_tree, family_tree.canvas, family_tree.window)
   if new_connex:
       cur.execute("DETACH tree")
       cur.close()
       conn.close()  

def redraw_current_person_area(current_person_id, main, current_name, current_file):
   current_tree = current_file[0]
   conn = sqlite3.connect(current_tree)
   cur = conn.cursor()
   main.current_person_input.delete(0, 'end')
   main.current_person_id = current_person_id
   main.show_top_pic(cur)
   main.current_person_input.current_id = None
   main.current_person_name = current_name
   if current_name:
       main.current_person_label.config(
           text=f"Current Person (ID): {current_name} ({current_person_id})")
   
   main.current_gender = get_current_person_gender(current_person_id, cur)

   cur.close()
   conn.close()

def redraw_families_table(
       current_grid_info, formats, family_tree, main=None, current_person_id=None):
   """ If you destroy some widgets in the families table, you have to destroy
       them all, in order to avoid a big problem restarting tab traversal from
       where it left off.
   """
   # start = timer()
   if current_person_id:
       main.nukefam_table.current_person_id = current_person_id
   main.nukefam_table.name_widgets = {}
   main.nukefam_table.editable_cells = []
   main.nukefam_table.couple_cells = {}
   main.nukefam_table.parent_cells = {}
   main.nukefam_table.original_text = ""  
   main.nukefam_table.final_text = ""
   for child in main.nukefam_table.parents_table.winfo_children():
       child.destroy()
   for child in main.nukefam_table.progeny_table.winfo_children():
       child.destroy()
   for child in main.nukefam_table.add_area.winfo_children():
       child.destroy()
   main.nukefam_table.make_nukefam_inputs()
   for widg in main.nukefam_table.editable_cells:
       if widg.master != main.nukefam_table.progeny_table:
           widg.bind(
               "<Control-Button-1>",
               main.nukefam_table.change_current_person)                
       elif (widg.master == main.nukefam_table.progeny_table and
               widg.grid_info()["column"] == 0):
           widg.bind("<Control-Button-1>", main.nukefam_table.change_current_person)
       widg.bind("<Double-Button-1>", main.nukefam_table.grid_edit_frame)
   main.nukefam_table.pardrads.set(99)
   if current_grid_info:
       main.nukefam_table.return_focus(current_grid_info)
   configall(main.nukefam_table, formats)
   family_tree.resize_families_table_scrollbar()

def redraw_events_table(events_table, main, cur, formats, current_person_id=None):

   for child in events_table.winfo_children():
       child.destroy()

   events_table.new_row = 0
   if current_person_id:
       events_table.current_person_id = current_person_id

   events_table.populate_events_table(cur)
   main.events_table.new_event_input.delete(0, "end")
   configall(main.events_table, formats)

def get_current_person_gender(current_person_id, cur):
   cur.execute(select_gender, (current_person_id,))
   gender = cur.fetchone()[0]
   if gender == "male":
       gender = "M"
   elif gender == "female":
       gender = "F"
   elif gender == "unknown":
       gender = "U"
   return gender