gallery.py
Nov 25, 2022 3:11:34 GMT -8
Post by Uncle Buddy on Nov 25, 2022 3:11:34 GMT -8
<drive>:\treebard\app\python\gallery.py Last Changed 2024-03-21
# gallery.py
import tkinter as tk
from PIL import Image, ImageTk
import sqlite3
from files import (
get_current_tree, current_drive, appwide_db_path, app_path, tree_path)
from utilities import resize_scrolled_content
from widgets import (
ScrolledDialog, configall, make_formats_dict, get_colors_type_id,
create_tooltip, run_statusbar_tooltips, MessageCopiable, Scrollbar,
RightClickMenu, make_rc_menus)
from messages_context_help import gallery_help_msg, gallery_thumbnail_help_msg
from dates import ChangeDate
from query_strings import (
select_all_images_nested_place, select_all_images_source,
select_all_images_person, select_current_person_id, select_source_by_id,
update_media_links_unmain_image_person,
update_media_links_unmain_image_nested_place, update_media_links_unmain_image_source,
update_media_links_main_image_person, update_media_links_main_image_nested_place,
update_media_links_main_image_source, select_current_source_id,
select_current_nested_place_id, select_nested_place_by_id,
select_nested_place_ids, select_place_name_from_id)
import dev_tools as dt
from dev_tools import look, seeline
class Gallery(ScrolledDialog):
def __init__(
self, master, family_tree_id, main, tabbook, graphics_tab, SCREEN_SIZE,
tab=None, current_person_id=None, current_person_name=None,
current_nested_place=None, current_source=None, *args, **kwargs):
ScrolledDialog.__init__(self, master, *args, **kwargs)
family_tree = master
self.family_tree_id = family_tree_id
self.main = main
self.tabbook = tabbook
self.graphics_tab = graphics_tab
self.SCREEN_WIDTH, self.SCREEN_HEIGHT = SCREEN_SIZE
self.tab = tab
self.current_person_id = current_person_id
self.current_nested_place = current_nested_place
self.current_source = current_source
self.protocol("WM_DELETE_WINDOW", self.cancel)
self.current_image = None
self.source = ""
self.place = ""
self.img_path = None
self.default_image = False
self.rc_menu = RightClickMenu(family_tree, self.treebard)
conn = sqlite3.connect(appwide_db_path)
cur = conn.cursor()
self.current_tree, self.current_dir = get_current_tree(
self.family_tree_id, cur)
cur.execute("ATTACH ? as tree", (self.current_tree,))
self.image_path_base = f"{tree_path}/{self.current_dir}/images/"
current_entity_name = None
self.main_pic = None
self.caption_text = ""
if current_person_name:
current_entity_name = current_person_name
elif self.current_nested_place:
cur.execute(select_nested_place_by_id, (self.current_nested_place,))
results = cur.fetchone()
if results:
current_entity_name = results[0]
place_name = []
cur.execute(select_nested_place_ids, (self.current_nested_place,))
nested_place_ids = cur.fetchone()
for num in nested_place_ids:
if num != 1:
cur.execute(select_place_name_from_id, (num,))
place_name.append(cur.fetchone()[0])
current_entity_name = ", ".join(place_name)
elif self.current_source:
cur.execute(select_source_by_id, (self.current_source,))
current_entity_name = cur.fetchone()[0]
else:
print("line", look(seeline()).lineno, "case_not_handled:")
self.counter = 0
self.thumb_labels = []
self.maxwidth = 0
self.maxheight = 0
pix_data = self.get_current_pix_data()
if len(pix_data) == 0:
self.default_image = True
self.filter_pix_data(pix_data)
self.geometry('+100+20')
gallery_type = "Person"
if self.current_nested_place:
gallery_type = "Place"
elif self.current_source:
gallery_type = "Source"
self.title(f"Current {gallery_type} Image Gallery")
self.make_gallery()
self.make_inputs(current_entity_name)
self.resize_scrolled_content(self, self.canvas, add_y=36)
cur.execute("DETACH tree")
cur.close()
conn.close()
ScrolledDialog.bind_canvas_to_mousewheel(self.canvas)
colors_type_id = get_colors_type_id(family_tree_id)
self.formats = make_formats_dict(colors_type_id=colors_type_id)
configall(self, self.formats)
def cancel(self):
self.grab_release()
self.destroy()
def make_gallery(self):
self.thumb_frame = tk.Frame(self.window)
self.thumb_canvas = tk.Canvas(
self.thumb_frame, bg=self.formats['bg'], bd=0, highlightthickness=0)
self.thumb_sbh = Scrollbar(
self.thumb_frame,
self.formats,
orient='horizontal',
command=self.thumb_canvas.xview,
hideable=True)
self.thumb_canvas.config(xscrollcommand=self.thumb_sbh.set)
self.viewer = tk.Frame(self.window, bd=2, relief='sunken')
self.thumbstrip = tk.Frame(self.thumb_canvas)
self.buttonbox = tk.Frame(self.window)
self.prevbutt = tk.Button(self.buttonbox, text='<<', width=7)
self.pic_canvas = tk.Canvas(
self.viewer, highlightthickness=3, bd=3)
self.pic_canvas.bind('<Button-1>', self.focus_clicked)
self.pic_canvas.bind('<Button-1>', self.scroll_start, add='+')
self.pic_canvas.bind('<B1-Motion>', self.scroll_move)
if self.default_image is False:
self.get_image_data()
def get_image_data(self):
self.img_path = f"{self.image_path_base}{self.main_pic}"
img_big = Image.open(self.img_path)
self.tk_img = ImageTk.PhotoImage(img_big)
self.pic_canvas.image = self.tk_img
z = 0
self.current_pictures = sorted(self.current_pictures)
for img in self.current_pictures:
pic_col = tk.Frame(self.thumbstrip)
pic_col.grid(column=z, row=0)
pic_file = img
self.img_path = f"{self.image_path_base}{pic_file}"
bare = pic_file.split(".")[1]
thumbsy = Image.open(self.img_path)
if thumbsy.width > self.maxwidth:
self.maxwidth = thumbsy.width
if thumbsy.height > self.maxheight:
self.maxheight = thumbsy.height
thumbsy.thumbnail((185,85))
thumb_path = '{}images/{}_tmb.png'.format(app_path, bare)
# overwrites file by same name if it exists
thumbsy.save(thumb_path)
small = ImageTk.PhotoImage(file=thumb_path, master=self.thumbstrip)
thumb = tk.Label(pic_col, image=small)
thumb.grid(column=0, row=0)
thumb.image = small
self.rc_menu.loop_made[thumb] = gallery_thumbnail_help_msg
self.thumb_labels.append(thumb)
rad = tk.Radiobutton(
pic_col,
takefocus=0,
value=pic_file,
command=lambda pic_file=pic_file: self.set_main_pic(
pic_file))
rad.grid(column=0, row=1)
if rad['value'] == self.main_pic:
rad.select()
create_tooltip(pic_col, pic_file)
z += 1
self.pil_img = img_big
self.fit_canvas_to_pic()
self.thumb_dict = dict(zip(self.thumb_labels, self.current_pictures))
def make_inputs(self, current_entity_name):
self.nextbutt = tk.Button(self.buttonbox, text='>>', width=7)
self.editbutt = tk.Button(
self.buttonbox, text="EDIT", width=7,
command=lambda graphics=self.graphics_tab, img_path=self.img_path:
self.go_to_graphics(graphics, img_path))
self.closebutt = tk.Button(
self.buttonbox, text="CLOSE",
width=7, command=self.cancel)
spacer = tk.Frame(self.buttonbox)
panel = tk.Frame(self.buttonbox)
subject = tk.Label(panel)
if current_entity_name:
subject.config(text=current_entity_name)
self.caption_lab = MessageCopiable(panel, self.formats)
self.picfile_lab = MessageCopiable(panel, self.formats)
self.picsize_lab = MessageCopiable(panel, self.formats)
self.prevbutt.config(command=self.back)
self.nextbutt.config(command=self.forward)
if self.default_image is False:
self.caption_lab.insert(1.0, self.caption_text)
self.picfile_lab.insert(1.0, self.img_path)
self.picsize_lab.insert(
1.0,
'width: {}, height: {}'.format(
self.pil_img.width, self.pil_img.height))
self.caption_lab.set_height()
self.picfile_lab.set_height()
self.picsize_lab.set_height()
# children of self
self.statusbar.grid(column=1, row=3, sticky='ew')
# children of self.window (see ScrolledDialog)
self.thumb_frame.grid(column=0, row=0, columnspan=2, sticky='w')
self.viewer.grid(column=0, row=2)
self.buttonbox.grid(column=0, row=3, sticky='ew', padx=12, pady=12)
# children of self.thumb_frame
self.thumb_canvas.grid(column=0, row=0, sticky="news")
self.thumb_sbh.grid(column=0, row=1, sticky="ew")
# children of self.thumb_canvas
self.thumbstrip.grid(column=0, row=0)
# children of self.viewer
self.pic_canvas.grid(column=0, row=0, columnspan=2)
# children of panel
subject.grid(column=0, row=0, sticky='w')
self.caption_lab.grid(column=0, row=1, sticky='w')
self.picfile_lab.grid(column=0, row=2, sticky='w')
self.picsize_lab.grid(column=0, row=3, sticky='w')
# children of self.buttonbox
self.buttonbox.columnconfigure(2, weight=10)
self.prevbutt.grid(column=0, row=0, sticky='e', padx=3, pady=3)
self.nextbutt.grid(column=1, row=0, sticky='e', padx=3, pady=3)
self.editbutt.grid(column=0, row=1, sticky='e', padx=3, pady=3)
self.closebutt.grid(column=1, row=1, sticky='e', padx=3, pady=3)
spacer.grid(column=2, row=0, rowspan=3, sticky='news')
panel.grid(column=3, row=0, rowspan=3, sticky='w')
for thumb in self.thumb_labels:
thumb.bind('<Button-1>', self.show_clicked)
self.pic_canvas.bind('<Key-Left>', lambda evt: self.back())
self.pic_canvas.bind('<Key-Right>', lambda evt: self.forward())
self.thumb_canvas.create_window(0, 0, anchor='nw', window=self.thumbstrip)
self.thumb_canvas.config(
scrollregion=(
0, 0,
self.thumbstrip.winfo_reqwidth(),
self.thumbstrip.winfo_reqheight()))
self.config_labels()
visited = (
(self.thumbstrip,
"Thumbnail Views",
"Click thumbnail to display. Hover to see the file name. "
"Select radio button to make this the main image."),
(self.pic_canvas,
"Image",
"Arrow keys change image when it's in focus."),
(self.prevbutt,
"Left Button",
"Click with mouse or when highlighted click with spacebar."),
(self.nextbutt,
"Right Button",
"Click with mouse or when highlighted click with spacebar."),
(self.editbutt,
"Edit Button",
"Open the current image in the Graphics Tab."))
run_statusbar_tooltips(
visited,
self.statusbar.status_label,
self.statusbar.tooltip_label,
self)
rcm_widgets = (
self.pic_canvas, self.prevbutt, self.nextbutt, self.editbutt)
make_rc_menus(
rcm_widgets,
self.rc_menu,
gallery_help_msg)
self.thumb_canvas.config(width=self.winfo_reqwidth(), height=130)
self.pic_canvas.focus_set()
def focus_clicked(self, evt):
evt.widget.focus_set()
def show_clicked(self, evt):
select_pic = self.current_pictures.index(self.thumb_dict[evt.widget])
self.chosen_picfile = self.current_pictures[select_pic]
self.img_path = f"{self.image_path_base}{self.chosen_picfile}"
pix_data = self.get_current_pix_data()
for tup in pix_data:
if tup[0] == self.chosen_picfile:
self.caption_text = tup[1]
self.main.current_image = tup[3]
new = Image.open(self.img_path)
self.tk_img = ImageTk.PhotoImage(new)
self.pil_img = new
self.fit_canvas_to_pic()
self.pic_canvas.image = self.tk_img
self.pic_canvas.config(
scrollregion=(0, 0, self.pil_img.width, self.pil_img.height))
self.config_labels()
self.counter = select_pic
def scroll_start(self, event):
self.pic_canvas.scan_mark(event.x, event.y)
def scroll_move(self, event):
self.pic_canvas.scan_dragto(event.x, event.y, gain=5)
def go_to_graphics(self, graphics, edit_image=None):
""" If a frame with this name already exists it's replaced:
https://stackoverflow.com/questions/59518905/
naming-a-widget-to-auto-destroy-replace-it
"""
picwin = tk.Frame(graphics, name='exists')
picwin.grid()
self.main.to_destroy.append(picwin)
curr_pic = self.picfile_lab.get(1.0, 'end')
curr_pic = curr_pic.strip('\n')
img_path = curr_pic
edit_pic = Image.open(img_path)
edit_img = ImageTk.PhotoImage(edit_pic)
editlab = tk.Label(picwin, None, image=edit_img)
editlab.image = edit_img
self.tabbook.active = self.tabbook.tabdict["graphics"][1]
self.tabbook.make_active()
# scroll to top so controls are seen when tab opens
self.main.canvas.yview_moveto(0.0)
if self:
self.lower(belowThis=self.tabbook)
editlab.grid() # When this grids a big pic, the whole tabbook gets big
# prevent large pics from blowing up size of the whole tabbook
# when placed here by edit button on a gallery
# Will need more attention when ready to make the graphics tab.
editlab.config(width=700, height=700)
self.main.edit_image = curr_pic
def filter_pix_data(self, pix_data):
def second_item(s):
return s[1]
pix_data = sorted(pix_data, key=second_item)
for lst in pix_data:
if lst[2] == 1:
self.main_pic = lst[0]
self.caption_text = lst[1]
if self.tab.winfo_name() == 'sourcetab':
self.source = lst[3]
elif self.tab.winfo_name() == 'placetab':
self.place = lst[3]
self.current_pictures = []
for lst in pix_data:
self.current_pictures.append(lst[0])
self.caption_path = []
for lst in pix_data:
self.caption_path.append((lst[0], lst[1]))
def back(self, evt=None):
if self.counter == 0:
self.counter = len(self.caption_path)
self.counter -= 1
self.img_path = f"{self.image_path_base}{self.caption_path[self.counter][0]}"
self.caption_text = self.caption_path[self.counter][1]
new = Image.open(self.img_path)
self.tk_img = ImageTk.PhotoImage(new)
self.pil_img = new
self.fit_canvas_to_pic()
self.pic_canvas.image = self.tk_img
self.pic_canvas.config(
scrollregion=(0, 0, self.pil_img.width, self.pil_img.height))
self.config_labels()
def forward(self, evt=None):
self.counter += 1
if self.counter == len(self.caption_path):
self.counter = 0
self.img_path = f"{self.image_path_base}{self.caption_path[self.counter][0]}"
self.caption_text = self.caption_path[self.counter][1]
new = Image.open(self.img_path)
self.tk_img = ImageTk.PhotoImage(new)
self.pil_img = new
self.fit_canvas_to_pic()
self.pic_canvas.image = self.tk_img
self.pic_canvas.config(
scrollregion=(0, 0, self.pil_img.width, self.pil_img.height))
self.config_labels()
def get_current_pix_data(self):
conn = sqlite3.connect(appwide_db_path)
cur = conn.cursor()
cur.execute("ATTACH ? AS tree", (self.current_tree,))
if self.current_nested_place:
cur.execute(select_all_images_nested_place, (self.current_nested_place,))
elif self.current_source:
cur.execute(select_all_images_source, (self.current_source,))
else:
cur.execute(select_all_images_person, (self.current_person_id,))
pix_data = cur.fetchall()
cur.close()
conn.close()
copy = list(pix_data)
pix_data = []
for pic in copy:
if not pic[0].startswith("0_default_image"):
pic_name = pic[0]
if not pic in pix_data:
pix_data.append(pic)
return pix_data
def fit_canvas_to_pic(self):
# don't show overly large images at their full size
FULL = 0.50
if self.maxwidth <= self.SCREEN_WIDTH * FULL:
gallery_wd = self.maxwidth
else:
gallery_wd = self.SCREEN_WIDTH * FULL
if self.maxheight <= self.SCREEN_HEIGHT * FULL:
gallery_ht = self.maxheight
else:
gallery_ht = self.SCREEN_HEIGHT * FULL
self.pic_canvas.config(
scrollregion=(0, 0, self.pil_img.width, self.pil_img.height),
width=gallery_wd,
height=gallery_ht)
# position image in canvas depending on image size
if (self.pil_img.width >= gallery_wd and
self.pil_img.height >= gallery_ht):
image = self.pic_canvas.create_image(
0, 0, anchor='nw', image=self.tk_img)
elif (self.pil_img.width <= gallery_wd and
self.pil_img.height >= gallery_ht):
image = self.pic_canvas.create_image(
self.pic_canvas.winfo_reqwidth()/2, 0,
anchor='n', image=self.tk_img)
elif (self.pil_img.width >= gallery_wd and
self.pil_img.height <= gallery_ht):
image = self.pic_canvas.create_image(
0, self.pic_canvas.winfo_reqheight()/2,
anchor='w', image=self.tk_img)
elif (self.pil_img.width <= gallery_wd and
self.pil_img.height <= gallery_ht):
image = self.pic_canvas.create_image(
self.pic_canvas.winfo_reqwidth()/2,
self.pic_canvas.winfo_reqheight()/2,
anchor='center',
image=self.tk_img)
def config_labels(self):
for widg in (self.caption_lab, self.picfile_lab, self.picsize_lab):
widg.config(state='normal')
widg.delete(1.0, 'end')
if self.default_image is False:
self.caption_lab.insert(1.0, self.caption_text)
self.picfile_lab.insert(1.0, self.img_path)
self.picsize_lab.insert(
1.0, 'width: {}, height: {}'.format(
self.pil_img.width, self.pil_img.height))
for widg in (self.caption_lab, self.picfile_lab, self.picsize_lab):
widg.set_height()
def set_main_pic(self, val):
""" Radiobutton command. """
if self.current_person_id:
select_query = select_current_person_id
unmain_query = update_media_links_unmain_image_person
main_query = update_media_links_main_image_person
elif self.current_nested_place:
select_query = select_current_nested_place_id
unmain_query = update_media_links_unmain_image_nested_place
main_query = update_media_links_main_image_nested_place
elif self.current_source:
select_query = select_current_source_id
unmain_query = update_media_links_unmain_image_source
main_query = update_media_links_main_image_source
conn = sqlite3.connect(self.current_tree)
conn.execute("PRAGMA foreign_keys = 1")
cur = conn.cursor()
cur.execute(select_query)
current_element = cur.fetchone()
cur.execute(unmain_query, current_element)
conn.commit()
cur.execute(main_query, (val,))
conn.commit()
if self.current_person_id:
self.main.show_top_pic(cur)
elif self.current_nested_place:
self.main.show_top_pic_nested_place(cur)
elif self.current_source:
self.main.show_top_pic_source(cur)
cur.close()
conn.close()