使用Python编写截图轻量化工具

import ctypes
import tkinter as tk
from tkinter import messagebox, filedialog
from pil import imagegrab, imagetk
 
 
scalefactor = ctypes.windll.shcore.getscalefactorfordevice(0)
ctypes.windll.shcore.setprocessdpiawareness(1)
 
 
 
class flatbutton(tk.label):
    def __init__(
            self, parent, command, enter_fg="#000000", 
            click_color="#25c253", *args, **kwargs
        ):
        super().__init__(parent, *args, **kwargs)
        self.__fg = fg = kwargs.get("fg", "#474747")
        self.__enter_fg = enter_fg
        self.__click_fg = click_color
        self.command = command
        self.config(cursor="hand2")
        self.bind("<enter>", lambda _: self.config(fg=enter_fg))
        self.bind("<leave>", lambda _: self.config(fg=fg))
        self.bind("<button-1>", lambda _: self.config(fg=click_color))
        self.bind("<buttonrelease-1>", self.__command)
        if fg == enter_fg:
            raise valueerror("enter_fg must be different from fg")
 
    def __command(self, event):
        try:
            if self.cget("fg") in (self.__enter_fg, self.__click_fg):
                self.command(event)
            self.config(fg=self.__fg)
        except tk.tclerror:
            # button have been destroy.
            pass
 
 
 
class adjustablerect(object):
    """
    the judgement seq is so important that you must care about:
    (right, bottom), (left, top), (right, top), (left, bottom),
    (center_x, top), (center_x, bottom), (left, center_y, ), (right, center_y)
    """
    anchor_size = 3
    anchor_hover_distance = 20
    cursor_files_name = ["aero_nwse_l.cur", "aero_nesw_l.cur", "aero_ns_l.cur", "aero_ew_l.cur"]
    cursor_files = [f"@c:/windows/cursors/{cursor_file}" for cursor_file in cursor_files_name]
    cursors = [
        cursor_files[0], cursor_files[0], cursor_files[1], cursor_files[1],
        cursor_files[2], cursor_files[2], cursor_files[3], cursor_files[3],
        "fleur", "arrow"
    ]
 
    def __init__(self, parent, screenshot):
        self.parent: tk.canvas = parent
        self.screenshot: screenshotutils = screenshot
        self.__rect: int = 0
        self.__anchors: list[int] = []
        self.anchor_id: int = 0
 
    def rect_coords(self) -> tuple[int, int, int, int]:
        try:
            return self.parent.coords(self.__rect)
        except tk.tclerror:
            return [
                min(self.screenshot.start_x, self.screenshot.end_x),
                min(self.screenshot.start_y, self.screenshot.end_y),
                max(self.screenshot.start_x, self.screenshot.end_x),
                max(self.screenshot.start_y, self.screenshot.end_y)
            ]
    
    def anchor_coords(self) -> tuple[int, int, int, int]:
        left, top, right, bottom = self.rect_coords()
        horizontal_middle = (left + right) // 2
        vertical_middle = (top + bottom) // 2
        return (
            (left, top), (horizontal_middle, top), (right, top), (right, vertical_middle),
            (right, bottom), (horizontal_middle, bottom), (left, bottom), (left, vertical_middle)
        )
    
    def get_anchor(self, event) -> int:
        cls = self.__class__
        left, top, right, bottom = self.rect_coords()
        center_x, center_y = (left + right) // 2, (top + bottom) // 2
        def near(actual, target):
            return abs(actual - target) < cls.anchor_hover_distance
        # 务必注意这个判断顺序，这与后面rect_adjust密切相关
        judgement_pos = (
            (right, bottom), (left, top), (right, top), (left, bottom),
            (center_x, top), (center_x, bottom), (left, center_y, ), (right, center_y)
        )
        for index, pos in enumerate(judgement_pos):
            if near(event.x, pos[0]) and near(event.y, pos[1]):
                return index
        if left < event.x < right and top < event.y < bottom:
            return 8
        return -1
 
    def create_anchors(self):
        cls = self.__class__
        for coord in self.anchor_coords():
            anchor = self.parent.create_rectangle(
                coord[0]-cls.anchor_size, coord[1]-cls.anchor_size,
                coord[0]+cls.anchor_size, coord[1]+cls.anchor_size,
                fill="#1aae1a", outline="#1aae1a"
            )
            self.__anchors.append(anchor)
    
    def move_anchors(self):
        cls = self.__class__
        for anchor, coord in zip(self.__anchors, self.anchor_coords()):
            self.parent.coords(
                anchor, coord[0]-cls.anchor_size, coord[1]-2, 
                coord[0]+cls.anchor_size, coord[1]+cls.anchor_size
            )
 
    def on_press(self, event):
        self.screenshot.start_x = event.x
        self.screenshot.start_y = event.y
        self.__rect= self.parent.create_rectangle(self.screenshot.start_x, self.screenshot.start_y, self.screenshot.start_x, self.screenshot.start_y, outline='#1aae1a', width=2)
        self.create_anchors()
 
    def on_release(self, _):
        self.screenshot.start_x, self.screenshot.start_y,\
        self.screenshot.end_x, self.screenshot.end_y = self.rect_coords()
 
    def on_hover(self, event):
        self.anchor_id = self.get_anchor(event)
        cursor = self.cursors[self.anchor_id]
        self.parent.config(cursor=cursor)
 
    def move_rect(self, event):
        offset_x = event.x - self.screenshot.move_start_x
        offset_y = event.y - self.screenshot.move_start_y
        self.screenshot.start_x += offset_x
        self.screenshot.start_y += offset_y
        self.screenshot.end_x += offset_x
        self.screenshot.end_y += offset_y
        self.screenshot.move_start_x = event.x
        self.screenshot.move_start_y = event.y
        self.parent.coords(self.__rect, self.screenshot.start_x, self.screenshot.start_y, self.screenshot.end_x, self.screenshot.end_y)
        self.move_anchors()
 
    def rect_adjust(self, event):
        if self.anchor_id == 8:
            return self.move_rect(event)
        if self.anchor_id == 0:
            self.screenshot.end_x, self.screenshot.end_y = event.x, event.y
        elif self.anchor_id == 1:
            self.screenshot.start_x, self.screenshot.start_y = event.x, event.y
        elif self.anchor_id == 2:
            self.screenshot.end_x, self.screenshot.start_y = event.x, event.y
        elif self.anchor_id == 3:
            self.screenshot.start_x, self.screenshot.end_y = event.x, event.y
        elif self.anchor_id == 4:
            self.screenshot.start_y = event.y
        elif self.anchor_id == 5:
            self.screenshot.end_y = event.y
        elif self.anchor_id == 6:
            self.screenshot.start_x = event.x
        elif self.anchor_id == 7:
            self.screenshot.end_x = event.x
        else:
            return
        self.parent.coords(self.__rect, self.screenshot.start_x, self.screenshot.start_y, self.screenshot.end_x, self.screenshot.end_y)
        self.move_anchors()
 
    
 
    
 
class screenshotutils(object):
    """
    截图的关键是坐标；这个类管理着图片的引用和截图坐标；
    """
    def tks(value) -> int:
        return int(scalefactor/100*value)
    
    zoom: int = 4
    zoom_width: float = tks(28.75)
    zoom_screen_size: int = int(zoom_width*zoom)
    magnifier_offset: int = 36
    ajust_bar_width: int = tks(100)
 
    # 截图相关变量
    def __init__(self):
        self.start_x = self.start_y = self.end_x = self.end_y = 0
        self.move_start_x = self.move_start_y = self.move_end_x = self.move_end_y = 0
        self.current_image = none
        self.pixel_reader = none
        self.final_images = list()
        # 这种是只移动但不改变大小和内容的控件，只需移动无需重绘
        self.screenshot_move_widget = list()
        # 这种是移动和改变大小的控件，需要实时重绘
        self.screenshot_redraw_widget = list()
 
    @staticmethod
    def tks(value) -> int:
        return int(scalefactor/100*value)
    
    @classmethod
    def move_widget_coords(cls, x, y) -> list[tuple[int, int, int, int]]:
        # 按照主框架，水平线，垂直线的顺序返回坐标
        magnifier_x = x+cls.magnifier_offset
        magnifier_y = y+cls.magnifier_offset
        main_frame_coord  = (
            magnifier_x, magnifier_y,
            magnifier_x+cls.zoom_screen_size,
            magnifier_y+cls.zoom_screen_size 
        )
        horrontal_line_coord = (
            magnifier_x, magnifier_y+cls.zoom_screen_size // 2,
            magnifier_x+cls.zoom_screen_size,
            magnifier_y+cls.zoom_screen_size // 2 
        )
        vertical_line_coord = (
            magnifier_x+cls.zoom_screen_size // 2, magnifier_y,
            magnifier_x+cls.zoom_screen_size // 2,
            magnifier_y+cls.zoom_screen_size 
        )
        coords = [main_frame_coord, horrontal_line_coord, vertical_line_coord]
        return coords
 
    def redraw_widget_coords(self, x, y) -> list[tuple]:
        # 按照"长 × 宽"、"放大镜图像"、"pos标签"、"rgb标签"的顺序返回坐标
        offset = self.__class__.magnifier_offset
        width_height_info = (min(self.start_x, self.end_x), min(self.start_y, self.end_y) - 40)
        magnifier_coord = (x + offset, y + offset)
        pos_info = (x + offset, y + offset+self.__class__.zoom_screen_size + 10)
        rgb_info = (x + offset, y + offset+self.__class__.zoom_screen_size + 47)
        coords = [width_height_info, magnifier_coord, pos_info, rgb_info]
        return coords
 
 
 
class mainui(tk.tk):
    def __init__(self):
        super().__init__()
        self.screenshot = screenshotutils()
        self.set_window()
        self.menu_bar: tk.frame = self.set_menubar()
        self.cut_btn: tk.label = self.set_cut_btn()
        self.save_btn: tk.label = self.set_save_btn()
        self.turn_left_btn: tk.label = self.set_turn_left_btn()
        self.turn_right_btn: tk.label = self.set_turn_right_btn()
        self.show_image_canvas: tk.canvas = self.set_show_image_canvas()
        self.adjust_rect: adjustablerect = none
        self.pos_label: tk.label = none
        self.rgb_label: tk.label = none
        self.adjust_bar: tk.frame = none
 
    def set_window(self):
        self.title("截图工具")
        self.geometry(f"{self.screenshot.tks(240)}x{self.screenshot.tks(30)}")
 
    def set_menubar(self) -> tk.frame:
        menubar = tk.frame(self, bg="#ffffff", height=30)
        menubar.pack(fill=tk.x)
        return menubar
 
    def set_cut_btn(self) -> tk.label:
        btn_cut = flatbutton(
            self.menu_bar, self.start_capture, text="✂", 
            bg="#ffffff", font=("segoe ui emoji", 18),
        )
        btn_cut.pack(side=tk.left, padx=5)
        return btn_cut
    
    def set_save_btn(self) -> tk.label:
        btn_save = flatbutton(
            self.menu_bar, self.save_image, text="💾", 
            bg="#ffffff", font=("segoe ui emoji", 18),
        )
        btn_save.pack(side=tk.left, padx=5)
        return btn_save
    
    def set_turn_left_btn(self) -> tk.label:
        turn_left_btn = flatbutton(
            self.menu_bar, self.turn_page, text="\u25c0", 
            bg="#ffffff", font=("segoe ui emoji", 18),
        )
        turn_left_btn.pack(side=tk.left, padx=5)
        return turn_left_btn
 
    def set_turn_right_btn(self) -> tk.label:
        turn_page_btn = flatbutton(
            self.menu_bar, self.turn_page, text="\u25b6", 
            bg="#ffffff", font=("segoe ui emoji", 18),
        )
        turn_page_btn.pack(side=tk.left, padx=5)
        return turn_page_btn
 
    def set_cancel_btn(self, parent) -> tk.label:
        cancel_btn = flatbutton(
            parent, self.clear_capture_info, text="×", bg="#ffffff",
            enter_fg="#db1a21",fg="#cc181f", font=("微软雅黑", 18)
        )
        cancel_btn.pack(side=tk.right, padx=5)
        return cancel_btn
 
    def set_confirm_btn(self, parent) -> tk.label:
        confirm_btn = flatbutton(
            parent, self.confirm_capture, fg="#23b34c", text="√",
            enter_fg="#27c956", bg="#ffffff", font=("微软雅黑", 18)
        )
        return confirm_btn
 
    def set_show_image_canvas(self) -> tk.canvas:
        canvas = tk.canvas(self, bg="white")
        return canvas
    
    def set_adjust_bar(self) -> tk.frame:
        self.adjust_bar = tk.frame(self.full_screenshot_canvas, bg="#ffffff", height=50)
        cancel_btn = self.set_cancel_btn(self.adjust_bar)
        confirm_btn = self.set_confirm_btn(self.adjust_bar)
        cancel_btn.pack(side=tk.right, padx=5)
        confirm_btn.pack(side=tk.right, padx=10)
    
    def set_magnifier_frame(self, event) -> none:
        initial_coord = (0, 0, 0, 0)
        main_frame_id = self.full_screenshot_canvas.create_rectangle(*initial_coord, outline='#1aae1a', width=1)
        horrontal_line = self.full_screenshot_canvas.create_line(*initial_coord, fill="#1aae1a", width=2)
        vertical_line = self.full_screenshot_canvas.create_line(*initial_coord, fill="#1aae1a", width=2)
        self.screenshot.screenshot_move_widget = [main_frame_id, horrontal_line, vertical_line]
        event.x = event.x + event.widget.winfo_rootx()
        event.y = event.y + event.widget.winfo_rooty()
        self.update_magnifier(event)
 
    def set_full_screenshot_canvas(self, parent) -> tk.canvas:
        img = imagegrab.grab()
        self.screenshot.current_image = img
        self.screenshot.pixel_reader = img.convert("rgb")
        photo = imagetk.photoimage(img)
        full_screenshot_canvas = tk.canvas(parent, bg="white")
        full_screenshot_canvas.create_image(0, 0, anchor=tk.nw, image=photo)
        full_screenshot_canvas.image = photo
        full_screenshot_canvas.pack(fill=tk.both, expand=true)
        return full_screenshot_canvas
    
    def set_pos_rgb_label(self, parent) -> tk.label:
        label = tk.label(parent, bg="#000000", font=("微软雅黑", 8), fg="#ffffff")
        return label
 
 
class screenshottool(mainui):
    def __init__(self):
        super().__init__()
        self.page_index = 0
 
    def start_capture(self, event):
        self.attributes('-alpha', 0)
        self.update()
        self.capture_win = tk.toplevel()
        self.capture_win.geometry(f"{self.winfo_screenwidth()}x{self.winfo_screenheight()}+0+0")
        self.capture_win.overrideredirect(true)
        self.full_screenshot_canvas = self.set_full_screenshot_canvas(self.capture_win)
        self.pos_label = self.set_pos_rgb_label(self.full_screenshot_canvas)
        self.rgb_label = self.set_pos_rgb_label(self.full_screenshot_canvas)
        self.adjust_rect = adjustablerect(self.full_screenshot_canvas, self.screenshot)
        self.set_magnifier_frame(event)
        self.set_adjust_bar()
        self.full_screenshot_canvas.bind("<button-1>", self.on_press)
        self.full_screenshot_canvas.bind("<motion>", self.update_magnifier)
        self.full_screenshot_canvas.bind("<buttonrelease-1>", self.on_release)
 
    def on_press(self, event):
        self.adjust_rect.on_press(event)
        self.full_screenshot_canvas.unbind("<motion>")
        self.full_screenshot_canvas.bind("<motion>", self.on_drag)
 
    def on_drag(self, event):
        self.adjust_rect.rect_adjust(event)
        self.update_magnifier(event)
 
    def on_release(self, event, resize=true):
        self.unbind_all()
        self.adjust_rect.on_release(event)
        self.full_screenshot_canvas.config(cursor=self.adjust_rect.cursor_files[0])
        self.full_screenshot_canvas.bind("<button-1>", self.start_move)
        self.full_screenshot_canvas.bind("<motion>", self.adjust_rect.on_hover)
        self.adjust_bar.place(x=self.screenshot.end_x - 300, y=self.screenshot.end_y + 10, width=300)
        if resize:
            self.screenshot.end_x, self.screenshot.end_y = event.x, event.y
 
    def unbind_all(self):
        events = ("<button-1>", "<motion>", "<buttonrelease-1>")
        for event in events:
            self.full_screenshot_canvas.unbind(event)
 
    def update_magnifier(self, event):
        x, y = event.x, event.y
        size = screenshotutils.zoom_width
        img = self.screenshot.current_image.crop((x - size//2, y - size//2, x + size//2, y + size//2))
        img = img.resize((screenshotutils.zoom_screen_size, screenshotutils.zoom_screen_size))
        photo = imagetk.photoimage(img)
        self.full_screenshot_canvas.image2 = photo
        w, h = abs(self.screenshot.end_x - self.screenshot.start_x), abs(self.screenshot.end_y - self.screenshot.start_y)
        for redraw_widget in self.screenshot.screenshot_redraw_widget:
            self.full_screenshot_canvas.delete(redraw_widget)
        self.screenshot.screenshot_redraw_widget.clear()
        redraw_widget_coords = self.screenshot.redraw_widget_coords(x, y)
        width_height_info, magnifier_coord, pos_info, rgb_info = redraw_widget_coords
        wh_info_widget = self.full_screenshot_canvas.create_text(*width_height_info, anchor=tk.nw, fill="white", text=f"{w} × {h}")
        zoom_img = self.full_screenshot_canvas.create_image(*magnifier_coord, anchor=tk.nw, image=photo)
        self.pos_label.config(text=f"pos: ({x}, {y})")
        self.rgb_label.config(text=f"rgb: {self.screenshot.pixel_reader.getpixel((x, y))}")
        self.pos_label.place(x=pos_info[0], y=pos_info[1])
        self.rgb_label.place(x=rgb_info[0], y=rgb_info[1])
        self.screenshot.screenshot_redraw_widget = [wh_info_widget, zoom_img]
        self.update_magnifier_frame(x, y)
 
    def update_magnifier_frame(self, x: int, y: int) -> none:
        coords = self.screenshot.move_widget_coords(x, y)
        for widget, coord in zip(self.screenshot.screenshot_move_widget, coords):
            self.full_screenshot_canvas.coords(widget, *coord)
            self.full_screenshot_canvas.tag_raise(widget)
 
    def start_move(self, event):
        self.screenshot.move_start_x = event.x
        self.screenshot.move_start_y = event.y
        self.adjust_bar.place_forget()
        self.pos_label.place_forget()
        self.rgb_label.place_forget()
        for widget in self.screenshot.screenshot_redraw_widget:
            self.full_screenshot_canvas.delete(widget)
        for widget in self.screenshot.screenshot_move_widget:
            self.full_screenshot_canvas.tag_lower(widget)
        self.full_screenshot_canvas.bind("<b1-motion>", self.adjust_rect.rect_adjust)
        self.full_screenshot_canvas.bind("<buttonrelease-1>", lambda e: self.on_release(e, false))
 
    def clear_capture_info(self, _):
        self.capture_win.destroy()
        self.full_screenshot_canvas.destroy()
        self.attributes('-alpha', 1)
        self.screenshot.screenshot_move_widget.clear()
 
    def confirm_capture(self, event):
        self.clear_capture_info(event)
        x1, y1, x2, y2 = self.adjust_rect.rect_coords()
        image = self.screenshot.current_image.crop((x1, y1, x2, y2))
        result = self.show_image(image)
        self.screenshot.final_images.append(result)
        self.page_index = len(self.screenshot.final_images) - 1
        self.attributes('-topmost', 1)
 
    def show_image(self, image):
        self.geometry(f"{max(image.width, screenshotutils.tks(240))}x{image.height+self.menu_bar.winfo_height()}")
        photo = imagetk.photoimage(image)
        self.show_image_canvas.config(width=image.width, height=image.height)
        self.show_image_canvas.delete("all")
        self.show_image_canvas.create_image(0, 0, anchor=tk.nw, image=photo)
        self.show_image_canvas.image = photo
        self.show_image_canvas.pack()
        return image
 
    def save_image(self, _):
        try:
            image = self.screenshot.final_images[self.page_index]
            filename = filedialog.asksaveasfilename(
                defaultextension=".png", 
                filetypes=[("png files", "*.png"), ("jpeg files", "*.jpg")],
                initialfile=f"{image.width}x{image.height}.png"
            )
            if not filename:
                return
            image.save(filename)
        except indexerror:
            messagebox.showerror("保存失败", "未检测到截取图像")
 
    def turn_page(self, event):
        if len(self.screenshot.final_images) == 0:
            return messagebox.showinfo("提示", "暂无图片可切换!")
        if event.widget == self.turn_left_btn:
            if self.page_index == 0:
                return messagebox.showinfo("提示", "已经是第一张图片!")
            self.page_index -= 1
        else:
            if self.page_index == len(self.screenshot.final_images) - 1:
                return messagebox.showinfo("提示", "已经是最后一张图片!")
            self.page_index += 1
        self.show_image(self.screenshot.final_images[self.page_index])
 
if __name__ == "__main__":
    app = screenshottool()
    app.mainloop()