tedit 2.7.2__tar.gz → 2.8.0__tar.gz

{tedit-2.7.2 → tedit-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tedit
-Version: 2.7.2
+Version: 2.8.0
 Summary: TE: a cross-platform terminal text editor with mouse support and syntax highlighting
 Project-URL: Homepage, https://github.com/alby13/TE-Text-Editor
 Author-email: alby13 <alby13@singularityon.com>

{tedit-2.7.2 → tedit-2.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tedit"
-version = "2.7.2" # must be > 0.9.1
+version = "2.8.0" # must be > 2.7.2
 description = "TE: a cross-platform terminal text editor with mouse support and syntax highlighting"
 readme = "README.md"
 requires-python = ">=3.9"

{tedit-2.7.2 → tedit-2.8.0}/src/tedit/__init__.py

@@ -1,4 +1,4 @@
-# TEdit / TE - Public Version 2.7.0 - Copyright 2024-26, All Rights Reserved.
+# TEdit / TE - Public Version 2.8.0 - Copyright 2024-26, All Rights Reserved.
 # Created by alby13 - https://github.com/alby13/TE-Text-Editor
 # Software provided 'as-is,' use at your own risk; creator assumes no liability.
 
@@ -23,6 +23,8 @@ class CursesFormatter(Formatter):
         self.color_map = {}  # token_type -> curses attr (fully pre-baked)
         self.next_color_pair = 1
         self.style = get_style_by_name(options.get('style', 'default'))
+        self.bg_color = options.get('bg_color', -1)
+        self.fg_color = options.get('fg_color', -1)
 
     def setup_colors(self):
         """Pre-bake a curses attr for every token type explicitly styled."""
@@ -45,8 +47,20 @@ class CursesFormatter(Formatter):
                 pair_num = seen_styles[style_key]
             elif self.next_color_pair <= max_pairs:
                 fg = self.hex_to_curses_color(style_info.get('color'))
+                if fg == -1:
+                    fg = self.fg_color
+
+                # No color at all — skip pair allocation, mark as unstyled
+                if fg == -1:
+                    attr = 0
+                    if style_info.get('bold'):      attr |= curses.A_BOLD
+                    if style_info.get('italic'):    attr |= curses.A_ITALIC
+                    if style_info.get('underline'): attr |= curses.A_UNDERLINE
+                    self.color_map[token] = attr
+                    continue
+
                 try:
-                    curses.init_pair(self.next_color_pair, fg, curses.COLOR_BLACK)
+                    curses.init_pair(self.next_color_pair, fg, self.bg_color)
                     pair_num = self.next_color_pair
                     self.next_color_pair += 1
                     seen_styles[style_key] = pair_num
@@ -66,8 +80,11 @@ class CursesFormatter(Formatter):
         if not hex_color:
             return -1
         hex_color = hex_color.lstrip('#')
+        if len(hex_color) == 3:
+            hex_color = hex_color[0]*2 + hex_color[1]*2 + hex_color[2]*2
         if len(hex_color) < 6:
             return -1
+            
         try:
             r = int(hex_color[0:2], 16)
             g = int(hex_color[2:4], 16)
@@ -351,13 +368,14 @@ class ColorsMenu:
             pass
 
 class FileBrowser:
-    def __init__(self, stdscr, start_dir=None):
+    def __init__(self, stdscr, start_dir=None, is_save_dialog=False):
         self.stdscr = stdscr
         self.current_dir = start_dir or os.getcwd()
         self.selected_item = 0
         self.top_item = 0
         self.items =[]
         self.show_all_files = False 
+        self.is_save_dialog = is_save_dialog
         self.refresh_items()
 
     TEXT_EXTENSIONS = {
@@ -452,7 +470,8 @@ class FileBrowser:
             pass
         
         # Draw title
-        title = f" File Browser: {os.path.basename(self.current_dir) or self.current_dir} "
+        title_prefix = " Save File: " if getattr(self, 'is_save_dialog', False) else " File Browser: "
+        title = f"{title_prefix}{os.path.basename(self.current_dir) or self.current_dir} "
         title_x = start_x + (browser_width - len(title)) // 2
         try:
             self.stdscr.addstr(start_y - 1, title_x, title, curses.A_BOLD)
@@ -533,7 +552,10 @@ class FileBrowser:
                 pass
         
         # Draw instructions
-        instructions = "↑↓: Navigate | Enter: Open | Esc: Cancel | Backspace: Parent | T: Toggle file type"
+        if getattr(self, 'is_save_dialog', False):
+            instructions = "↑↓: Navigate | Enter: Navigate/Overwrite | S: Save New File Here | Esc: Cancel"
+        else:
+            instructions = "↑↓: Navigate | Enter: Open | Esc: Cancel | Backspace: Parent | T: Toggle file type"
         try:
             self.stdscr.addstr(start_y + browser_height + 1, start_x, 
                              instructions[:browser_width], curses.A_DIM)
@@ -550,6 +572,16 @@ class FileBrowser:
         elif key == curses.KEY_DOWN:
             if self.selected_item < len(self.items) - 1:
                 self.selected_item += 1
+        elif key == curses.KEY_PPAGE:  # Page Up
+            height, _ = self.stdscr.getmaxyx()
+            page_size = max(1, height - 8 - 2)  # matches content_height in draw()
+            self.selected_item = max(0, self.selected_item - page_size)
+
+        elif key == curses.KEY_NPAGE:  # Page Down
+            height, _ = self.stdscr.getmaxyx()
+            page_size = max(1, height - 8 - 2)
+            self.selected_item = min(len(self.items) - 1, self.selected_item + page_size)
+
         elif key in (curses.KEY_BACKSPACE, 127, 8):
             parent_dir = os.path.dirname(self.current_dir)
             if parent_dir != self.current_dir:
@@ -557,11 +589,13 @@ class FileBrowser:
                 self.refresh_items()
                 self.selected_item = 0
                 self.top_item = 0
-        elif key in (ord('t'), ord('T')):          # ← ADD THIS
+        elif key in (ord('t'), ord('T')):
             self.show_all_files = not self.show_all_files
             self.refresh_items()
             self.selected_item = 0
             self.top_item = 0
+        elif key in (ord('s'), ord('S')) and getattr(self, 'is_save_dialog', False):
+            return f"SAVE_PROMPT:{self.current_dir}"
         elif key in [ord('\n'), ord('\r'), curses.KEY_ENTER, 459]:
             if self.items and self.selected_item < len(self.items):
                 selected = self.items[self.selected_item]
@@ -609,6 +643,10 @@ class FileBrowser:
             click_ratio = (my - start_y - 1) / max(1, track_height)
             self.top_item = int(click_ratio * max(0, len(self.items) - visible_items))
             self.top_item = max(0, min(self.top_item, len(self.items) - visible_items))
+            # Keep selected_item within the newly visible range
+            self.selected_item = max(self.top_item,
+                                     min(self.selected_item,
+                                         self.top_item + visible_items - 1))
             return None
 
         # Check if click is within browser window
@@ -654,7 +692,7 @@ class Menu:
         self.submenus = {
             "File":["New", "Open", "Save", "Save as", "Exit"],
             "Edit":["Undo", "Redo", "Cut", "Copy", "Paste", "Find"],
-            "Menu": ["Toggle Line Numbers", "Change Theme", "Colors"],
+            "Menu": ["Toggle Line Numbers", "Word Wrap", "Change Theme", "Colors"],
             "Help": ["User Manual", "About"],
             "Fun":["Print to Imaginary Printer", "Play a Game", "Coffee Break Simulator", "Provide Feedback", "Procrastination NOW!", "Write it for me"]
         }
@@ -818,6 +856,7 @@ class TextEditor:
         self.redo_stack =[]
 
         self.read_only = False
+        self.word_wrap = False
 
         # Find / Search
         self.last_search = ""     # Remembers the last search for quick "find next"
@@ -850,7 +889,7 @@ class TextEditor:
         try:
             sample = "\n".join(self.content[:100])
             self.lexer = guess_lexer(sample, **opts)
-        except ClassNotFound:
+        except Exception:
             self.lexer = get_lexer_by_name("text", **opts)
 
     def setup_colors(self):
@@ -864,7 +903,12 @@ class TextEditor:
         except curses.error:
             has_default_colors = False
 
-        self.formatter = CursesFormatter(style=self.color_theme, has_default_colors=has_default_colors)
+        self.formatter = CursesFormatter(
+            style=self.color_theme, 
+            has_default_colors=has_default_colors,
+            bg_color=self.editor_bg,
+            fg_color=self.editor_fg
+        )
         self.formatter.setup_colors()
 
         try:
@@ -991,8 +1035,9 @@ class TextEditor:
             self.draw_context_menu()
 
         # Draw status bars with horizontal offset info
-        h_info = f" +{self.left_column}" if self.left_column > 0 else ""
-        status = f"File: {self.current_file or 'Untitled'} | Ln {self.cursor_y + 1}, Col {self.cursor_x + 1}{h_info} | Theme: {self.color_theme}"
+        h_info = f" +{self.left_column}" if (self.left_column > 0 and not self.word_wrap) else ""
+        wrap_info = " | WRAP" if self.word_wrap else ""
+        status = f"File: {self.current_file or 'Untitled'} | Ln {self.cursor_y + 1}, Col {self.cursor_x + 1}{h_info}{wrap_info} | Theme: {self.color_theme}"
 
         if self.menu_focus:
             help_text = "MENU MODE: ←→ Select Menu | ↑↓ Navigate Items | Enter: Select | Esc: Close | F9: Edit Mode | Click text to edit"
@@ -1048,140 +1093,267 @@ class TextEditor:
     def position_cursor(self, height, width, line_num_width):
         """Comprehensive bounds checking with horizontal scroll support."""
         try:
-            # Calculate cursor screen position
-            screen_y = self.cursor_y - self.top_line + 1
-            screen_x = self.cursor_x - self.left_column + line_num_width
-            
-            # Ensure cursor is within valid screen boundaries
-            if (screen_y >= 1 and screen_y < height - 3 and 
-                screen_x >= line_num_width and screen_x < width):
-                self.stdscr.move(screen_y, screen_x)
+            if self.word_wrap:
+                # In wrap mode, find which visual screen_y the cursor lands on
+                available_width = width - line_num_width - 1
+                if available_width <= 0:
+                    return
+                screen_y = 1
+                found = False
+                line_idx = self.top_line
+                content_height = height - 4
+                while screen_y <= content_height and line_idx < len(self.content):
+                    if screen_y >= height - 3:
+                        break
+                    raw_line = self.content[line_idx]
+                    chunks = self._wrap_line(raw_line, available_width)
+                    if line_idx == self.cursor_y:
+                        # Find which chunk the cursor column falls in
+                        for col_start, col_end in chunks:
+                            if col_start <= self.cursor_x <= col_end or col_end == len(raw_line):
+                                screen_x = line_num_width + (self.cursor_x - col_start)
+                                if screen_y < height - 3 and screen_x < width:
+                                    self.stdscr.move(screen_y, screen_x)
+                                found = True
+                                break
+                            screen_y += 1
+                        break
+                    screen_y += len(chunks)
+                    line_idx += 1
+                if not found:
+                    try:
+                        self.stdscr.move(1, line_num_width)
+                    except curses.error:
+                        pass
             else:
-                # If cursor would be off-screen, place it at a safe position
-                safe_y = min(max(1, screen_y), height - 4)
-                safe_x = min(max(line_num_width, screen_x), width - 1)
-                self.stdscr.move(safe_y, safe_x)
+                screen_y = self.cursor_y - self.top_line + 1
+                screen_x = self.cursor_x - self.left_column + line_num_width
+
+                if (screen_y >= 1 and screen_y < height - 3 and
+                        screen_x >= line_num_width and screen_x < width):
+                    self.stdscr.move(screen_y, screen_x)
+                else:
+                    safe_y = min(max(1, screen_y), height - 4)
+                    safe_x = min(max(line_num_width, screen_x), width - 1)
+                    self.stdscr.move(safe_y, safe_x)
         except curses.error:
-            try: self.stdscr.move(1, line_num_width)
-            except curses.error: pass
+            try:
+                self.stdscr.move(1, line_num_width)
+            except curses.error:
+                pass
 
     def _ensure_cursor_visible(self):
         """Adjusts self.top_line and self.left_column to make sure the cursor is on screen."""
         height, width = self.stdscr.getmaxyx()
-        
+
         # --- Vertical Scrolling ---
         content_height = height - 3
         if self.cursor_y < self.top_line:
             self.top_line = self.cursor_y
         elif self.cursor_y >= self.top_line + content_height:
             self.top_line = self.cursor_y - content_height + 1
-            
+
+        if self.word_wrap:
+            # In wrap mode horizontal scrolling is meaningless — keep it zeroed
+            self.left_column = 0
+            return
+
         # --- Horizontal Scrolling ---
         line_num_width = 5 if self.show_line_numbers else 0
         available_width = width - line_num_width - 1
-        
+
         if self.cursor_x < self.left_column:
             self.left_column = self.cursor_x
         elif self.cursor_x >= self.left_column + available_width:
             self.left_column = self.cursor_x - available_width + 1
 
+    def _wrap_line(self, line, available_width):
+        """Split a document line into screen-width chunks for word wrap.
+        Returns a list of (start_col, end_col) slices into the original line."""
+        if available_width <= 0:
+            return [(0, len(line))] if line else [(0, 0)]
+        if not line:
+            return [(0, 0)]
+        chunks = []
+        start = 0
+        while start < len(line):
+            end = min(start + available_width, len(line))
+            # Try to break at a word boundary if mid-word
+            if end < len(line):
+                break_at = line.rfind(' ', start, end)
+                if break_at > start:
+                    end = break_at + 1  # include the space in this chunk
+            chunks.append((start, end))
+            start = end
+        return chunks if chunks else [(0, 0)]
+
+    def _lex_line(self, line, base_text_attr):
+        """Return a list of (char, attr) pairs for a single document line."""
+        if self.formatter:
+            token_stream = lex(line, self.lexer)
+            tokens = self.formatter.format(token_stream, None)
+        else:
+            tokens = [(line, base_text_attr)]
+        result = []
+        for text, attr in tokens:
+            # Use base_text_attr only when the token truly has NO color assigned (attr == 0)
+            final_attr = attr if attr != 0 else base_text_attr
+            for ch in text:
+                result.append((ch, final_attr))
+        return result
+
     def draw_content(self, height, width, line_num_width):
         """Handles drawing text with syntax highlighting and selection."""
         content_height = height - 4
-        
+
         if content_height <= 0 or width <= line_num_width:
             return
 
-        # Determine the base text attribute from the canvas pair (respects user color choices)
+        # Base attribute from canvas color pair
         if self.editor_bg != -1 or self.editor_fg != -1:
             base_text_attr = curses.color_pair(self._CANVAS_PAIR)
         else:
             base_text_attr = 0
 
-        # Lex the entire visible block for multi-line context
-        lines_tokens =[]
-        visible_lines = self.content[self.top_line : self.top_line + content_height]
+        available_width = width - line_num_width - 1
+        if available_width <= 0:
+            return
 
-        if self.formatter and visible_lines:
-            # Join visible lines and lex them as one continuous block
-            visible_text = "\n".join(visible_lines)
-            token_stream = lex(visible_text, self.lexer)
-            all_tokens = self.formatter.format(token_stream, None)
-            
-            # Split the resulting tokens back into individual lines based on '\n'
-            current_line_tokens =[]
-            for text, attr in all_tokens:
-                parts = text.split('\n')
-                for j, part in enumerate(parts):
-                    if j > 0:
-                        lines_tokens.append(current_line_tokens)
-                        current_line_tokens =[]
-                    if part:
-                        current_line_tokens.append((part, attr))
-            lines_tokens.append(current_line_tokens)
-
-            # Some lexers still forcibly append a newline despite ensurenl=False
-            if len(lines_tokens) == len(visible_lines) + 1 and not lines_tokens[-1]:
-                lines_tokens.pop()
-
-            # Bulletproof Fallback: If pygments somehow changed the number of lines 
-            # (e.g., stripping blank lines), revert to line-by-line lexing to guarantee cursor sync.
-            if len(lines_tokens) != len(visible_lines):
-                lines_tokens =[]
-                for line in visible_lines:
-                    token_stream = lex(line, self.lexer)
-                    lines_tokens.append(self.formatter.format(token_stream, None))
-        else:
-            # Fallback if no formatter
-            lines_tokens = [[(line, base_text_attr)] for line in visible_lines]
+        if self.word_wrap:
+            # ── WORD WRAP MODE ────────────────────────────────────────────────
+            # Walk document lines from top_line, emitting screen rows until full.
+            screen_y = 1
+            line_idx = self.top_line
 
-        for i in range(content_height):
-            line_idx = self.top_line + i
-            screen_y = i + 1
-            
-            if screen_y >= height - 3: break
-                
-            if line_idx < len(self.content):
-                try:
+            while screen_y <= content_height and line_idx < len(self.content):
+                if screen_y >= height - 3:
+                    break
+
+                raw_line = self.content[line_idx]
+                chunks = self._wrap_line(raw_line, available_width)
+                char_attrs = self._lex_line(raw_line, base_text_attr)
+
+                for chunk_num, (col_start, col_end) in enumerate(chunks):
+                    if screen_y > content_height or screen_y >= height - 3:
+                        break
+
+                    # Line number only on the first visual row of a doc line
                     if self.show_line_numbers and line_num_width <= width:
-                        self.stdscr.addstr(screen_y, 0, f"{line_idx + 1:4d} ", curses.A_DIM)
-                    
-                    available_width = width - line_num_width - 1
-                    if available_width <= 0: continue
-
-                    # Fetch the pre-calculated tokens for this specific line
-                    tokens = lines_tokens[i] if i < len(lines_tokens) else[]
-
-                    # 2. Unified drawing loop
-                    screen_x_pos = line_num_width
-                    line_x_pos = 0 # Tracks position in the actual document line
-
-                    for text, attr in tokens:
-                        if screen_x_pos >= width - 1:
-                            break # Screen is horizontally full, stop processing tokens
-
-                        for char_to_draw in text:
-                            # Only draw if the character is within the visible horizontal window
-                            if line_x_pos >= self.left_column:
-                                if screen_x_pos < width - 1:
-                                    # Merge the token attr with any canvas fg override
-                                    # final_attr = attr | base_text_attr if base_text_attr else attr
-                                    # PAIR_NUMBER extracts bits 8-23 from the attr value (portable, no PAIR_NUMBER needed)
-                                    pair_num = (attr >> 8) & 0xFF if attr else 0
-                                    final_attr = base_text_attr if pair_num == 0 else attr
-                                    # Handle text selection highlighting
-                                    if self.is_selected(line_idx, line_x_pos):
-                                        final_attr |= curses.A_REVERSE
-                                        
-                                    self.stdscr.addstr(screen_y, screen_x_pos, char_to_draw, final_attr)
-                                    screen_x_pos += 1
-                                else:
-                                    break # Reached the right edge
-                            
-                            line_x_pos += 1 # Always advance document index
-                        
-                except curses.error:
-                    continue
+                        if chunk_num == 0:
+                            try:
+                                self.stdscr.addstr(screen_y, 0,
+                                    f"{line_idx + 1:4d} ", curses.A_DIM)
+                            except curses.error:
+                                pass
+                        else:
+                            try:
+                                self.stdscr.addstr(screen_y, 0,
+                                    "     ", 0)  # blank gutter for continuation rows
+                            except curses.error:
+                                pass
+
+                    screen_x = line_num_width
+                    for doc_x in range(col_start, col_end):
+                        if screen_x >= width - 1:
+                            break
+                        if doc_x < len(char_attrs):
+                            ch, attr = char_attrs[doc_x]
+                        else:
+                            ch, attr = ' ', base_text_attr
+                        if self.is_selected(line_idx, doc_x):
+                            attr |= curses.A_REVERSE
+                        try:
+                            self.stdscr.addstr(screen_y, screen_x, ch, attr)
+                        except curses.error:
+                            pass
+                        screen_x += 1
+
+                    screen_y += 1
+
+                line_idx += 1
+
+        else:
+            # ── NORMAL (HORIZONTAL SCROLL) MODE ───────────────────────────────
+            # Lex the entire visible block for multi-line context
+            lines_tokens = []
+            visible_lines = self.content[self.top_line : self.top_line + content_height]
+
+            if self.formatter and visible_lines:
+                visible_text = "\n".join(visible_lines)
+                token_stream = lex(visible_text, self.lexer)
+                all_tokens = self.formatter.format(token_stream, None)
+
+                current_line_tokens = []
+                for text, attr in all_tokens:
+                    parts = text.split('\n')
+                    for j, part in enumerate(parts):
+                        if j > 0:
+                            lines_tokens.append(current_line_tokens)
+                            current_line_tokens = []
+                        if part:
+                            current_line_tokens.append((part, attr))
+                lines_tokens.append(current_line_tokens)
+
+                if len(lines_tokens) == len(visible_lines) + 1 and not lines_tokens[-1]:
+                    lines_tokens.pop()
+
+                if len(lines_tokens) != len(visible_lines):
+                    lines_tokens = []
+                    for line in visible_lines:
+                        token_stream = lex(line, self.lexer)
+                        lines_tokens.append(self.formatter.format(token_stream, None))
+            else:
+                lines_tokens = [[(line, base_text_attr)] for line in visible_lines]
+
+            for i in range(content_height):
+                line_idx = self.top_line + i
+                screen_y = i + 1
+
+                if screen_y >= height - 3:
+                    break
+
+                if line_idx < len(self.content):
+                    try:
+                        if self.show_line_numbers and line_num_width <= width:
+                            self.stdscr.addstr(screen_y, 0,
+                                f"{line_idx + 1:4d} ", curses.A_DIM)
+
+                        if available_width <= 0:
+                            continue
+
+                        tokens = lines_tokens[i] if i < len(lines_tokens) else []
+
+                        screen_x_pos = line_num_width
+                        line_x_pos = 0
+
+                        for text, attr in tokens:
+                            if screen_x_pos >= width - 1:
+                                break
+
+                            for char_to_draw in text:
+                                if line_x_pos >= self.left_column:
+                                    if screen_x_pos < width - 1:
+                                        final_attr = attr if attr != 0 else base_text_attr
+                                        if self.is_selected(line_idx, line_x_pos):
+                                            final_attr |= curses.A_REVERSE
+                                        self.stdscr.addstr(screen_y, screen_x_pos,
+                                            char_to_draw, final_attr)
+                                        screen_x_pos += 1
+                                    else:
+                                        break
+
+                                line_x_pos += 1
+
+                        # Scroll indicators
+                        indicator_attr = curses.A_BOLD | curses.A_REVERSE
+                        full_line = self.content[line_idx]
+                        if self.left_column > 0 and len(full_line) > self.left_column:
+                            self.stdscr.addstr(screen_y, line_num_width, '‹', indicator_attr)
+                        if len(full_line) > self.left_column + available_width:
+                            self.stdscr.addstr(screen_y, width - 2, '›', indicator_attr)
+
+                    except curses.error:
+                        continue
 
     def open_user_manual(self):
         """Opens the user_manual.txt file in a new, read-only buffer."""
@@ -1389,12 +1561,21 @@ class TextEditor:
         if not self.file_browser:
             self.browser_mode = False # Safety exit
             return
-        
+
+        # Define is_save before we clear
+        is_save = getattr(self.file_browser, 'is_save_dialog', False)
+
         result = None
         if key == curses.KEY_MOUSE:
             try:
-                _, mx, my, _, _ = curses.getmouse()
-                result = self.file_browser.handle_mouse(mx, my)
+                _, mx, my, _, bstate = curses.getmouse()
+                # Scroll wheel scrolls the list
+                if bstate & curses.BUTTON4_PRESSED:
+                    result = self.file_browser.handle_key(curses.KEY_PPAGE)
+                elif bstate & curses.BUTTON5_PRESSED:
+                    result = self.file_browser.handle_key(curses.KEY_NPAGE)
+                else:
+                    result = self.file_browser.handle_mouse(mx, my)
             except curses.error:
                 pass
         else:
@@ -1405,9 +1586,21 @@ class TextEditor:
             self.file_browser = None  # Clean up the browser instance
 
             if result == "CANCEL":
-                self.message = "Open file cancelled."
+                self.message = "Save cancelled." if is_save else "Open file cancelled."
+            elif isinstance(result, str) and result.startswith("SAVE_PROMPT:"):
+                dir_path = result.split("SAVE_PROMPT:", 1)[1]
+                dir_name = os.path.basename(dir_path) or dir_path
+                filename_input = self.get_user_input(f"Save As (in {dir_name}): ")
+                if filename_input and filename_input.strip() != "":
+                    full_path = os.path.join(dir_path, filename_input.strip())
+                    self._do_save(full_path, ask_overwrite=True)
+                else:
+                    self.message = "Save cancelled - no filename provided."
             else: # A filename was returned
-                self._load_file_content(result)
+                if is_save:
+                    self._do_save(result, ask_overwrite=True)
+                else:
+                    self._load_file_content(result)
 
     def handle_menu_input(self, key):
         action = None
@@ -1429,12 +1622,9 @@ class TextEditor:
                         self.message = "Returned to editing mode."
                         # Place cursor at the clicked location with accurate horizontal logic
                         line_num_width = 5 if self.show_line_numbers else 0
-                        clicked_y = min(max(0, self.top_line + my - 1), len(self.content) - 1)
+                        clicked_y, clicked_x = self._click_to_doc_pos(my, mx)
                         self.cursor_y = clicked_y
-                        if 0 <= clicked_y < len(self.content):
-                            self.cursor_x = min(max(0, mx - line_num_width + self.left_column), len(self.content[clicked_y]))
-                        else:
-                            self.cursor_x = 0
+                        self.cursor_x = clicked_x
                         self.clear_selection()
                         return # Event handled, no more processing needed
             except curses.error:
@@ -1474,8 +1664,7 @@ class TextEditor:
                 # Handle left-click actions in the content area
                 if my > 0 and my < height - 2:
                     line_num_width = 5 if self.show_line_numbers else 0
-                    clicked_y = min(max(0, self.top_line + my - 1), len(self.content) - 1)
-                    clicked_x = min(max(0, mx - line_num_width + self.left_column), len(self.content[clicked_y]))
+                    clicked_y, clicked_x = self._click_to_doc_pos(my, mx)
 
                     if bstate & curses.BUTTON1_CLICKED or bstate & curses.BUTTON1_PRESSED:
                         self.clear_selection()
@@ -1530,10 +1719,22 @@ class TextEditor:
             self.move_cursor(1, 0)
         elif key == curses.KEY_LEFT:
             self.clear_selection()
-            self.move_cursor(0, -1)
+            if self.cursor_x == 0 and self.cursor_y > 0:
+                # At the start of a line — jump up to the end of the previous line
+                self.cursor_y -= 1
+                self.cursor_x = len(self.content[self.cursor_y])
+                self._ensure_cursor_visible()
+            else:
+                self.move_cursor(0, -1)
         elif key == curses.KEY_RIGHT:
             self.clear_selection()
-            self.move_cursor(0, 1)
+            if self.cursor_x == len(self.content[self.cursor_y]) and self.cursor_y < len(self.content) - 1:
+                # At the end of a line — jump down to the start of the next line
+                self.cursor_y += 1
+                self.cursor_x = 0
+                self._ensure_cursor_visible()
+            else:
+                self.move_cursor(0, 1)
         elif key == curses.KEY_NPAGE:
             self.clear_selection()
             height, _ = self.stdscr.getmaxyx()
@@ -1815,6 +2016,10 @@ class TextEditor:
                 self.show_line_numbers = not self.show_line_numbers
                 self.message = f"Line numbers turned {'on' if self.show_line_numbers else 'off'}."
                 self._ensure_cursor_visible()
+            elif item == "Word Wrap":
+                self.word_wrap = not self.word_wrap
+                self.message = f"Word wrap {'on' if self.word_wrap else 'off'}."
+                self._ensure_cursor_visible()
             elif item == "Change Theme":
                 self.change_theme()
             elif item == "Colors":
@@ -1885,6 +2090,60 @@ class TextEditor:
             self.menu.open = False
             self.menu_focus = False
 
+    def _click_to_doc_pos(self, my, mx):
+        """Convert a mouse click at screen row my, col mx to (doc_y, doc_x).
+        Works correctly in both normal and word-wrap mode."""
+        height, width = self.stdscr.getmaxyx()
+        line_num_width = 5 if self.show_line_numbers else 0
+
+        if not self.word_wrap:
+            # Normal mode: simple 1-to-1 screen-row to doc-line mapping
+            doc_y = min(max(0, self.top_line + my - 1), len(self.content) - 1)
+            doc_x = min(max(0, mx - line_num_width + self.left_column),
+                        len(self.content[doc_y]))
+            return doc_y, doc_x
+
+        # Wrap mode: walk visual rows from top_line to find which doc line and
+        # which column within that line the click lands on.
+        available_width = width - line_num_width - 1
+        if available_width <= 0:
+            return 0, 0
+
+        screen_y = 1          # visual rows start at row 1 (row 0 is the menu bar)
+        content_height = height - 4
+
+        for line_idx in range(self.top_line, len(self.content)):
+            raw_line = self.content[line_idx]
+            chunks = self._wrap_line(raw_line, available_width)
+
+            for col_start, col_end in chunks:
+                if screen_y == my:
+                    # The click is on this visual row
+                    col_offset = mx - line_num_width          # chars from left edge
+                    doc_x = col_start + max(0, col_offset)
+                    doc_x = min(doc_x, col_end)               # clamp to chunk end
+                    doc_x = min(doc_x, len(raw_line))         # clamp to line length
+                    return line_idx, doc_x
+                screen_y += 1
+                if screen_y > content_height:
+                    # Clicked below all content — return end of last line
+                    last = len(self.content) - 1
+                    return last, len(self.content[last])
+
+        # Fallback
+        last = len(self.content) - 1
+        return last, len(self.content[last])
+
+        """Moves the cursor and ensures it's visible."""
+        # Calculate new y position
+        self.cursor_y = max(0, min(self.cursor_y + dy, len(self.content) - 1))
+        
+        # Calculate new x position, clamping to the new line's length
+        self.cursor_x = min(max(0, self.cursor_x + dx), len(self.content[self.cursor_y]))
+        
+        # Ensure the view scrolls if necessary
+        self._ensure_cursor_visible()
+
     def move_cursor(self, dy, dx):
         """Moves the cursor and ensures it's visible."""
         # Calculate new y position
@@ -1970,22 +2229,23 @@ class TextEditor:
     def save_file(self, save_as=False):
         """Save the current file with improved error handling and validation."""
         if self._check_read_only(): return
-        filename_to_save = None
         
         if not save_as and self.current_file:
-            filename_to_save = self.current_file
+            self._do_save(self.current_file, ask_overwrite=False)
         else:
-            filename_input = self.get_user_input("Save As: ")
-            if not filename_input or filename_input.strip() == "":
-                self.message = "Save cancelled - no filename provided."
+            start_dir = os.getcwd()
+            if self.current_file:
+                start_dir = os.path.dirname(self.current_file)
+                
+            self.file_browser = FileBrowser(self.stdscr, start_dir=start_dir, is_save_dialog=True)
+            self.browser_mode = True
+            self.message = "Choose location to save..."
+
+    def _do_save(self, filename_to_save, ask_overwrite=True):
+        if ask_overwrite and os.path.exists(filename_to_save):
+            if not self.get_user_confirmation(f"'{os.path.basename(filename_to_save)}' exists. Overwrite? (y/n)"):
+                self.message = "Save cancelled."
                 return
-            
-            filename_to_save = filename_input.strip()
-            
-            if os.path.exists(filename_to_save):
-                if not self.get_user_confirmation(f"'{os.path.basename(filename_to_save)}' exists. Overwrite? (y/n)"):
-                    self.message = "Save cancelled."
-                    return
         
         if not filename_to_save:
             self.message = "Save cancelled - invalid filename."
@@ -2028,7 +2288,8 @@ class TextEditor:
 
     def get_user_confirmation(self, prompt):
         """Displays a prompt and waits for a 'y' or 'n' response. Returns True for 'y', False otherwise."""
-        self.stdscr.nodelay(0)
+        # self.stdscr.nodelay(0) - previous code that probably doesn't wait long enough
+        self.stdscr.timeout(-1)  # Force infinite wait for the keystroke
         response = False
         try:
             # Re-draw the interface to ensure the prompt is on a clean screen
@@ -2054,7 +2315,8 @@ class TextEditor:
             pass # Ignore errors during confirmation
         finally:
             # Restore non-blocking input mode
-            self.stdscr.nodelay(1)
+            # self.stdscr.nodelay(1) - previous code that probably doesn't wait long enough
+            self.stdscr.timeout(50)
         return response
 
     def open_file(self):