Редактор изображений. Обновление изображения на холсте. Неверно работает scrollbar

from tkinter import *
from tkinter import filedialog as fd
from PIL import Image, ImageTk, ImageOps, ImageFilter
from tkinter.ttk import Notebook
import os
from tkinter import messagebox as mb
import shutil
import pyperclip
import json
import tkinter.font
from tkinter.colorchooser import *
from tkinter import simpledialog
import numpy as np
 
CONFIG_FILE = "config.json"
 
class ImageEditor:
    root = Tk()
    text_font = StringVar()
    text_size = IntVar()
    bold_text = StringVar()
    italic_text = StringVar()
    drawing_tool = StringVar()
 
    stroke_size = IntVar()
    fill_color = StringVar()
    stroke_color = StringVar()
 
    left_but = "up"
    x_pos = None
    y_pos = None
    x1_line_pt, x2_line_pt, y1_line_pt, y2_line_pt = None, None, None, None
 
    def __init__(self):
        #self.root = Tk()
        self.tabsIm = Notebook(self.root)
        self.openIm = []
       # image = ImageTk.PhotoImage(image.open("C:\\Users\\Ruslan\\PycharmProjects\\Kurs\\resources\\doom.jpg"))
        #self.root.create_image(0,0,anchor=NW,image=image)
        #self.root.geometry("1280x720")
        self.select_1_x = 0
        self.select_1_y = 0
        self.select_2_x = 0
        self.select_2_y = 0
 
        self.canvas_select = None
        self.rect_select = None
 
        self.text_font.set("Times")
        self.text_size.set(20)
        self.bold_text.set('normal')
        self.italic_text.set('roman')
        self.drawing_tool.set("pencil")
        self.stroke_size.set(3)
        self.fill_color.set('#000000')
        self.stroke_color.set('#000000')
 
        self.init()
 
    def wind_(self):
        self.root.geometry("1280x720+300+150")
 
    def init(self):
        self.root.title("Image Editor")
        self.root.iconphoto(True, PhotoImage(file="resources/icon.png"))
        self.root.bind("<Escape>", self._close)
        self.tabsIm.enable_traversal()
        self.root.protocol("WM_DELETE_WINDOW", self._close)
 
        if not os.path.exists(CONFIG_FILE):
            with open(CONFIG_FILE, 'w') as f:
                json.dump({"openIm": []}, f)
        else:
            self.load_im_conf()
 
    def run(self):
        self.drawmenu()
        self.drawwidg()
        self.wind_()
        self.root.mainloop()
 
    def drawmenu(self):
        menubar = Menu(self.root)
        filemenu = Menu(menubar, tearoff=0)
        filemenu.add_command(label="Open", command=self.open_new_images)
        filemenu.add_command(label="Save", command=self.save_)
        filemenu.add_command(label="Save as", command=self.save_image_as)
        filemenu.add_command(label="Save all", command=self.save_all)
        filemenu.add_separator()
        filemenu.add_command(label="Close image", command=self.close_image)
        filemenu.add_separator()
        filemenu.add_command(label="Delete image", command=self.delete_image)
        filemenu.add_command(label="Move Image", command=self.moveimage)
        filemenu.add_separator()
 
        filemenu.add_command(label="Exit", command=self._close)
        menubar.add_cascade(label="File", menu=filemenu)
 
        editmenu = Menu(menubar, tearoff=0)
 
        transmenu = Menu(editmenu, tearoff=0)
 
        rotatemenu = Menu(transmenu, tearoff=0)
        rotatemenu.add_command(label="Rotate left by 90", command=lambda: self.rotate(90))
        rotatemenu.add_command(label="Rotate right by 90", command=lambda: self.rotate(-90))
        rotatemenu.add_command(label="Rotate left by 180", command=lambda: self.rotate(180))
        rotatemenu.add_command(label="Rotate right by 180", command=lambda: self.rotate(-180))
        transmenu.add_cascade(label="Rotate", menu=rotatemenu)
 
        flipmenu = Menu(editmenu, tearoff=0)
        flipmenu.add_command(label="Flip Horizontally", command=lambda: self.flip_("Horizontally"))
        flipmenu.add_command(label="Flip Vertically", command=lambda: self.flip_("Vertically"))
 
        resizemenu = Menu(editmenu, tearoff=0)
        resizemenu.add_command(label="Enlarge", command=self.enlarge_image)
        resizemenu.add_command(label="Reduce", command=self.reduce_image)
        resizemenu.add_command(label="Normal Size", command=self.normal_size)
 
        filtermenu = Menu(editmenu, tearoff=0)
        filtermenu.add_command(label="Blur", command=lambda: self.filter_(ImageFilter.BLUR))
        filtermenu.add_command(label="Sharpen", command=lambda: self.filter_(ImageFilter.SHARPEN))
        filtermenu.add_command(label="Contour", command=lambda: self.filter_(ImageFilter.CONTOUR))
        filtermenu.add_command(label="Detail", command=lambda: self.filter_(ImageFilter.DETAIL))
        filtermenu.add_command(label="Smooth", command=lambda: self.filter_(ImageFilter.SMOOTH))
        filtermenu.add_command(label="Find Edges", command=lambda: self.filter_(ImageFilter.FIND_EDGES))
        filtermenu.add_command(label="Emboss", command=lambda: self.filter_(ImageFilter.EMBOSS))
 
        croppmenu = Menu(editmenu, tearoff=0)
        croppmenu.add_command(label="Start selection", command=self.startselect)
        croppmenu.add_command(label="Stop selection", command=self.stopselect)
 
        draw_menu = Menu(editmenu, tearoff=0)
        draw_menu.add_command(label="Start draw", command=self.painting)
        draw_menu.add_command(label="Stop draw", command=self.stop_painting)
 
        draw1_menu = Menu(editmenu, tearoff=0)
 
        tool_menu = Menu(draw1_menu, tearoff=0)
        tool_menu.add_radiobutton(label="Pencil", variable=self.drawing_tool, value="pencil")
        tool_menu.add_radiobutton(label="Arc", variable=self.drawing_tool, value="arc")
        tool_menu.add_radiobutton(label="Line", variable=self.drawing_tool, value="line")
        tool_menu.add_radiobutton(label="Oval", variable=self.drawing_tool, value="oval")
        tool_menu.add_radiobutton(label="Rectangle", variable=self.drawing_tool, value="rectangle")
        tool_menu.add_radiobutton(label="Text", variable=self.drawing_tool, value="text")
        draw1_menu.add_cascade(label="Tool", menu=tool_menu)
 
        color_menu = Menu(draw1_menu, tearoff=0)
        color_menu.add_command(label="Fill", command=self.pick_fill)
        color_menu.add_command(label="Stroke", command=self.pick_stroke)
        draw1_menu.add_cascade(label="Color", menu=color_menu)
 
        strokesize_menu = Menu(color_menu, tearoff=0)
        strokesize_menu.add_radiobutton(label="2", variable=self.stroke_size, value=2)
        strokesize_menu.add_radiobutton(label="3", variable=self.stroke_size, value=3)
        strokesize_menu.add_radiobutton(label="4", variable=self.stroke_size, value=4)
        strokesize_menu.add_radiobutton(label="5", variable=self.stroke_size, value=5)
        color_menu.add_cascade(label="Stroke Size", menu=strokesize_menu)
 
        font_menu = Menu(draw1_menu, tearoff=0)
        font_menu.add_checkbutton(label="Bold", variable=self.bold_text, onvalue='bold', offvalue='normal')
        font_menu.add_checkbutton(label="Italic", variable=self.italic_text, onvalue='italic', offvalue='roman')
        draw1_menu.add_cascade(label="Font", menu=font_menu)
 
        fonttype_menu = Menu(font_menu, tearoff=0)
        fonttype_menu.add_radiobutton(label="Times", variable=self.text_font)
        fonttype_menu.add_radiobutton(label="Courier", variable=self.text_font)
        fonttype_menu.add_radiobutton(label="Ariel", variable=self.text_font)
        font_menu.add_cascade(label="Font Type", menu=fonttype_menu)
 
        fontsize_menu = Menu(font_menu, tearoff=0)
        fontsize_menu.add_radiobutton(label="10", variable=self.text_size, value=10)
        fontsize_menu.add_radiobutton(label="15", variable=self.text_size, value=15)
        fontsize_menu.add_radiobutton(label="20", variable=self.text_size, value=20)
        fontsize_menu.add_radiobutton(label="25", variable=self.text_size, value=25)
        font_menu.add_cascade(label="Font Size", menu=fontsize_menu)
 
        editmenu.add_cascade(label="Transform", menu=transmenu)
        editmenu.add_cascade(label="Flip", menu=flipmenu)
        editmenu.add_cascade(label="Resize", menu=resizemenu)
        editmenu.add_cascade(label="Filter", menu=filtermenu)
        editmenu.add_cascade(label="Crop", menu=croppmenu)
        editmenu.add_cascade(label="Draw", menu=draw_menu)
        editmenu.add_cascade(label="Draw1", menu=draw1_menu)
        menubar.add_cascade(label="Edit", menu=editmenu)
 
        about_menu = Menu(menubar, tearoff=0)
        about_menu.add_command(label="About", command=self.show_info)
        menubar.add_cascade(label="About", menu=about_menu, command=self.show_info)
 
        self.root.configure(menu=menubar)
 
    def drawwidg(self):
        self.tabsIm.pack(fill="both", expand=1)
 
    def painting(self):
        c_tab, path, image = self.work_now()
        if not c_tab:
            return
        tab4frame = self.tabsIm.children[c_tab[c_tab.rfind('!'):]]
        canvas = tab4frame.children['!canvas']
        self.canvass = canvas
        self.canvass.bind("<Motion>", self.motion)
        self.canvass.bind("<ButtonPress-1>", self.left_but_down)
        self.canvass.bind("<ButtonRelease-1>", self.left_but_up)
 
        #self.update_inside_app(c_tab, image)
 
    def stop_painting(self):
        c_tab, path, image = self.work_now()
        if not c_tab:
            return
        tab4frame = self.tabsIm.children[c_tab[c_tab.rfind('!'):]]
        canvas = tab4frame.children['!canvas']
        #image = image.close()
        #canvas.itemconfig(image, img1)
        self.canvass.unbind("<Motion>")
        self.canvass.unbind("<ButtonPress-1>")
        self.canvass.unbind("<ButtonRelease-1>")
        self.canvass.update()
        self.update_inside_app(c_tab, image)
 
    def left_but_down(self, event=None):
        self.left_but = "down"
        self.x1_line_pt = event.x
        self.y1_line_pt = event.y
 
    def left_but_up(self, event=None):
        self.left_but = "up"
        self.x_pos = None
        self.y_pos = None
        self.x2_line_pt = event.x
        self.y2_line_pt = event.y
 
        if self.drawing_tool.get() == "line":
            self.line_draw(event)
        elif self.drawing_tool.get() == "arc":
            self.arc_draw(event)
        elif self.drawing_tool.get() == "oval":
            self.oval_draw(event)
        elif self.drawing_tool.get() == "rectangle":
            self.rectangle_draw(event)
        elif self.drawing_tool.get() == "text":
            self.text_draw(event)
 
    def motion(self, event=None):
        if self.drawing_tool.get() == "pencil":
            self.pencil_draw(event)
 
    def pencil_draw(self, event=None):
        if self.left_but == "down":
            if self.x_pos is not None and self.y_pos is not None:
                self.canvass.create_line(self.x_pos, self.y_pos, event.x, event.y, smooth=TRUE,
                                         fill=self.stroke_color.get(), width=self.stroke_size.get())
            self.x_pos = event.x
            self.y_pos = event.y
 
    def line_draw(self, event=None):
        if None not in (self.x1_line_pt, self.x2_line_pt, self.y1_line_pt, self.y2_line_pt):
            self.canvass.create_line(self.x1_line_pt, self.y1_line_pt, self.x2_line_pt,
                                     self.y2_line_pt, smooth=TRUE, fill=self.stroke_color.get())
 
    def arc_draw(self, event=None):
        if None not in (self.x1_line_pt, self.x2_line_pt, self.y1_line_pt, self.y2_line_pt):
            coords = self.x1_line_pt, self.y1_line_pt, self.x2_line_pt, self.y2_line_pt
            self.canvass.create_arc(coords, start=0, extent=150, style=ARC, fill=self.stroke_color.get())
 
    def oval_draw(self, event=None):
        if None not in (self.x1_line_pt, self.x2_line_pt, self.y1_line_pt, self.y2_line_pt):
            self.canvass.create_oval(self.x1_line_pt, self.x2_line_pt, self.y1_line_pt, self.y2_line_pt,
                                     fill=self.fill_color.get(), outline=self.stroke_color.get(),
                                     width=self.stroke_size.get())
 
    def rectangle_draw(self, event=None):
        if None not in (self.x1_line_pt, self.x2_line_pt, self.y1_line_pt, self.y2_line_pt):
            self.canvass.create_rectangle(self.x1_line_pt, self.x2_line_pt, self.y1_line_pt, self.y2_line_pt,
                                     fill=self.fill_color.get(), outline=self.stroke_color.get(),
                                     width=self.stroke_size.get())
 
    def text_draw(self, event=None):
        if None not in (self.x1_line_pt, self.y1_line_pt):
            text_font = tkinter.font.Font(family=self.text_font.get(),
                                          size=self.text_size.get(),
                                          weight=self.bold_text.get(),
                                          slant=self.italic_text.get())
            user_text = simpledialog.askstring("Input", "Enter Text", parent=self.root)
            if user_text is not None:
                self.canvass.create_text(self.x1_line_pt, self.y1_line_pt, fill=self.fill_color.get(),
                                         font=text_font, text=user_text)
 
    def pick_fill(self, event=None):
        fill_color = askcolor(title='Pick fill color')
        if None not in fill_color:
            self.fill_color.set(fill_color[1])
            print("Fill Color", self.fill_color.get())
 
    def pick_stroke(self, event=None):
        stroke_color = askcolor(title='Pick Stroke color')
        if None not in stroke_color:
            self.stroke_color.set(stroke_color[1])
            print("Stroke Color", self.stroke_color.get())
 
    def load_im_conf(self):
        with open(CONFIG_FILE, 'r') as f:
            config = json.load(f)
 
        paths = config["openIm"]
        for path in paths:
            self.add_new_image(path)
 
    def open_new_images(self):
        Impaths = fd.askopenfilenames(filetypes=(("Images", "*.jpeg;*.png;*.jpg "), ))
        for Impath in Impaths:
            self.add_new_image(Impath)
 
    def add_new_image(self, Impath):
        image = Image.open(Impath)
        Imtk = ImageTk.PhotoImage(image)
        self.openIm.append([Impath, image])
        Imtab = Frame(self.tabsIm)
 
        self.canvaspanel = Canvas(Imtab, width=Imtk.width(), height=Imtk.height(), bd=0, highlightthickness=0
                             )
        self.canvaspanel.image = Imtk
        self.canvaspanel.create_image(0, 0, image=Imtk, anchor=NW)
        self.canvaspanel.grid(row=0, column=0)
        self.canvaspanel.pack(expand=TRUE, fill=BOTH)
        scrollv = Scrollbar(self.canvaspanel, orient=VERTICAL)
        scrollv.pack(side=RIGHT, fill=Y)
        scrollv.config(command=self.canvaspanel.yview)
        self.canvaspanel.config(yscrollcommand=scrollv.set, scrollregion=(0, 0,Imtk.width()+1200, Imtk.height()+1200))
        scrollh = Scrollbar(self.canvaspanel, orient=HORIZONTAL)
        scrollh.pack(side=BOTTOM, fill=X)
        scrollh.config(command=self.canvaspanel.xview)
        self.canvaspanel.config(xscrollcommand=scrollh.set)
        self.tabsIm.add(Imtab, text=Impath.split('/')[-1])
        self.tabsIm.select(Imtab)
        self.newimager = image.size
        self.canvaspanel.bind("<MouseWheel>", self._on_mousewheel)
        self.canvaspanel.bind("<Shift-MouseWheel>", self._on_mousewheel1)
        #self.canvaspanel.bind("<Control-MouseWheel>", self.reduce_image)
        # self.canvaspanel.bind("<Control-MouseWheel>", self.enlarge_image)
 
    def _on_mousewheel(self, event):
        self.canvaspanel.yview_scroll(int(-1 * (event.delta / 120)), "units")
 
    def _on_mousewheel1(self, event):
        self.canvaspanel.xview_scroll(int(-1 * (event.delta / 120)), "units")
 
    def work_now(self):
        c_tab = self.tabsIm.select()
        if not c_tab:
            return None, None, None  # tab image path
        numtab = self.tabsIm.index(c_tab)
        path, image = self.openIm[numtab]
        return c_tab, path, image
 
    def save_(self):
        c_tab, path, image = self.work_now()
        if not c_tab:
            return
        numtab = self.tabsIm.index(c_tab)
        if path[-1] == '*':
            path = path[:-1]
            self.openIm[numtab][0] = path
            image.save(path)
            self.tabsIm.add(c_tab, text=path.split('/')[-1])
 
    def save_all(self):
        for i, (path, image) in enumerate(self.openIm):
            if path[-1] != '*':
                continue
            path = path[:-1]
            self.openIm[i][0] = path
            image.save(path)
            self.tabsIm.tab(i, text=path.split('/')[-1])
 
    def close_image(self):
        pass
 
    def delete_image(self):
        pass
 
    def save_image_as(self):
        c_tab, path, image = self.work_now()
        if not c_tab:
            return
        numtab = self.tabsIm.index(c_tab)
        oldp, oldexten = os.path.splitext(path)
        if oldexten[-1] == '*':
            oldexten = oldexten[:-1]
        newp = fd.asksaveasfilename(initialdir=oldp, filetypes=(("Images", "*.jpeg;*.png;*.jpg "), ))
        if not newp:
            return
        newp, newexten = os.path.splitext(newp)
        if not newexten:
            newexten = oldexten
        elif oldexten != newexten:
            mb.showerror("Неправильно расширение", f"Получили неправильное расширение: {newexten}. Старое: {oldexten}")
            return
 
        image.save(newp + newexten)
        image.close()
        del self.openIm[numtab]
        self.tabsIm.forget(c_tab)
        self.add_new_image(newp + newexten)
 
    def moveimage(self):
        pass
 
    def rotate(self, degrees):
        pass
 
    def flip_(self, flip_type):
        pass
 
    def enlarge_image(self):
        pass
 
    def reduce_image(self):
       pass
 
    def normal_size(self):
        pass
 
    def filter_(self, filter_type):
       pass
 
    def croppim(self):
        c_tab, path, image = self.work_now()
        if not c_tab:
            return
 
        image = image.crop((self.select_1_x, self.select_1_y, self.select_2_x,
                           self.select_2_y))
        self.update_inside_app(c_tab, image)
 
    def startselect(self):
        c_tab = self.tabsIm.select()
        if not c_tab:
            return
        tab4frame = self.tabsIm.children[c_tab[c_tab.rfind('!'):]]
        canvas = tab4frame.children['!canvas']
 
        self.canvas_select = canvas
        self.rect_select = canvas.create_rectangle(self.select_1_x, self.select_1_y, self.select_2_x, self.select_2_y,
        dash=(10, 10), fill='', outline='red', width=2)
        canvas.bind("<Button-1>", self.firstposition)
        canvas.bind("<B1-Motion>", self.secondposition)
 
    def firstposition(self, event):
        self.select_1_x, self.select_1_y = event.x, event.y
 
    def secondposition(self, event):
        self.select_2_x, self.select_2_y = event.x, event.y
        if self.canvas_select is not None and self.rect_select is not None:
            self.canvas_select.coords(self.rect_select, self.select_1_x,
                                             self.select_1_y, self.select_2_x, self.select_2_y)
 
    def stopselect(self):
        self.canvas_select.unbind("<Button-1>")
        self.canvas_select.unbind("<B1-Motion>")
 
        self.canvas_select.delete(self.rect_select)
 
        self.croppim()
 
        self.rect_select = None
        self.canvas_select = None
        self.select_1_x, self.select_1_y = 0, 0
        self.select_2_x, self.select_2_y = 0, 0
 
    def update_inside_app(self, c_tab, image):
        numtab = self.tabsIm.index(c_tab)
        tab4frame = self.tabsIm.children[c_tab[c_tab.rfind('!'):]]
        canvas = tab4frame.children['!canvas']
        self.openIm[numtab][1] = image
 
        Imtk = ImageTk.PhotoImage(image)
 
        canvas.delete("all")
        canvas.image = Imtk
        canvas.configure(width=Imtk.width(), height=Imtk.height())
        canvas.create_image(0, 0, image=Imtk, anchor="nw")
 
        Impath = self.openIm[numtab][0]
        if Impath[-1] != '*':
            Impath += '*'
            self.openIm[numtab][0] = Impath
            Imname = Impath.split('/')[-1]
            self.tabsIm.tab(c_tab, text=Imname)
 
    def saveIminconf(self):
        paths = [(path[:-1] if path[-1] == '*' else path) for (path, image) in self.openIm]
        images = {"openIm": paths}
        with open(CONFIG_FILE, 'w') as f:
            json.dump(images, f, indent=4)
 
    def unsaved_images(self):
        for path, _ in self.openIm:
            if path[-1] == "*":
                return True
        return False
 
    def show_info(self):
 
        mb.showinfo("About Image Viewer",
                          "Это фоторедактор простой!")
 
    def _close(self, event=None):
        if self.unsaved_images():
            if not mb.askokcancel("Exit", "Are u sure about this?"):
                return
        self.saveIminconf()
        self.root.quit()
 
if __name__ == "__main__":
    ImageEditor().run()