Pythonで画像をドラッグ＆ドロップ！自動で角丸・透過PNGを作る方法

import tkinter as tk
from tkinter import ttk, filedialog, messagebox
from PIL import Image, ImageDraw, UnidentifiedImageError
import os
import sys

# tkinterdnd2 をインポート (フォールバック対応)
try:
    from tkinterdnd2 import DND_FILES, TkinterDnD
except ImportError:
    TkinterDnD = None
    print("tkinterdnd2ライブラリが見つかりません。ドラッグアンドドロップ機能は無効になります。", file=sys.stderr)
    print("インストールするには 'pip install tkinterdnd2' を実行してください。", file=sys.stderr)

# Pillow のリサンプリングフィルターをバージョン互換性考慮して設定
try:
    LANCZOS_RESAMPLE = Image.Resampling.LANCZOS
except AttributeError:
    try:
        LANCZOS_RESAMPLE = Image.LANCZOS
    except AttributeError:
        LANCZOS_RESAMPLE = Image.ANTIALIAS # 最悪ANTIALIASを使う


class AutoRoundedTransparentIconGenerator:
    def __init__(self, master_root):
        self.master = master_root
        self.master.title("Auto Rounded Transparent Icon Generator")
        self.master.geometry("580x820")

        self.style = ttk.Style()
        self.style.theme_use('clam')

        self.BG_COLOR = "white"
        self.PRIMARY_COLOR = "#00529B"
        self.SECONDARY_COLOR = "#0078D4"
        self.LIGHT_BLUE_BG = "#F0F8FF"
        self.TEXT_COLOR_ON_LIGHT_BG = self.PRIMARY_COLOR
        self.TEXT_COLOR_ON_DARK_BG = "white"
        self.BUTTON_ACTIVE_BG = "#003C75"
        self.DISABLED_FG_COLOR = "#A0A0A0"
        self.DISABLED_BG_COLOR = "#E0E0E0"
        self.ERROR_COLOR = "red"
        self.SUCCESS_COLOR = "green"
        self.WARNING_COLOR = "#E67E00"

        self.FONT_NORMAL = ("Segoe UI", 10)
        self.FONT_BOLD = ("Segoe UI Bold", 11)
        self.FONT_LARGE = ("Segoe UI", 14)
        self.FONT_TITLE = ("Segoe UI Semibold", 16)

        self.master.configure(bg=self.BG_COLOR)

        self.style.configure("TFrame", background=self.BG_COLOR)
        self.style.configure("TLabel", background=self.BG_COLOR, foreground=self.TEXT_COLOR_ON_LIGHT_BG, font=self.FONT_NORMAL)
        self.style.configure("TLabelframe", background=self.BG_COLOR, bordercolor=self.SECONDARY_COLOR)
        self.style.configure("TLabelframe.Label", background=self.BG_COLOR, foreground=self.PRIMARY_COLOR, font=self.FONT_BOLD)
        self.style.configure("TButton", background=self.SECONDARY_COLOR, foreground=self.TEXT_COLOR_ON_DARK_BG,
                             font=self.FONT_BOLD, padding=6, relief="raised", borderwidth=1, bordercolor=self.PRIMARY_COLOR)
        self.style.map("TButton", background=[('active', self.BUTTON_ACTIVE_BG), ('disabled', self.DISABLED_BG_COLOR)],
                       foreground=[('disabled', self.DISABLED_FG_COLOR)])
        self.style.configure("TEntry", fieldbackground="white", foreground=self.TEXT_COLOR_ON_LIGHT_BG, insertcolor=self.TEXT_COLOR_ON_LIGHT_BG,
                             bordercolor=self.SECONDARY_COLOR, font=self.FONT_NORMAL)
        self.style.map("TEntry", bordercolor=[('focus', self.PRIMARY_COLOR)], fieldbackground=[('readonly', "#F0F0F0")])
        self.style.configure("TCheckbutton", background=self.BG_COLOR, foreground=self.TEXT_COLOR_ON_LIGHT_BG, font=self.FONT_NORMAL)
        self.style.map("TCheckbutton",
                       indicatorcolor=[('selected', self.PRIMARY_COLOR), ('!selected', self.SECONDARY_COLOR)],
                       foreground=[('disabled', self.DISABLED_FG_COLOR)])
        self.style.configure("TRadiobutton", background=self.BG_COLOR, foreground=self.TEXT_COLOR_ON_LIGHT_BG, font=self.FONT_NORMAL)
        self.style.map("TRadiobutton",
                       indicatorcolor=[('selected', self.PRIMARY_COLOR), ('!selected', self.SECONDARY_COLOR)],
                       foreground=[('disabled', self.DISABLED_FG_COLOR)])


        self.input_path = tk.StringVar()
        self.output_path = tk.StringVar()
        self.radius_var = tk.IntVar(value=25)
        self.make_fully_round_var = tk.BooleanVar(value=False)
        self.no_rounding_var = tk.BooleanVar(value=False)

        self.MODES = {
            "mode1": {"label": "標準 (1MB目標, 512x512px)", "max_size_mb": 1, "max_dims": (512, 512)},
            "mode2": {"label": "高品質 (15MB目標, 1024x500px)", "max_size_mb": 15, "max_dims": (1024, 500)},
            "custom": {"label": "カスタム (サイズ/容量 制限なし)", "max_size_mb": float('inf'), "max_dims": (float('inf'), float('inf'))}
        }
        self.output_mode_var = tk.StringVar(value="mode1")

        self.dnd_enabled = TkinterDnD is not None

        main_frame = ttk.Frame(self.master, padding="10")
        main_frame.pack(expand=True, fill=tk.BOTH)

        title_label = ttk.Label(main_frame, text="画像変換・角丸ツール", font=self.FONT_TITLE, foreground=self.PRIMARY_COLOR)
        title_label.pack(pady=(10,15))

        drop_frame_container = tk.Frame(main_frame, bg=self.LIGHT_BLUE_BG,
                                        highlightbackground=self.PRIMARY_COLOR,
                                        highlightthickness=2, relief="solid",
                                        width=500, height=140)
        drop_frame_container.pack(pady=(0,10), padx=10, fill="x")
        drop_frame_container.pack_propagate(False)

        self.drop_label_text = tk.StringVar()
        drop_label_message = "ここに画像をドラッグ＆ドロップ" if self.dnd_enabled else "ドラッグ＆ドロップ無効"
        self.drop_label_text.set(drop_label_message + "\nまたは下から選択")

        drop_label = tk.Label(drop_frame_container, textvariable=self.drop_label_text,
                              font=self.FONT_LARGE, wraplength=480, justify="center",
                              bg=self.LIGHT_BLUE_BG, fg=self.TEXT_COLOR_ON_LIGHT_BG)
        drop_label.pack(expand=True, fill="both", padx=10, pady=10)

        if self.dnd_enabled:
            drop_label.drop_target_register(DND_FILES)
            drop_label.dnd_bind('<<Drop>>', self.handle_drop)
            drop_frame_container.drop_target_register(DND_FILES)
            drop_frame_container.dnd_bind('<<Drop>>', self.handle_drop)
        else:
            drop_label.config(text="D&D無効: tkinterdnd2未導入\n下からファイルを選択してください")

        settings_frame = ttk.Frame(main_frame)
        settings_frame.pack(pady=(5,0), padx=5, fill="x")

        input_outer_frame = ttk.Frame(settings_frame)
        input_outer_frame.pack(pady=(5,2), fill="x")
        ttk.Label(input_outer_frame, text="入力画像:").pack(side=tk.LEFT, padx=(0,5))
        self.input_entry = ttk.Entry(input_outer_frame, textvariable=self.input_path, width=45, state="readonly")
        self.input_entry.pack(side=tk.LEFT, expand=True, fill="x", ipady=2, padx=(0,5))
        ttk.Button(input_outer_frame, text="参照", command=self.select_input_file, width=6).pack(side=tk.LEFT)

        output_outer_frame = ttk.Frame(settings_frame)
        output_outer_frame.pack(pady=(2,5), fill="x")
        ttk.Label(output_outer_frame, text="出力先:  ").pack(side=tk.LEFT, padx=(0,5))
        self.output_entry = ttk.Entry(output_outer_frame, textvariable=self.output_path, width=45, state="readonly")
        self.output_entry.pack(side=tk.LEFT, expand=True, fill="x", ipady=2, padx=(0,5))
        ttk.Button(output_outer_frame, text="参照", command=self.select_output_file, width=6).pack(side=tk.LEFT)

        mode_options_frame = ttk.LabelFrame(main_frame, text="出力モード設定", padding="10")
        mode_options_frame.pack(pady=10, padx=10, fill="x")
        for mode_key, mode_props in self.MODES.items():
            rb = ttk.Radiobutton(mode_options_frame, text=mode_props["label"], variable=self.output_mode_var,
                                 value=mode_key, style="TRadiobutton", command=self.update_ui_states)
            rb.pack(anchor=tk.W, pady=2)

        self.radius_options_frame = ttk.LabelFrame(main_frame, text="角丸・形状設定", padding="10")
        self.radius_options_frame.pack(pady=10, padx=10, fill="x")

        self.no_rounding_check = ttk.Checkbutton(self.radius_options_frame, text="角丸処理をしない (元画像のまま出力)",
                                                 variable=self.no_rounding_var,
                                                 command=self.update_ui_states,
                                                 style="TCheckbutton")
        self.no_rounding_check.pack(anchor=tk.W, pady=(0,5))

        self.fully_round_check = ttk.Checkbutton(self.radius_options_frame, text="完全に丸くする (円形切り抜き)",
                                                 variable=self.make_fully_round_var,
                                                 command=self.update_ui_states,
                                                 style="TCheckbutton")
        self.fully_round_check.pack(anchor=tk.W, pady=(0,5))

        radius_slider_frame = ttk.Frame(self.radius_options_frame)
        radius_slider_frame.pack(fill="x", pady=(0,5))

        self.radius_label = ttk.Label(radius_slider_frame, text="角の丸み:", style="TLabel")
        self.radius_label.pack(side=tk.LEFT, padx=(0,10))
        self.radius_scale = tk.Scale(radius_slider_frame, from_=0, to_=200, orient=tk.HORIZONTAL,
                                     variable=self.radius_var,
                                     bg=self.BG_COLOR, fg=self.TEXT_COLOR_ON_LIGHT_BG, troughcolor=self.SECONDARY_COLOR,
                                     highlightthickness=0, activebackground=self.PRIMARY_COLOR, sliderrelief="flat",
                                     font=self.FONT_NORMAL, length=300)
        self.radius_scale.pack(side=tk.LEFT, expand=True, fill="x")

        button_frame = ttk.Frame(main_frame)
        button_frame.pack(pady=(10,5), padx=10, fill="x")
        self.process_button = ttk.Button(button_frame, text="画像を処理", command=self.process_image, style="TButton")
        self.process_button.pack(expand=True, fill="x", ipady=5)

        self.status_label = ttk.Label(main_frame, text="", font=self.FONT_NORMAL, anchor=tk.CENTER)
        self.status_label.pack(pady=(5,10), fill="x")

        self.update_process_button_state()
        self.update_ui_states()

    def update_ui_states(self):
        if self.no_rounding_var.get():
            self.fully_round_check.config(state=tk.DISABLED)
            self.make_fully_round_var.set(False)
            self.radius_scale.config(state=tk.DISABLED)
            self.radius_label.config(state=tk.DISABLED, foreground=self.DISABLED_FG_COLOR) # Disabled color for label
        else:
            self.fully_round_check.config(state=tk.NORMAL)
            if self.make_fully_round_var.get():
                self.radius_scale.config(state=tk.DISABLED)
                self.radius_label.config(state=tk.DISABLED, foreground=self.DISABLED_FG_COLOR) # Disabled color
            else:
                self.radius_scale.config(state=tk.NORMAL)
                self.radius_label.config(state=tk.NORMAL, foreground=self.TEXT_COLOR_ON_LIGHT_BG) # Normal color

        self.update_process_button_state()

    def update_process_button_state(self):
        if self.input_path.get() and self.output_path.get():
            self.process_button.config(state=tk.NORMAL)
        else:
            self.process_button.config(state=tk.DISABLED)

    def handle_drop(self, event):
        if not self.dnd_enabled: return
        filepath_raw = event.data

        if filepath_raw.startswith('{') and filepath_raw.endswith('}'):
            filepath = filepath_raw[1:-1]
        else:
            filepath = filepath_raw

        # Take the first file if multiple are dropped (paths might be space or "} {" separated)
        first_filepath = filepath.split('} {')[0].split(' ')[0].strip()

        if os.path.isfile(first_filepath):
            if self.is_image_file(first_filepath):
                self.input_path.set(first_filepath)
                self.drop_label_text.set(f"読込: {os.path.basename(first_filepath)}")
                self.status_label.config(text="画像が読み込まれました。", foreground=self.PRIMARY_COLOR)
                input_dir = os.path.dirname(first_filepath)
                base, ext = os.path.splitext(os.path.basename(first_filepath))
                default_output_name = f"{base}_processed.png"
                self.output_path.set(os.path.join(input_dir, default_output_name))
            else:
                self.status_label.config(text="エラー: 画像ファイルではありません。", foreground=self.ERROR_COLOR)
                messagebox.showerror("エラー", f"{os.path.basename(first_filepath)} は有効な画像ファイルではありません。")
                self.reset_drop_label()
        else:
            self.status_label.config(text="エラー: 有効なファイルではありません。", foreground=self.ERROR_COLOR)
            messagebox.showerror("エラー", f"{first_filepath} は有効なファイルパスではありません。")
            self.reset_drop_label()
        self.update_process_button_state()
        self.update_ui_states()

    def reset_drop_label(self):
        drop_message_base = "ここに画像をドラッグ＆ドロップ" if self.dnd_enabled else "D&D無効"
        self.drop_label_text.set(drop_message_base + "\nまたは下から選択")

    def is_image_file(self, filepath):
        try:
            with Image.open(filepath) as img_test:
                img_test.verify() 
            with Image.open(filepath) as img_test2: # Reopen after verify
                img_test2.format 
            return True
        except (IOError, UnidentifiedImageError, FileNotFoundError, SyntaxError, TypeError, AttributeError) as e:
            print(f"File '{filepath}' is not a valid image: {e}", file=sys.stderr)
            return False

    def select_input_file(self):
        filepath = filedialog.askopenfilename(
            title="入力画像を選択",
            filetypes=(("画像ファイル", "*.png *.jpg *.jpeg *.gif *.bmp *.tiff *.webp"),
                       ("すべてのファイル", "*.*"))
        )
        if filepath:
            if self.is_image_file(filepath):
                self.input_path.set(filepath)
                self.drop_label_text.set(f"読込: {os.path.basename(filepath)}")
                input_dir = os.path.dirname(filepath)
                base, ext = os.path.splitext(os.path.basename(filepath))
                default_output_name = f"{base}_processed.png"
                self.output_path.set(os.path.join(input_dir, default_output_name))
                self.status_label.config(text="入力画像を選択しました。", foreground=self.PRIMARY_COLOR)
            else:
                messagebox.showerror("エラー", "選択されたファイルは有効な画像ファイルではありません。")
                self.status_label.config(text="エラー: 無効な画像ファイルです。", foreground=self.ERROR_COLOR)
                self.input_path.set("") # Clear invalid input path
        self.update_process_button_state()
        self.update_ui_states()

    def select_output_file(self):
        input_filename = os.path.basename(self.input_path.get())
        if input_filename:
            name, _ = os.path.splitext(input_filename)
            default_name = f"{name}_processed.png"
        else:
            default_name = "processed_image.png"

        filepath = filedialog.asksaveasfilename(
            title="出力先を選択",
            defaultextension=".png",
            initialfile=default_name,
            filetypes=(("PNG画像", "*.png"), ("すべてのファイル", "*.*"))
        )
        if filepath:
            self.output_path.set(filepath)
            self.status_label.config(text="出力先を選択しました。", foreground=self.PRIMARY_COLOR)
        self.update_process_button_state()

    def resize_image_aspect_fit(self, image, max_width, max_height):
        original_width, original_height = image.size
        if original_width == 0 or original_height == 0: return image

        # Handle cases where one dimension is inf (e.g. for custom mode if only one dim is constrained)
        if max_width == float('inf') and max_height == float('inf'): return image
        if max_width == float('inf'):
            if original_height == 0: return image # Avoid division by zero
            max_width = original_width * (max_height / original_height)
        if max_height == float('inf'):
            if original_width == 0: return image # Avoid division by zero
            max_height = original_height * (max_width / original_width)

        ratio_w = max_width / original_width
        ratio_h = max_height / original_height
        scale_factor = min(ratio_w, ratio_h)

        new_width = int(original_width * scale_factor)
        new_height = int(original_height * scale_factor)
        new_width = max(1, new_width)
        new_height = max(1, new_height)

        if (new_width, new_height) == (original_width, original_height): return image

        img_to_resize = image.convert('RGBA') if image.mode not in ('RGBA', 'LA') else image
        resized_image = img_to_resize.resize((new_width, new_height), LANCZOS_RESAMPLE)
        print(f"Aspect fit resize from {original_width}x{original_height} to {new_width}x{new_height}")
        return resized_image

    def resize_to_fixed_canvas(self, image, target_canvas_width, target_canvas_height):
        img_rgba = image.convert("RGBA") # Ensure RGBA for consistent alpha handling
        original_width, original_height = img_rgba.size

        if original_width == 0 or original_height == 0:
            return Image.new("RGBA", (target_canvas_width, target_canvas_height), (0,0,0,0))

        ratio_w = target_canvas_width / original_width
        ratio_h = target_canvas_height / original_height
        scale_factor = min(ratio_w, ratio_h)

        new_width = int(original_width * scale_factor)
        new_height = int(original_height * scale_factor)
        new_width = max(1, new_width)
        new_height = max(1, new_height)

        resized_image = img_rgba.resize((new_width, new_height), LANCZOS_RESAMPLE)

        final_image = Image.new("RGBA", (target_canvas_width, target_canvas_height), (0,0,0,0)) # Transparent canvas

        paste_x = (target_canvas_width - new_width) // 2
        paste_y = (target_canvas_height - new_height) // 2

        final_image.paste(resized_image, (paste_x, paste_y), resized_image) # Use resized_image's alpha as mask

        print(f"Resized from {original_width}x{original_height} to {new_width}x{new_height}, then padded to {target_canvas_width}x{target_canvas_height}")
        return final_image

    def round_corners(self, image, radius):
        image_to_round = image.copy().convert("RGBA")
        width, height = image_to_round.size

        actual_radius = int(radius) # Ensure radius is integer

        if not self.make_fully_round_var.get() and actual_radius > min(width, height) // 2:
             actual_radius = min(width, height) // 2

        if actual_radius < 0: actual_radius = 0

        mask = Image.new('L', (width, height), 0)
        draw = ImageDraw.Draw(mask)
        draw.rounded_rectangle((0, 0, width, height), radius=actual_radius, fill=255)
        image_to_round.putalpha(mask)
        return image_to_round

    def process_image(self):
        input_p = self.input_path.get()
        output_p = self.output_path.get()
        selected_mode_key = self.output_mode_var.get()
        current_mode_settings = self.MODES[selected_mode_key]

        target_dim_w, target_dim_h = current_mode_settings["max_dims"]
        target_max_filesize_mb = current_mode_settings["max_size_mb"]

        if not input_p or not output_p:
            messagebox.showerror("エラー", "入力画像と出力先を選択してください。")
            return

        try:
            self.status_label.config(text="処理中...", foreground=self.PRIMARY_COLOR)
            self.master.update_idletasks()

            with Image.open(input_p) as img:
                processed_img = img.copy()

                # 1. リサイズ処理
                if selected_mode_key == "mode1" or selected_mode_key == "mode2":
                    processed_img = self.resize_to_fixed_canvas(processed_img, int(target_dim_w), int(target_dim_h))
                elif selected_mode_key == "custom":
                    # For custom mode, if dims are not inf, use aspect_fit. Otherwise, no resize.
                    if target_dim_w != float('inf') or target_dim_h != float('inf'):
                         processed_img = self.resize_image_aspect_fit(processed_img, target_dim_w, target_dim_h)

                # 2. 角丸処理
                if not self.no_rounding_var.get():
                    current_width, current_height = processed_img.size
                    max_possible_radius = min(current_width, current_height) // 2
                    actual_radius = 0

                    if self.make_fully_round_var.get():
                        actual_radius = max_possible_radius
                        print(f"完全に丸くするため、半径を {actual_radius} に設定。")
                    else:
                        slider_radius_val = self.radius_var.get()
                        if slider_radius_val > max_possible_radius:
                            actual_radius = max_possible_radius
                            self.radius_var.set(actual_radius)
                            if slider_radius_val != actual_radius and selected_mode_key != "custom":
                                 messagebox.showwarning("半径調整",
                                                       f"指定された半径({slider_radius_val}px)は現在の画像サイズ({current_width}x{current_height}px)では大きすぎたため、"
                                                       f"最大値の{actual_radius}pxに調整しました。")
                        else:
                            actual_radius = slider_radius_val

                    if actual_radius < 0: actual_radius = 0

                    if actual_radius > 0 or self.make_fully_round_var.get():
                        processed_img = self.round_corners(processed_img, actual_radius)

                # 3. 保存
                if output_p.lower().endswith(".png") and processed_img.mode != 'RGBA':
                    processed_img = processed_img.convert("RGBA")

                processed_img.save(output_p, "PNG", optimize=True, compress_level=9)

            final_filesize_bytes = os.path.getsize(output_p)
            final_filesize_mb = final_filesize_bytes / (1024 * 1024)

            status_message = f"処理完了: {os.path.basename(output_p)} ({final_filesize_mb:.2f}MB) を保存。"
            status_color = self.SUCCESS_COLOR

            if target_max_filesize_mb != float('inf') and final_filesize_mb > target_max_filesize_mb:
                messagebox.showwarning("ファイルサイズ警告",
                                     f"生成されたファイルのサイズ ({final_filesize_mb:.2f}MB) が選択モードの目標 ({target_max_filesize_mb}MB) を超えました。\n"
                                     f"画質を維持するため、このまま保存されました。")
                status_message = f"完了(サイズ警告あり): {os.path.basename(output_p)} ({final_filesize_mb:.2f}MB超)。"
                status_color = self.WARNING_COLOR

            self.status_label.config(text=status_message, foreground=status_color)
            self.reset_drop_label()

        except FileNotFoundError:
            messagebox.showerror("エラー", f"入力ファイルが見つかりません: {input_p}")
            self.status_label.config(text="エラー: 入力ファイルが見つかりません。", foreground=self.ERROR_COLOR)
        except UnidentifiedImageError:
             messagebox.showerror("エラー", f"画像ファイルとして認識できません: {input_p}")
             self.status_label.config(text="エラー: 画像ファイル形式が無効です。", foreground=self.ERROR_COLOR)
        except IOError as e:
            messagebox.showerror("エラー", f"ファイル入出力エラー: {e}\n画像が破損しているかサポート外の形式の可能性があります。")
            self.status_label.config(text=f"エラー: ファイルIOエラー ({e})", foreground=self.ERROR_COLOR)
        except Exception as e:
            import traceback
            traceback.print_exc(file=sys.stderr)
            messagebox.showerror("予期せぬエラー", f"予期せぬエラーが発生しました: {e}")
            self.status_label.config(text=f"予期せぬエラー: {e}", foreground=self.ERROR_COLOR)
        finally:
            self.update_process_button_state()
            self.update_ui_states()

    def run(self):
        self.master.mainloop()

if __name__ == "__main__":
    # Windows 高DPI対応 (try-exceptで囲み、他OSでのエラーを回避)
    try:
        if sys.platform == "win32":
            from ctypes import windll
            windll.shcore.SetProcessDpiAwareness(1) # DPI_AWARENESS_PER_MONITOR_AWARE
    except Exception as e:
        print(f"Failed to set DPI awareness: {e}", file=sys.stderr)

    if TkinterDnD:
        root = TkinterDnD.Tk()
    else:
        root = tk.Tk()

    app = AutoRoundedTransparentIconGenerator(root)
    app.run()

def handle_drop(self, event):
    if not self.dnd_enabled: return
    filepath_raw = event.data
    # ファイルパスの整形処理
    # ...
    first_filepath = filepath.split('} {')[0].split(' ')[0].strip()

    if os.path.isfile(first_filepath):
        if self.is_image_file(first_filepath):
            # 画像ファイルの場合の処理
            self.input_path.set(first_filepath)
            # ... (出力パスの自動設定など)
        else:
            # 画像ファイルでない場合の処理
            messagebox.showerror("エラー", ...)
            self.reset_drop_label()
    else:
        # 無効なファイルパスの場合の処理
        messagebox.showerror("エラー", ...)
        self.reset_drop_label()
    self.update_process_button_state()
    self.update_ui_states()

def select_input_file(self):
    filepath = filedialog.askopenfilename(...)
    if filepath:
        if self.is_image_file(filepath):
            # 画像ファイルの場合の処理
            self.input_path.set(filepath)
            # ... (出力パスの自動設定など)
        else:
            # 画像ファイルでない場合の処理
            messagebox.showerror("エラー", ...)
            self.input_path.set("") # 無効なパスをクリア
    self.update_process_button_state()
    self.update_ui_states()

def select_output_file(self):
    filepath = filedialog.asksaveasfilename(...)
    if filepath:
        self.output_path.set(filepath)
    self.update_process_button_state()

def update_ui_states(self):
    if self.no_rounding_var.get():
        # 角丸処理しない場合、他の角丸設定を無効化
        self.fully_round_check.config(state=tk.DISABLED)
        self.make_fully_round_var.set(False)
        self.radius_scale.config(state=tk.DISABLED)
        self.radius_label.config(state=tk.DISABLED, ...)
    else:
        # 角丸処理する場合、他の設定を有効化
        self.fully_round_check.config(state=tk.NORMAL)
        if self.make_fully_round_var.get():
            # 完全に丸くする場合、半径スライダーを無効化
            self.radius_scale.config(state=tk.DISABLED)
            self.radius_label.config(state=tk.DISABLED, ...)
        else:
            # 角丸半径を指定する場合、半径スライダーを有効化
            self.radius_scale.config(state=tk.NORMAL)
            self.radius_label.config(state=tk.NORMAL, ...)

    self.update_process_button_state()

def update_process_button_state(self):
    if self.input_path.get() and self.output_path.get():
        self.process_button.config(state=tk.NORMAL) # 入力・出力パスがあればボタン有効
    else:
        self.process_button.config(state=tk.DISABLED) # なければ無効

def round_corners(self, image, radius):
    image_to_round = image.copy().convert("RGBA") # RGBAモードに変換 (アルファチャンネル必須)
    width, height = image_to_round.size

    actual_radius = int(radius)
    # 半径が画像サイズを超えないように調整 (完全に丸くする場合を除く)
    if not self.make_fully_round_var.get() and actual_radius > min(width, height) // 2:
         actual_radius = min(width, height) // 2
    # 半径が負の値にならないように調整
    if actual_radius < 0: actual_radius = 0

    mask = Image.new('L', (width, height), 0) # グレースケールのマスク画像を生成 (初期値0=完全透明)
    draw = ImageDraw.Draw(mask)
    # マスク画像に角丸の白い矩形を描画 (白=不透明)
    draw.rounded_rectangle((0, 0, width, height), radius=actual_radius, fill=255)

    image_to_round.putalpha(mask) # 元画像にマスク画像をアルファチャンネルとして適用
    return image_to_round

def process_image(self):
    # ... (画像処理ロジック)

    # 3. 保存
    if output_p.lower().endswith(".png") and processed_img.mode != 'RGBA':
        processed_img = processed_img.convert("RGBA") # PNG保存時はRGBA必須

    processed_img.save(output_p, "PNG", optimize=True, compress_level=9)

    # ... (ファイルサイズチェックとステータス表示)

try:
    # ... (画像処理ロジック)
except FileNotFoundError:
    messagebox.showerror("エラー", f"入力ファイルが見つかりません: {input_p}")
    self.status_label.config(text="エラー: 入力ファイルが見つかりません。", foreground=self.ERROR_COLOR)
except UnidentifiedImageError:
     messagebox.showerror("エラー", f"画像ファイルとして認識できません: {input_p}")
     self.status_label.config(text="エラー: 画像ファイル形式が無効です。", foreground=self.ERROR_COLOR)
# ... (他の例外処理)
except Exception as e:
    # 予期せぬエラー
    import traceback
    traceback.print_exc(file=sys.stderr)
    messagebox.showerror("予期せぬエラー", f"予期せぬエラーが発生しました: {e}")
    self.status_label.config(text=f"予期せぬエラー: {e}", foreground=self.ERROR_COLOR)

# Pillow のリサンプリングフィルターをバージョン互換性考慮して設定
try:
    LANCZOS_RESAMPLE = Image.Resampling.LANCZOS # Pillow 9.1.0以降
except AttributeError:
    try:
        LANCZOS_RESAMPLE = Image.LANCZOS # Pillow 1.0.0以降 (非推奨)
    except AttributeError:
        LANCZOS_RESAMPLE = Image.ANTIALIAS # それ以前 (非推奨)