Compare commits

..
3 Commits
Author SHA1 Message Date
CosmicKillsSouls 0af6aa05a0 Adjustable Window sizes
Changed window sizes to be controlled by config.
2026-09-04 11:43:31 -05:00
CosmicKillsSouls 1aaaefd08f Adjustable Window sizes
Changed window sizes to be controlled by config.
2026-09-04 11:39:48 -05:00
CosmicKillsSouls 9e74032649 Initial Commit 2026-08-21 07:07:21 -05:00
7 changed files with 571 additions and 1172 deletions

No files matched your search

-2
View File
@@ -1,2 +0,0 @@
__pycache__/
*.py[cod]
-43
View File
@@ -1,43 +0,0 @@
[Paths]
SEARCH_ROOT = C:\CNCPrograms\Programs
TRASH_DIR = C:\CNCPrograms\Trash
INDEX_FILE = C:\CNCPrograms\search_index.pkl
[Features]
TRASH_ENABLED = True
EDITOR_ENABLED = False
AUTO_CLOSE_SECONDS = 300
WORKER_COUNT = 16
[Copy]
Extension =
[Buttons]
BUTTON_SIZE_SEARCH=15
BUTTON_SIZE_OPEN=15
BUTTON_SIZE_SELECT_ALL=15
BUTTON_SIZE_SAVE=15
BUTTON_SIZE_COPY=15
BUTTON_SIZE_TRASH=15
BUTTON_SIZE_CLOSE=15
BUTTON_SIZE_MESSAGE=15
BUTTON_SIZE_YES_NO=15
[UI]
TEXT_FONT = Consolas
SEARCH_WIDTH=400
SEARCH_HEIGHT=150
SEARCH_FONT_SIZE=12
RESULTS_WIDTH=1000
RESULTS_HEIGHT=700
RESULTS_FONT_SIZE=11
PREVIEW_WIDTH=1200
PREVIEW_HEIGHT=900
PREVIEW_FONT_SIZE=24
ERROR_WIDTH=400
ERROR_HEIGHT=100
ERROR_FONT_SIZE=20
-380
View File
@@ -1,380 +0,0 @@
import os
import re
import csv
import hashlib
import tkinter as tk
from pathlib import Path
# ============================================================
# GUI
# ============================================================
def select_folder():
return input("Enter folder path: ").strip().strip("'\"")
# ============================================================
# Helper Functions
# ============================================================
def normalize_nc_content(text):
output = []
for line in text.splitlines():
line = line.upper()
# Remove comments
line = re.sub(r"\(.*?\)", "", line)
line = re.sub(r";.*", "", line)
# Remove tool numbers
line = re.sub(r"\bT\d+\b", "", line)
# Remove spindle speeds
line = re.sub(r"\bS[-+]?\d*\.?\d+\b", "", line)
line = line.strip()
if line:
output.append(line)
return "\n".join(output)
def calculate_file_hash(file_path):
sha = hashlib.sha256()
with open(file_path, "rb") as f:
while True:
chunk = f.read(8192)
if not chunk:
break
sha.update(chunk)
return sha.hexdigest()
# ============================================================
# Geometry Comparison
# ============================================================
AXIS_PATTERN = re.compile(r"([XYZIJKR])([-+]?\d*\.?\d+)")
COMMAND_PATTERN = re.compile(r"\b(G\d+|M\d+)\b")
def extract_toolpath(file_path):
motions = []
with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
for raw_line in f:
line = normalize_nc_content(raw_line)
if not line:
continue
commands = COMMAND_PATTERN.findall(line)
axes = {
axis: float(value)
for axis, value in AXIS_PATTERN.findall(line)
}
if commands or axes:
motions.append({
"commands": tuple(commands),
"axes": axes
})
return motions
def compare_program_structure(file1, file2, tolerance=0.005):
path1 = extract_toolpath(file1)
path2 = extract_toolpath(file2)
if len(path1) != len(path2):
return False, None
max_diff = 0
for move1, move2 in zip(path1, path2):
if move1["commands"] != move2["commands"]:
return False, None
axes = set(move1["axes"]) | set(move2["axes"])
for axis in axes:
if axis not in move1["axes"]:
return False, None
if axis not in move2["axes"]:
return False, None
diff = abs(
move1["axes"][axis]
- move2["axes"][axis]
)
max_diff = max(max_diff, diff)
if diff > tolerance:
return False, max_diff
return True, max_diff
# ============================================================
# Extension Normalization
# ============================================================
def normalize_extensions(root_folder):
root_path = Path(root_folder)
if not root_path.exists():
raise FileNotFoundError(root_folder)
for file in root_path.rglob("*"):
if not file.is_file():
continue
suffix = file.suffix.lower()
if suffix == "":
new_file = file.with_name(
file.name + ".txt"
)
elif suffix == ".nc":
new_file = file.with_suffix(".txt")
elif suffix == ".txt":
if file.suffix == ".txt":
continue
new_file = file.with_suffix(".txt")
else:
continue
try:
file.rename(new_file)
except Exception as e:
print(f"Failed: {file}")
print(e)
print("Extension normalization complete.")
# ============================================================
# Program Splitting
# ============================================================
def split_file_by_key(input_file, output_dir):
os.makedirs(output_dir, exist_ok=True)
current_output = None
with open(input_file, "r", encoding="utf-8", errors="ignore") as infile:
for line in infile:
if line.startswith("O"):
if current_output:
current_output.write("%\n")
current_output.close()
filename = line[:6].strip()
output_path = os.path.join(output_dir, f"{filename}.txt")
current_output = open(output_path, "w", encoding="utf-8")
current_output.write("%\n")
if current_output:
current_output.write(line)
if current_output:
current_output.write("%\n")
current_output.close()
print(f"Finished: {input_file}")
# ============================================================
# Exact Duplicate Removal
# ============================================================
def remove_exact_duplicates(root_dir):
known_hashes = {}
deleted = []
for file in Path(root_dir).rglob("*.txt"):
file_hash = calculate_file_hash(file)
if file_hash in known_hashes:
print(f"Removing exact duplicate: {file}")
file.unlink()
deleted.append(file)
else:
known_hashes[file_hash] = file
print(
f"Removed {len(deleted)} exact duplicates."
)
# ============================================================
# Geometry Duplicate Removal
# ============================================================
def remove_geometry_duplicates(root_dir, tolerance=0.005):
files = list(Path(root_dir).rglob("*.txt"))
removed = set()
for i in range(len(files)):
if files[i] in removed:
continue
for j in range(i + 1, len(files)):
if files[j] in removed:
continue
duplicate, max_diff = compare_program_structure(files[i], files[j], tolerance)
if duplicate:
print(
f"Removing geometric duplicate:\n"
f" Keep: {files[i].name}\n"
f" Delete: {files[j].name}\n"
f" Max Delta: {max_diff:.5f}"
)
files[j].unlink()
removed.add(files[j])
print(
f"Removed {len(removed)} geometry duplicates."
)
# ============================================================
# Similarity Report
# ============================================================
def generate_similarity_report(
root_dir,
tolerance=0.005,
output_csv="similarity_report.csv"
):
files = list(Path(root_dir).rglob("*.txt"))
with open(output_csv, "w", newline="", encoding="utf-8") as csvfile:
writer = csv.writer(csvfile)
writer.writerow([
"File1",
"File2",
"Duplicate",
"MaxCoordinateDelta"
])
for i in range(len(files)):
for j in range(i + 1, len(files)):
duplicate, delta = compare_program_structure(files[i], files[j], tolerance)
writer.writerow([
files[i].name,
files[j].name,
duplicate,
delta
])
print(
f"Similarity report written to {output_csv}"
)
# ============================================================
# Main
# ============================================================
if __name__ == "__main__":
input_dir = select_folder()
if not os.path.isdir(input_dir):
print("Invalid folder.")
raise SystemExit(1)
normalize_extensions(input_dir)
master_output_dir = os.path.join(input_dir, "Split_Output")
os.makedirs(master_output_dir, exist_ok=True)
for root, dirs, files in os.walk(input_dir):
if os.path.abspath(root).startswith(os.path.abspath(master_output_dir)):
continue
for filename in files:
if not filename.lower().endswith(".pgm"):
continue
input_file = os.path.join(root, filename)
program_output_dir = os.path.join(master_output_dir, os.path.splitext(filename)[0])
split_file_by_key(input_file, program_output_dir)
remove_exact_duplicates(master_output_dir)
remove_geometry_duplicates(master_output_dir, tolerance=0.005)
generate_similarity_report(master_output_dir, tolerance=0.005)
print("All files processed.")
-146
View File
@@ -1,146 +0,0 @@
#!/usr/bin/env python3
import os
import sys
import pickle
import configparser
from concurrent.futures import ThreadPoolExecutor
# ============================================================
# CONFIG
config = configparser.ConfigParser()
config.read(r"C:\ProgramData\Program-Search\config.ini")
# PATHS
SEARCH_ROOT = config["Paths"]["SEARCH_ROOT"]
INDEX_FILE = config["Paths"]["INDEX_FILE"]
# FEATURES
WORKER_COUNT = config.getint("Features", "WORKER_COUNT", fallback=8)
# ============================================================
def read_file(path, mtime, size):
try:
with open(path, "r", errors="ignore") as f:
return (
path,
{
"filename": os.path.basename(path).lower(),
"content": f.read().lower(),
"mtime": mtime,
"size": size,
}
)
except Exception:
return None
def scan_files(root):
"""Return {path: (mtime, size)} for every file under root."""
found = {}
stack = [root]
while stack:
current = stack.pop()
try:
with os.scandir(current) as it:
for entry in it:
try:
if entry.is_dir(follow_symlinks=False):
stack.append(entry.path)
elif entry.is_file():
st = entry.stat()
found[entry.path] = (st.st_mtime, st.st_size)
except OSError:
pass
except OSError:
pass
return found
def load_index():
try:
with open(INDEX_FILE, "rb") as f:
return pickle.load(f)
except Exception:
return {}
def save_index(index):
os.makedirs(os.path.dirname(INDEX_FILE), exist_ok=True)
# Write to a temp file first so a crash never leaves a corrupt index.
tmp_file = INDEX_FILE + ".tmp"
with open(tmp_file, "wb") as f:
pickle.dump(index, f, protocol=pickle.HIGHEST_PROTOCOL)
os.replace(tmp_file, INDEX_FILE)
def update_index(index, verbose=False):
"""
Bring index up to date with SEARCH_ROOT in place.
Only new or changed files are re-read; deleted files are removed.
Returns True if anything changed.
"""
if verbose:
print("Scanning files...")
on_disk = scan_files(SEARCH_ROOT)
removed = [p for p in index if p not in on_disk]
for p in removed:
del index[p]
to_read = []
for path, (mtime, size) in on_disk.items():
data = index.get(path)
if (
data is None
or data.get("mtime") != mtime
or data.get("size") != size
):
to_read.append((path, mtime, size))
if verbose:
print(
f"Found {len(on_disk)} files: "
f"{len(to_read)} new/changed, {len(removed)} removed"
)
completed = 0
with ThreadPoolExecutor(max_workers=WORKER_COUNT) as executor:
for result in executor.map(lambda a: read_file(*a), to_read):
completed += 1
if verbose and completed % 100 == 0:
print(f"{completed}/{len(to_read)}")
if result:
path, data = result
index[path] = data
return bool(removed or to_read)
def build_index(full=False):
index = {} if full else load_index()
changed = update_index(index, verbose=True)
if not changed and os.path.exists(INDEX_FILE):
print("\nIndex already up to date.")
return
print("\nSaving index...")
save_index(index)
size_mb = os.path.getsize(INDEX_FILE) / 1024 / 1024
print(
f"Index saved:\n"
f"{INDEX_FILE}\n"
f"{len(index)} files\n"
f"{size_mb:.2f} MB"
)
if __name__ == "__main__":
# Run with --full to rebuild the index from scratch.
build_index(full="--full" in sys.argv)
+174 -192
View File
@@ -2,307 +2,288 @@
import os import os
import tkinter as tk import tkinter as tk
from tkinter import scrolledtext from tkinter import scrolledtext
import tkinter.font as tkfont
import shutil import shutil
import ctypes
import string
import configparser import configparser
# ============================================================ # ============================================================
# CONFIG: # CONFIG:
config = configparser.ConfigParser() config = configparser.ConfigParser()
config.read(r"C:\ProgramData\Program-Search\config.ini") config.read(r"C:\ProgramData\Program-Search\config.ini")
# PATHS
SEARCH_ROOT = config["Paths"]["SEARCH_ROOT"] SEARCH_ROOT = config["Paths"]["SEARCH_ROOT"]
TRASH_DIR = config["Paths"]["TRASH_DIR"] TRASH_DIR = config["Paths"]["TRASH_DIR"]
# FEATURES EDITOR_ENABLED = config.getboolean("Features", "EDITOR_ENABLED")
EDITOR_ENABLED = config.getboolean("Features", "EDITOR_ENABLED", fallback=True) AUTO_CLOSE_SECONDS = config.getint("Features", "AUTO_CLOSE_SECONDS")
AUTO_CLOSE_SECONDS = config.getint("Features", "AUTO_CLOSE_SECONDS", fallback=30) CLOSE_ALL_ENABLED = config.getboolean("Features", "CLOSE_ALL_ENABLED")
# UI
TEXT_FONT = config.get("UI", "TEXT-font", fallback="Consolas")
SEARCH_WIDTH = config.getint("UI", "SEARCH_WIDTH", fallback=400)
SEARCH_HEIGHT = config.getint("UI", "SEARCH_HEIGHT", fallback=150)
SEARCH_FONT_SIZE = config.getint("UI", "SEARCH_FONT_SIZE", fallback=12)
RESULTS_WIDTH = config.getint("UI", "RESULTS_WIDTH", fallback=1000)
RESULTS_HEIGHT = config.getint("UI", "RESULTS_HEIGHT", fallback=700)
RESULTS_FONT_SIZE = config.getint("UI", "RESULTS_FONT_SIZE", fallback=11)
PREVIEW_WIDTH = config.getint("UI", "PREVIEW_WIDTH", fallback=1200)
PREVIEW_HEIGHT = config.getint("UI", "PREVIEW_HEIGHT", fallback=900)
PREVIEW_FONT_SIZE = config.getint("UI", "PREVIEW_FONT_SIZE", fallback=24)
ERROR_WIDTH = config.getint("UI", "ERROR_WIDTH", fallback=400)
ERROR_HEIGHT = config.getint("UI", "ERROR_HEIGHT", fallback=100)
ERROR_FONT_SIZE = config.getint("UI", "ERROR_FONT_SIZE", fallback=11)
# BUTTONS
BUTTON_SIZE_SEARCH = config.getint("Buttons", "BUTTON_SIZE_SEARCH", fallback=15)
BUTTON_SIZE_OPEN = config.getint("Buttons", "BUTTON_SIZE_OPEN", fallback=15)
BUTTON_SIZE_SELECT_ALL = config.getint("Buttons", "BUTTON_SIZE_SELECT_ALL", fallback=15)
BUTTON_SIZE_SAVE = config.getint("Buttons", "BUTTON_SIZE_SAVE", fallback=15)
BUTTON_SIZE_COPY = config.getint("Buttons", "BUTTON_SIZE_COPY", fallback=15)
BUTTON_SIZE_TRASH = config.getint("Buttons", "BUTTON_SIZE_TRASH", fallback=15)
BUTTON_SIZE_CLOSE = config.getint("Buttons", "BUTTON_SIZE_CLOSE", fallback=15)
BUTTON_SIZE_MESSAGE = config.getint("Buttons", "BUTTON_SIZE_MESSAGE", fallback=15)
BUTTON_SIZE_YES_NO = config.getint("Buttons", "BUTTON_SIZE_YES_NO", fallback=15)
# ============================================================ # ============================================================
os.makedirs(TRASH_DIR, exist_ok=True) os.makedirs(TRASH_DIR, exist_ok=True)
def center_window(win, width, height):
screen_width = win.winfo_screenwidth()
screen_height = win.winfo_screenheight()
x = int((screen_width / 2) - (width / 2))
y = int((screen_height / 2) - (height / 2))
win.geometry(f"{width}x{height}+{x}+{y}")
def custom_message(title, message): def custom_messagebox(title, message, kind="info"):
win = tk.Toplevel() win = tk.Toplevel()
win.title(title) win.title(title)
win.protocol("WM_DELETE_WINDOW", win.destroy) win.geometry("600x300")
tk.Label(
win,
text=message,
font=(TEXT_FONT, ERROR_FONT_SIZE),
wraplength=ERROR_WIDTH - 30,
justify="center"
).pack(padx=15, pady=15)
tk.Button(win, text="OK", font=(TEXT_FONT, BUTTON_SIZE_MESSAGE), command=win.destroy).pack(pady=10)
win.bind("<Return>", lambda e: win.destroy())
center_window(win, ERROR_WIDTH, ERROR_HEIGHT)
win.lift()
win.focus_force()
win.transient()
win.grab_set() win.grab_set()
win.update() win.focus_force()
win.wait_window() center_window(win)
frame = tk.Frame(win, padx=20, pady=20)
frame.pack(expand=True, fill="both")
tk.Label(frame, text=message, font=("Consolas", 24), wraplength=550).pack(pady=20)
if kind == "yesno":
result = {"value": False}
def yes():
result["value"] = True
win.destroy()
def no():
result["value"] = False
win.destroy()
tk.Button(frame, text="Yes", font=("Consolas", 24), padx=10, pady=10, command=yes).pack(side="left", padx=16)
tk.Button(frame, text="No", font=("Consolas", 24), padx=10, pady=10, command=no).pack(side="right", padx=16)
win.wait_window()
return result["value"]
else:
def close():
win.destroy()
tk.Button(frame, text="OK", font=("Consolas", 24), padx=10, pady=10, command=close).pack(pady=20)
win.bind("<Return>", lambda event: close())
win.wait_window()
def center_window(win):
win.update_idletasks()
w = win.winfo_width()
h = win.winfo_height()
sw = win.winfo_screenwidth()
sh = win.winfo_screenheight()
x = (sw // 2) - (w // 2)
y = (sh // 2) - (h // 2)
win.geometry(f"{w}x{h}+{x}+{y}")
def custom_yesno(title, message):
win = tk.Toplevel()
win.title(title)
result = {"value": False}
tk.Label(
win,
text=message,
font=(TEXT_FONT, ERROR_FONT_SIZE),
wraplength=ERROR_WIDTH - 30,
justify="center"
).pack(padx=15, pady=15)
button_frame = tk.Frame(win)
button_frame.pack(pady=10)
def yes():
result["value"] = True
win.destroy()
def no():
result["value"] = False
win.destroy()
tk.Button(button_frame, text="Yes", width=BUTTON_SIZE_YES_NO, font=(TEXT_FONT, BUTTON_SIZE_YES_NO), command=yes).pack(side="left", padx=10)
tk.Button(button_frame, text="No", width=BUTTON_SIZE_YES_NO, font=(TEXT_FONT, BUTTON_SIZE_YES_NO), command=no).pack(side="left", padx=10)
win.protocol("WM_DELETE_WINDOW", no)
center_window(win, ERROR_WIDTH, ERROR_HEIGHT)
win.lift()
win.focus_force()
win.grab_set()
win.wait_window()
return result["value"]
def popup_search_input(): def popup_search_input():
win = tk.Toplevel() win = tk.Toplevel()
win.title("Search") win.title("Search Trash")
win.geometry(f"{SEARCH_WIDTH}x{SEARCH_HEIGHT}") win.geometry("600x300")
center_window(win)
tk.Label(win, text="Enter part number or name:", font=(TEXT_FONT, SEARCH_FONT_SIZE)).pack(pady=10)
entry = tk.Entry(win, font=(TEXT_FONT, SEARCH_FONT_SIZE)) tk.Label(win, text="Enter part number or name:", font=("Consolas", 18)).pack(pady=20)
entry.pack(pady=5)
win.lift() entry = tk.Entry(win, font=("Consolas", 18))
win.attributes("-topmost", True) entry.pack(pady=10)
entry.focus_set()
result = {"value": None, "force_close": False}
result = {"value": None}
def submit(): def submit():
result["value"] = entry.get().strip().lower() result["value"] = entry.get().strip().lower()
win.destroy() win.destroy()
def force_close(): entry.bind("<Return>", lambda event: submit())
result["force_close"] = True win.bind("<Return>", lambda event: submit())
win.destroy()
tk.Button(win, text="Search", font=("Consolas", 18), padx=20, pady=10, command=submit).pack(pady=40)
entry.bind("<Return>", lambda e: submit())
tk.Button(win, text="Search", font=(TEXT_FONT, BUTTON_SIZE_SEARCH), command=submit).pack(pady=10)
center_window(win, SEARCH_WIDTH, SEARCH_HEIGHT)
win.protocol("WM_DELETE_WINDOW", force_close)
win.after(50, lambda: (entry.focus_set(), entry.icursor(tk.END)))
win.after(100, lambda: win.attributes("-topmost", False))
win.wait_window() win.wait_window()
return result["value"] return result["value"]
def search_files(term): def search_files(term):
matches = [] matches = []
term_lower = term.lower()
for root, dirs, files in os.walk(TRASH_DIR): for root, dirs, files in os.walk(TRASH_DIR):
for fname in files: for fname in files:
path = os.path.join(root, fname) path = os.path.join(root, fname)
fname_lower = fname.lower()
filename_match = term_lower in fname.lower()
filename_match = term in fname_lower
contents_match = False contents_match = False
try: try:
with open(path, "r", errors="ignore") as f: with open(path, "r", errors="ignore") as f:
if term_lower in f.read().lower(): if term in f.read().lower():
contents_match = True contents_match = True
except Exception: except:
pass pass
if filename_match or contents_match: if filename_match or contents_match:
matches.append(path) matches.append(path)
return matches return matches
def popup_results_list(matches): def popup_results_list(matches):
win = tk.Toplevel() win = tk.Toplevel()
win.title("Matches Found") win.title("Matches Found")
win.geometry(f"{RESULTS_WIDTH}x{RESULTS_HEIGHT}") win.geometry("1200x1000")
center_window(win)
tk.Label(win, text="Select files to preview:", font=(TEXT_FONT, RESULTS_FONT_SIZE)).pack(pady=10)
tk.Label(win, text="Select files to preview:", font=("Consolas", 18)).pack(pady=20)
lb = tk.Listbox(win, selectmode=tk.MULTIPLE, font=(TEXT_FONT, RESULTS_FONT_SIZE))
lb = tk.Listbox(win, selectmode=tk.MULTIPLE, font=("Consolas", 18))
lb.pack(expand=True, fill="both") lb.pack(expand=True, fill="both")
lb.bind("<Return>", lambda e: submit())
for m in matches: for m in matches:
parent = os.path.basename(os.path.dirname(m)) lb.insert(tk.END, m)
filename = os.path.basename(m)
display = f"{parent}\\{filename}"
lb.insert(tk.END, display)
result = {"selected": []} result = {"selected": []}
def select_all(): def select_all():
lb.select_set(0, tk.END) lb.select_set(0, tk.END)
def submit(): def submit():
sel = lb.curselection() sel = lb.curselection()
if not sel:
custom_message("No Selection", "Please select at least 1 file.")
return
result["selected"] = [matches[i] for i in sel] result["selected"] = [matches[i] for i in sel]
win.destroy() win.destroy()
tk.Button(win, text="Open Selected", font=(TEXT_FONT, BUTTON_SIZE_OPEN), command=submit).pack(padx=10) lb.bind("<Return>", lambda event: submit())
tk.Button(win, text="Select All", font=(TEXT_FONT, BUTTON_SIZE_SELECT_ALL), command=select_all).pack(padx=10) win.bind("<Return>", lambda event: submit())
center_window(win, RESULTS_WIDTH, RESULTS_HEIGHT) tk.Button(win, text="Open Selected", font=("Consolas", 18), padx=20, pady=10, command=submit).pack(side="right", padx=20, pady=20)
win.lift() tk.Button(win, text="Select All", font=("Consolas", 18), padx=20, pady=10, command=select_all).pack(side="left", padx=20, pady=20)
win.focus_force()
win.wait_window() win.wait_window()
return result["selected"] return result["selected"]
def popup_file_preview(path, on_close_callback): def popup_file_preview(path, on_close_callback):
win = tk.Toplevel() win = tk.Toplevel()
height = min(PREVIEW_HEIGHT, win.winfo_screenheight() - 80) win.title(path)
win.geometry(f"{PREVIEW_WIDTH}x{height}") win.geometry("900x1000")
center_window(win)
frame = tk.Frame(win)
frame.pack(side="bottom", fill="x") box = scrolledtext.ScrolledText(win, wrap=tk.WORD, font=("Consolas", 18))
box.pack(expand=True, fill="both")
box = scrolledtext.ScrolledText(win, wrap=tk.WORD, font=(TEXT_FONT, PREVIEW_FONT_SIZE))
box.pack(expand=True, fill="both", padx=5, pady=10)
try: try:
with open(path, "r", errors="ignore") as f: with open(path, "r", errors="ignore") as f:
original_text = f.read() original_text = f.read()
box.insert(tk.END, original_text) box.insert(tk.END, original_text)
box.edit_modified(False) box.edit_modified(False)
except Exception as e: except Exception as e:
original_text = ""
box.insert(tk.END, f"Error reading file:\n{e}") box.insert(tk.END, f"Error reading file:\n{e}")
modified = {"changed": False} modified = {"changed": False}
def mark_modified(event=None): def mark_modified(event=None):
if box.edit_modified(): if box.edit_modified():
modified["changed"] = True modified["changed"] = True
box.edit_modified(False) box.edit_modified(False)
if EDITOR_ENABLED: if EDITOR_ENABLED:
box.bind("<<Modified>>", mark_modified) box.bind("<<Modified>>", mark_modified)
else: else:
box.configure(state="disabled") box.configure(state="disabled")
frame = tk.Frame(win)
frame.pack(fill="x", pady=10)
def save_file(): def save_file():
try: try:
with open(path, "w", errors="ignore") as f: with open(path, "w", errors="ignore") as f:
f.write(box.get("1.0", tk.END)) f.write(box.get("1.0", tk.END))
modified["changed"] = False modified["changed"] = False
custom_message("Saved", f"File saved:\n{path}") custom_messagebox("Saved", f"File saved:\n{path}")
except Exception as e: except Exception as e:
custom_message("Save Error", str(e)) custom_messagebox("Save Error", str(e))
if EDITOR_ENABLED: if EDITOR_ENABLED:
tk.Button(frame, text="Save", fg="green", font=(TEXT_FONT, BUTTON_SIZE_SAVE), command=save_file).pack(side="left", padx=10) tk.Button(frame, text="Save", fg="green", font=("Consolas", 18), padx=15, pady=8, command=save_file).pack(side="left", padx=10, pady=10)
def restore_file(): def restore_file():
if EDITOR_ENABLED and modified["changed"]: if EDITOR_ENABLED and modified["changed"]:
ask = custom_yesno("Unsaved Changes", "You have unsaved changes.\nSave before restoring?") ask = custom_messagebox("Unsaved Changes", "You have unsaved changes.\nSave before restoring?", kind="yesno")
if ask: if ask:
save_file() save_file()
try: try:
rel_path = os.path.relpath(path, TRASH_DIR) rel_path = os.path.relpath(path, TRASH_DIR)
dest_path = os.path.join(SEARCH_ROOT, rel_path) dest_path = os.path.join(SEARCH_ROOT, rel_path)
os.makedirs(os.path.dirname(dest_path), exist_ok=True) os.makedirs(os.path.dirname(dest_path), exist_ok=True)
shutil.move(path, dest_path) shutil.move(path, dest_path)
custom_message("Restored", f"File restored to:\n{dest_path}")
custom_messagebox("Restored", f"File restored to:\n{dest_path}")
win.destroy()
on_close_callback()
except Exception as e: except Exception as e:
custom_message("Restore Error", str(e)) custom_messagebox("Restore Error", str(e))
tk.Button(frame, text="Restore File", fg="blue", font=("Consolas", 18), padx=15, pady=8, command=restore_file).pack(side="left", padx=10, pady=10)
def close(): def close():
if EDITOR_ENABLED and modified["changed"]: if EDITOR_ENABLED and modified["changed"]:
ask = custom_yesno("Unsaved Changes", "You have unsaved changes.\nSave before closing?") ask = custom_messagebox("Unsaved Changes", "You have unsaved changes.\nSave before closing?", kind="yesno")
if ask: if ask:
save_file() save_file()
win.destroy() win.destroy()
on_close_callback() on_close_callback()
tk.Button(frame, text="Close", font=("Consolas", 18), padx=15, pady=8, command=close).pack(side="right", padx=10, pady=10)
def close_all_button():
ask = custom_messagebox("WARNING!", "Are you sure you want to close all windows?", kind="yesno")
if ask:
close_all(win.master)
if CLOSE_ALL_ENABLED:
tk.Button(frame, text="Close All", font=("Consolas", 18), padx=15, pady=8, command=close_all_button).pack(side="right", padx=10, pady=10)
def auto_close(): def auto_close():
if win.winfo_exists(): if win.winfo_exists():
win.destroy() win.destroy()
on_close_callback() on_close_callback()
win.protocol("WM_DELETE_WINDOW", close) win.protocol("WM_DELETE_WINDOW", close)
win.after(AUTO_CLOSE_SECONDS * 1000, auto_close) win.after(AUTO_CLOSE_SECONDS * 1000, auto_close)
tk.Button(frame, text="Restore File", fg="blue", font=(TEXT_FONT, BUTTON_SIZE_CLOSE), command=restore_file).pack(side="left", padx=10)
tk.Button(frame, text="Close", font=(TEXT_FONT, BUTTON_SIZE_CLOSE), command=close).pack(side="right", padx=10) def close_all(root):
for w in root.winfo_children():
try:
w.destroy()
except:
pass
root.destroy()
def main(): def main():
root = tk.Tk() root = tk.Tk()
root.withdraw() root.withdraw()
while True: default_font = tkfont.nametofont("TkDefaultFont")
result = popup_search_input() default_font.configure(family="Consolas", size=18)
search_term = result["value"]
if result["force_close"]: text_font = tkfont.nametofont("TkTextFont")
text_font.configure(family="Consolas", size=18)
fixed_font = tkfont.nametofont("TkFixedFont")
fixed_font.configure(family="Consolas", size=18)
while True:
search_term = popup_search_input()
if not search_term:
root.destroy() root.destroy()
return return
if not search_term:
custom_message("Invalid Search", "Please enter a search term.")
continue
matches = search_files(search_term) matches = search_files(search_term)
if not matches:
custom_message("No Results", "No matching files found.") if matches:
continue break
break
custom_messagebox("No Results", "No matching files found.")
selected = popup_results_list(matches) selected = popup_results_list(matches)
if not selected: if not selected:
@@ -310,16 +291,17 @@ def main():
return return
open_windows = {"count": len(selected)} open_windows = {"count": len(selected)}
def window_closed(): def window_closed():
open_windows["count"] -= 1 open_windows["count"] -= 1
if open_windows["count"] == 0: if open_windows["count"] == 0:
root.destroy() root.destroy()
for path in selected: for path in selected:
popup_file_preview(path, window_closed) popup_file_preview(path, window_closed)
root.mainloop() root.mainloop()
if __name__ == "__main__": if __name__ == "__main__":
main() main()
+379 -409
View File
@@ -1,410 +1,380 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
import os import os
import tkinter as tk import tkinter as tk
from tkinter import scrolledtext from tkinter import filedialog, messagebox, scrolledtext
import shutil import tkinter.font as tkfont
import ctypes import shutil
import string import ctypes
import configparser import string
import Indexer import configparser
# ============================================================
# CONFIG: # ============================================================
config = configparser.ConfigParser() # CONFIG:
config.read(r"C:\ProgramData\Program-Search\config.ini") config = configparser.ConfigParser()
# PATHS config.read(r"C:\ProgramData\Program-Search\config.ini")
SEARCH_ROOT = config["Paths"]["SEARCH_ROOT"] SEARCH_WINDOW_SIZE = config["General"]["SEARCH_WINDOW_SIZE"]
TRASH_DIR = config["Paths"]["TRASH_DIR"] RESULTS_WINDOW_SIZE = config["General"]["RESULTS_WINDOW_SIZE"]
INDEX_FILE = config["Paths"]["INDEX_FILE"] PREVIEW_WINDOW_SIZE = config["General"]["PREVIEW_WINDOW_SIZE"]
# FEATURES SEARCH_ROOT = config["Paths"]["SEARCH_ROOT"]
TRASH_ENABLED = config.getboolean("Features", "TRASH_ENABLED", fallback=False) TRASH_DIR = config["Paths"]["TRASH_DIR"]
EDITOR_ENABLED = config.getboolean("Features", "EDITOR_ENABLED", fallback=False) TRASH_ENABLED = config.getboolean("Features", "TRASH_ENABLED")
AUTO_CLOSE_SECONDS = config.getint("Features", "AUTO_CLOSE_SECONDS", fallback=3600) EDITOR_ENABLED = config.getboolean("Features", "EDITOR_ENABLED")
# COPY MANUEAL_REPLACE_ENABLED = config.getboolean("Features", "MANUEAL_REPLACE_ENABLED")
EXTENSION = config.get("Copy", "Extension", fallback="") CLOSE_ALL_ENABLED = config.getboolean("Features", "CLOSE_ALL_ENABLED")
# UI AUTO_CLOSE_SECONDS = config.getint("Features", "AUTO_CLOSE_SECONDS")
TEXT_FONT = config.get("UI","TEXT_FONT", fallback="Consolas") Extension = config["Copy"]["Extension"]
SEARCH_WIDTH = config.getint("UI", "SEARCH_WIDTH", fallback=400) # ============================================================
SEARCH_HEIGHT = config.getint("UI", "SEARCH_HEIGHT", fallback=150)
SEARCH_FONT_SIZE = config.getint("UI", "SEARCH_FONT_SIZE", fallback=12)
RESULTS_WIDTH = config.getint("UI", "RESULTS_WIDTH", fallback=1000) os.makedirs(TRASH_DIR, exist_ok=True)
RESULTS_HEIGHT = config.getint("UI", "RESULTS_HEIGHT", fallback=700)
RESULTS_FONT_SIZE = config.getint("UI", "RESULTS_FONT_SIZE", fallback=11)
PREVIEW_WIDTH = config.getint("UI", "PREVIEW_WIDTH", fallback=1200) def custom_messagebox(title, message, kind="info"):
PREVIEW_HEIGHT = config.getint("UI", "PREVIEW_HEIGHT", fallback=900) win = tk.Toplevel()
PREVIEW_FONT_SIZE = config.getint("UI", "PREVIEW_FONT_SIZE", fallback=24) win.title(title)
ERROR_WIDTH = config.getint("UI", "ERROR_WIDTH", fallback=400) win.geometry(SEARCH_WINDOW_SIZE)
ERROR_HEIGHT = config.getint("UI", "ERROR_HEIGHT", fallback=100) win.grab_set()
ERROR_FONT_SIZE = config.getint("UI", "ERROR_FONT_SIZE", fallback=11) win.focus_force()
# BUTTONS frame = tk.Frame(win, padx=20, pady=20)
BUTTON_SIZE_SEARCH = config.getint("Buttons", "BUTTON_SIZE_SEARCH", fallback=15) frame.pack(expand=True, fill="both")
BUTTON_SIZE_OPEN = config.getint("Buttons", "BUTTON_SIZE_OPEN", fallback=15) center_window(win)
BUTTON_SIZE_SELECT_ALL = config.getint("Buttons", "BUTTON_SIZE_SELECT_ALL", fallback=15)
BUTTON_SIZE_SAVE = config.getint("Buttons", "BUTTON_SIZE_SAVE", fallback=15) tk.Label(frame, text=message, font=("Consolas", 24), wraplength=550).pack(pady=20)
BUTTON_SIZE_COPY = config.getint("Buttons", "BUTTON_SIZE_COPY", fallback=15) def close():
BUTTON_SIZE_TRASH = config.getint("Buttons", "BUTTON_SIZE_TRASH", fallback=15) win.destroy()
BUTTON_SIZE_CLOSE = config.getint("Buttons", "BUTTON_SIZE_CLOSE", fallback=15)
BUTTON_SIZE_MESSAGE = config.getint("Buttons", "BUTTON_SIZE_MESSAGE", fallback=15) if kind == "yesno":
BUTTON_SIZE_YES_NO = config.getint("Buttons", "BUTTON_SIZE_YES_NO", fallback=15) result = {"value": False}
# ============================================================ IsInfo = False
def yes():
os.makedirs(TRASH_DIR, exist_ok=True) result["value"] = True
win.destroy()
SEARCH_INDEX = Indexer.load_index()
if Indexer.update_index(SEARCH_INDEX): def no():
try: result["value"] = False
Indexer.save_index(SEARCH_INDEX) win.destroy()
except Exception:
pass tk.Button(frame, text="Yes", font=("Consolas", 24), padx=10, pady=10, command=yes).pack(side="left", padx=16)
tk.Button(frame, text="No", font=("Consolas", 24), padx=10, pady=10, command=no).pack(side="right", padx=16)
def find_external_drives():
drives = [] win.wait_window()
DRIVE_REMOVABLE = 2 return result["value"]
for letter in string.ascii_uppercase: else:
drive = f"{letter}:\\" tk.Button(frame, text="OK", font=("Consolas", 24), padx=10, pady=10, command=close).pack(pady=20)
if os.path.exists(drive): win.bind("<Return>", lambda event: close())
dtype = ctypes.windll.kernel32.GetDriveTypeW(drive) win.wait_window()
if dtype == DRIVE_REMOVABLE:
drives.append(drive)
def center_window(win):
return drives win.update_idletasks()
w = win.winfo_width()
h = win.winfo_height()
def popup_search_input(): sw = win.winfo_screenwidth()
win = tk.Toplevel() sh = win.winfo_screenheight()
win.title("Search") x = (sw // 2) - (w // 2)
win.geometry(f"{SEARCH_WIDTH}x{SEARCH_HEIGHT}") y = (sh // 2) - (h // 2)
win.geometry(f"{w}x{h}+{x}+{y}")
tk.Label(win, text="Enter part number or name:", font=(TEXT_FONT, SEARCH_FONT_SIZE)).pack(pady=10)
entry = tk.Entry(win, font=(TEXT_FONT, SEARCH_FONT_SIZE))
entry.pack(pady=5) def find_external_drives():
win.lift() drives = []
win.attributes("-topmost", True) DRIVE_REMOVABLE = 2
win.after(50, lambda: (entry.focus_set(), entry.icursor(tk.END)))
win.after(100, lambda: (win.attributes("-topmost"), False)) for letter in string.ascii_uppercase:
drive = f"{letter}:\\"
result = {"value": None, "force_close": False} if os.path.exists(drive):
dtype = ctypes.windll.kernel32.GetDriveTypeW(drive)
def submit(): if dtype == DRIVE_REMOVABLE:
result["value"] = entry.get().strip().lower() drives.append(drive)
win.destroy()
return drives
def force_close():
result["force_close"] = True
win.destroy() def close_all(root):
for w in root.winfo_children():
entry.bind("<Return>", lambda e: submit()) try:
tk.Button(win, text="Search", font=(TEXT_FONT, BUTTON_SIZE_SEARCH), command=submit).pack(pady=10) w.destroy()
except:
center_window(win,SEARCH_WIDTH, SEARCH_HEIGHT) pass
win.protocol("WM_DELETE_WINDOW", force_close) root.destroy()
win.wait_window()
return result
def popup_search_input():
win = tk.Toplevel()
def center_window(win, width, height): win.title("Search")
screen_width = win.winfo_screenwidth() win.geometry(SEARCH_WINDOW_SIZE)
screen_height = win.winfo_screenheight() center_window(win)
x = int((screen_width / 2) - (width / 2)) tk.Label(win, text="Enter program number, part number, or name:").pack(pady=10)
y = int((screen_height / 2) - (height / 2)) entry = tk.Entry(win)
entry.pack(pady=5)
win.geometry(f"{width}x{height}+{x}+{y}") entry.focus_set()
entry.bind("<Return>", lambda event: submit())
win.bind("<Return>", lambda event: submit())
def custom_message(title, message):
win = tk.Toplevel() result = {"value": None}
win.title(title)
win.protocol("WM_DELETE_WINDOW", win.destroy) def submit():
result["value"] = entry.get().strip().lower()
win.destroy()
tk.Label(win, text=message, font=(TEXT_FONT, ERROR_FONT_SIZE), wraplength=ERROR_WIDTH - 30, justify="center").pack(padx=15, pady=15)
tk.Button(win, text="Search", command=submit, padx=20, pady=20).pack(pady=60)
tk.Button(win, text="OK", font=(TEXT_FONT, BUTTON_SIZE_MESSAGE), command=win.destroy).pack(pady=10)
win.wait_window(); return result["value"]
win.bind("<Return>", lambda e: win.destroy())
center_window(win,ERROR_WIDTH, ERROR_HEIGHT) def search_files(term):
win.lift() matches = []
win.focus_force()
win.transient() for root, dirs, files in os.walk(SEARCH_ROOT):
win.grab_set() for fname in files:
win.update() path = os.path.join(root, fname)
win.wait_window() fname_lower = fname.lower()
filename_match = term in fname_lower
def custom_yesno(title, message): contents_match = False
win = tk.Toplevel()
win.title(title) try:
with open(path, "r", errors="ignore") as f:
result = {"value": False} if term in f.read().lower():
contents_match = True
tk.Label( except:
win, pass
text=message,
font=(TEXT_FONT, ERROR_FONT_SIZE), if filename_match or contents_match:
wraplength=ERROR_WIDTH - 30, matches.append(path)
justify="center"
).pack(padx=15, pady=15) return matches
button_frame = tk.Frame(win)
button_frame.pack(pady=10) def popup_results_list(matches):
win = tk.Toplevel()
def yes(): win.title("Matches Found")
result["value"] = True win.geometry(RESULTS_WINDOW_SIZE)
win.destroy() center_window(win)
def no(): tk.Label(win, text="Select files to preview:").pack(pady=10)
result["value"] = False
win.destroy() lb = tk.Listbox(win, selectmode=tk.MULTIPLE)
lb.pack(expand=True, fill="both")
tk.Button(button_frame, text="Yes", width=10, font=(TEXT_FONT, BUTTON_SIZE_YES_NO), command=yes).pack(side="left", padx=10)
tk.Button(button_frame, text="No", width=10, font=(TEXT_FONT, BUTTON_SIZE_YES_NO), command=no).pack(side="left", padx=10) for m in matches:
lb.insert(tk.END, m)
win.protocol("WM_DELETE_WINDOW", no)
center_window(win,ERROR_WIDTH, ERROR_HEIGHT) result = {"selected": []}
win.lift()
win.focus_force() def select_all():
win.grab_set() lb.select_set(0, tk.END)
win.wait_window() def submit():
sel = lb.curselection()
return result["value"] result["selected"] = [matches[i] for i in sel]
win.destroy()
def search_files(term): tk.Button(win, text="Open Selected", command=submit, padx=20, pady=10).pack(side ="right", padx=20, pady=10)
tk.Button(win, text="Select All", command=select_all, padx=20, pady=10).pack(side ="left", padx=20, pady=10)
term = term.lower()
lb.bind("<Return>", lambda event: submit())
matches = [] win.bind("<Return>", lambda event: submit())
for path, data in SEARCH_INDEX.items(): win.wait_window(); return result["selected"]
if term in data.get("filename"):
matches.append(path) def popup_file_preview(path, on_close_callback):
win = tk.Toplevel()
elif term in data.get("content", ""): win.title(path)
matches.append(path) win.geometry(PREVIEW_WINDOW_SIZE)
return matches box = scrolledtext.ScrolledText(win, wrap=tk.WORD)
box.pack(expand=True, fill="both")
def popup_results_list(matches): try:
win = tk.Toplevel() with open(path, "r", errors="ignore") as f:
win.title("Matches Found") original_text = f.read()
win.geometry(f"{RESULTS_WIDTH}x{RESULTS_HEIGHT}") box.insert(tk.END, original_text)
box.edit_modified(False)
tk.Label(win, text="Select files to preview:", font=(TEXT_FONT, RESULTS_FONT_SIZE)).pack(pady=10) except Exception as e:
original_text = ""
lb = tk.Listbox(win, selectmode=tk.MULTIPLE, font=(TEXT_FONT, RESULTS_FONT_SIZE)) box.insert(tk.END, f"Error reading file:\n{e}")
lb.pack(expand=True, fill="both")
lb.bind("<Return>", lambda e: submit()) modified = {"changed": False}
for m in matches: def mark_modified(event=None):
parent = os.path.basename(os.path.dirname(m)) if box.edit_modified():
filename = os.path.basename(m) modified["changed"] = True
display = f"{parent}\\{filename}" box.edit_modified(False)
lb.insert(tk.END, display)
if EDITOR_ENABLED:
result = {"selected": []} box.bind("<<Modified>>", mark_modified)
else:
def select_all(): box.configure(state="disabled")
lb.select_set(0, tk.END)
def submit(): frame = tk.Frame(win)
sel = lb.curselection() frame.pack(fill="x", pady=10)
if not sel:
custom_message("No Selection", "Please select at least 1 file.")
return def save_file():
result["selected"] = [matches[i] for i in sel] try:
win.destroy() with open(path, "w", errors="ignore") as f:
f.write(box.get("1.0", tk.END))
tk.Button(win, text="Open Selected", font=(TEXT_FONT, BUTTON_SIZE_OPEN), command=submit).pack(padx=10) modified["changed"] = False
tk.Button(win, text="Select All", font=(TEXT_FONT, BUTTON_SIZE_SELECT_ALL), command=select_all).pack(padx=10) custom_messagebox("Saved", f"File saved:\n{path}")
except Exception as e:
center_window(win,RESULTS_WIDTH, RESULTS_HEIGHT) custom_messagebox("Save Error", str(e))
win.lift()
win.focus_force() def copy_to_external():
win.wait_window() if EDITOR_ENABLED and modified["changed"]:
return result["selected"] ask = custom_messagebox("Unsaved Changes", "You have unsaved changes.\nSave before copying?", kind = "yesno")
if ask:
save_file()
def popup_file_preview(path, on_close_callback, preview_windows):
win = tk.Toplevel() drives = find_external_drives()
preview_windows.append(win) if not drives:
win.title(path) custom_messagebox("No External Drive Found", "No external drive detected."); return
height = min(PREVIEW_HEIGHT, win.winfo_screenheight() - 80)
win.geometry(f"{PREVIEW_WIDTH}x{height}") base_name = os.path.splitext(os.path.basename(path))[0]
win.bind("<Escape>", lambda e: close()) new_name = base_name + Extension
frame = tk.Frame(win) copied = []
frame.pack(side="bottom", fill="x") for d in drives:
try:
box = scrolledtext.ScrolledText(win, wrap=tk.WORD, font=(TEXT_FONT, PREVIEW_FONT_SIZE)) dest = os.path.join(d, new_name)
box.pack(expand=True, fill="both", padx=5, pady=10) shutil.copy2(path, dest)
copied.append(dest)
try: except Exception as e:
with open(path, "r", errors="ignore") as f: custom_messagebox("Copy Error", f"Could not copy to {d}:\n{e}")
original_text = f.read()
box.insert(tk.END, original_text) if copied:
box.edit_modified(False) custom_messagebox("Copied Successfully", "Copied to:\n\n" + "\n".join(copied))
except Exception as e: win.destroy()
original_text = "" on_close_callback()
box.insert(tk.END, f"Error reading file:\n{e}") close_all(win.master)
modified = {"changed": False} def move_to_trash():
confirm = custom_messagebox("Move to Trash",f"Are you sure you want to move this file to trash?\n\n{path}", kind = "yesno")
def mark_modified(event=None): if confirm:
if box.edit_modified(): try:
modified["changed"] = True rel_path = os.path.relpath(path, SEARCH_ROOT)
box.edit_modified(False) dest_path = os.path.join(TRASH_DIR, rel_path)
os.makedirs(os.path.dirname(dest_path), exist_ok=True)
if EDITOR_ENABLED: shutil.move(path, dest_path)
box.bind("<<Modified>>", mark_modified) custom_messagebox("Trashed", f"Moved to trash:\n{dest_path}")
else: win.destroy()
box.configure(state="disabled") on_close_callback()
except Exception as e:
custom_messagebox("Trash Error", str(e))
def save_file():
try: def manual_replace():
with open(path, "w", errors="ignore") as f: drives = find_external_drives()
f.write(box.get("1.0", tk.END)) if not drives: custom_messagebox("No External Drive Found","No external drive detected."); return
modified["changed"] = False base_name = os.path.splitext(os.path.basename(path))[0]
custom_message("Saved", f"File saved:\n{path}") new_name = base_name + Extension
except Exception as e: replacement_path = None
custom_message("Save Error", str(e)) for d in drives:
candidate = os.path.join(d, new_name)
if EDITOR_ENABLED: if os.path.exists(candidate): replacement_path = candidate;
tk.Button(frame, text="Save", fg="green", font=(TEXT_FONT, BUTTON_SIZE_SAVE), command=save_file).pack(side="left", padx=10) break
if not replacement_path: custom_messagebox("File Not Found",f"No replacement file named:\n\n{new_name}\n\nwas found on any external drive."); return
def copy_to_external(): try:
if EDITOR_ENABLED and modified["changed"]: with open(replacement_path,"r",errors="ignore") as f: new_contents = f.read()
ask = custom_yesno( except Exception as e: custom_messagebox("Read Error",f"Could not read replacement file:\n{e}"); return
"Unsaved Changes", try:
"You have unsaved changes.\nSave before copying?" with open(path,"w",errors="ignore") as f: f.write(new_contents)
) except Exception as e: custom_messagebox("Write Error",f"Could not overwrite original file:\n{e}"); return
if ask: box.delete("1.0",tk.END); box.insert(tk.END,new_contents); box.edit_modified(False); modified["changed"] = False
save_file() custom_messagebox("Replaced Successfully",f"File replaced using:\n{replacement_path}")
drives = find_external_drives() def close():
if not drives: if EDITOR_ENABLED and modified["changed"]:
custom_message("No External Drive Found", "No external drive detected.") ask = custom_messagebox("Unsaved Changes", "You have unsaved changes.\nSave before closing?", kind = "yesno")
return if ask:
save_file()
base_name = os.path.splitext(os.path.basename(path))[0]
new_name = base_name + EXTENSION win.destroy()
on_close_callback()
copied = []
for d in drives: def auto_close():
try: if win.winfo_exists():
dest = os.path.join(d, new_name) win.destroy()
shutil.copy2(path, dest) on_close_callback()
copied.append(dest)
except Exception as e: def close_all_button():
custom_message("Copy Error", f"Could not copy to {d}:\n{e}") ask = custom_messagebox("WARNING!", "Are you sure you want to cloose all windows?", kind = "yesno")
if ask:
if copied: close_all(win.master)
custom_message("Copied Successfully", "Copied to:\n\n" + "\n".join(copied))
win.destroy() win.protocol("WM_DELETE_WINDOW", close)
on_close_callback() win.after(AUTO_CLOSE_SECONDS * 1000, auto_close)
def move_to_trash(): if EDITOR_ENABLED:
confirm = custom_yesno( tk.Button(win, text="Save", fg="green", command=save_file, padx=15, pady=8).pack(side ="left",padx=10, pady=10)
"Move to Trash",
f"Are you sure you want to move this file to trash?\n\n{path}" if TRASH_ENABLED == True:
) tk.Button(win, text="Move to Trash", fg="red", command=move_to_trash, padx=15, pady=8).pack(side ="left",padx=10, pady=10)
if confirm:
try: tk.Button(win, text="Copy to External Drive", command=copy_to_external, padx=15, pady=8).pack(side ="left",padx=10, pady=10)
rel_path = os.path.relpath(path, SEARCH_ROOT)
dest_path = os.path.join(TRASH_DIR, rel_path) tk.Button(win, text="Close", command=close, padx=15, pady=8).pack(side ="right",padx=10, pady=10)
os.makedirs(os.path.dirname(dest_path), exist_ok=True)
shutil.move(path, dest_path) if CLOSE_ALL_ENABLED:
custom_message("Trashed", f"Moved to trash:\n{dest_path}") tk.Button(win, text="Close All", command=lambda: close_all_button(), padx=15, pady=8).pack(side ="right",padx=10, pady=10)
win.destroy()
on_close_callback() if MANUEAL_REPLACE_ENABLED == True:
except Exception as e: tk.Button(win, text="Replace from External Drive", command=manual_replace, padx=15, pady=8).pack(side ="right",padx=10, pady=10)
custom_message("Trash Error", str(e))
def close():
if EDITOR_ENABLED and modified["changed"]: def main():
ask = custom_yesno("Unsaved Changes","You have unsaved changes.\nSave before closing?") root = tk.Tk()
if ask: root.withdraw()
save_file() default_font = tkfont.nametofont("TkDefaultFont")
if win in preview_windows: default_font.configure(family="Consolas", size=18)
preview_windows.remove(win)
win.destroy() text_font = tkfont.nametofont("TkTextFont")
on_close_callback() text_font.configure(family="Consolas", size=18)
def auto_close(): fixed_font = tkfont.nametofont("TkFixedFont")
if win.winfo_exists(): fixed_font.configure(family="Consolas", size=18)
win.destroy()
on_close_callback() root.option_add("*Dialog.msg.font", "Consolas 18")
root.option_add("*Dialog.msg.width", 60)
def close_all(): root.option_add("*Dialog.msg.height", 10)
confirm = custom_yesno("Close All", "Close all preview windows?") root.option_add("*Dialog.msg.wrapLength", 600)
if not confirm:
return while True:
for preview in preview_windows[:]: search_term = popup_search_input()
try: if not search_term:
if preview.winfo_exists(): root.destroy()
preview.destroy() return
except tk.TclError:
pass matches = search_files(search_term)
preview_windows.clear()
if matches:
win.protocol("WM_DELETE_WINDOW", close) break
win.after(AUTO_CLOSE_SECONDS * 1000, auto_close)
custom_messagebox("No Results", "No matching files found.")
if TRASH_ENABLED:
tk.Button(frame, text="Move to Trash", fg="red", font=(TEXT_FONT, BUTTON_SIZE_TRASH), command=move_to_trash).pack(side="left", padx=10) selected = popup_results_list(matches)
if not selected:
tk.Button(frame, text="Copy to External Drive", fg="blue", font=(TEXT_FONT, BUTTON_SIZE_COPY), command=copy_to_external).pack(side="left", padx=10) root.destroy()
return
tk.Button(frame, text="Close", font=(TEXT_FONT, BUTTON_SIZE_CLOSE), command=close).pack(side="right", padx=10)
tk.Button(frame, text="Close all", font=(TEXT_FONT, BUTTON_SIZE_CLOSE), command=close_all).pack(side="right", padx=10) open_windows = {"count": len(selected)}
def main(): def window_closed():
root = tk.Tk() open_windows["count"] -= 1
root.withdraw() if open_windows["count"] == 0:
root.destroy()
while True:
result = popup_search_input()
search_term = result["value"] for path in selected:
popup_file_preview(path, window_closed)
if result["force_close"]:
root.destroy() root.mainloop()
return
if not search_term:
custom_message("Invalid Search", "Please enter a search term.") if __name__ == "__main__":
continue
matches = search_files(search_term)
if not matches:
custom_message("No Results", "No matching files found.")
continue
break
selected = popup_results_list(matches)
if not selected:
root.destroy()
return
open_windows = {"count": len(selected)}
preview_windows = []
def window_closed():
open_windows["count"] -= 1
if open_windows["count"] == 0:
root.destroy()
for path in selected:
popup_file_preview(path, window_closed, preview_windows)
root.mainloop()
if __name__ == "__main__":
main() main()
+18
View File
@@ -0,0 +1,18 @@
[General]
SEARCH_WINDOW_SIZE = 600x300
RESULTS_WINDOW_SIZE = 1200x1000
PREVIEW_WINDOW_SIZE = 900x1000
[Paths]
SEARCH_ROOT = C:\CNCPrograms\Programs
TRASH_DIR = C:\CNCPrograms\Trash
[Features]
TRASH_ENABLED = False
EDITOR_ENABLED = False
MANUEAL_REPLACE_ENABLED = False
CLOSE_ALL_ENABLED = True
AUTO_CLOSE_SECONDS = 300
[Copy]
Extension =