sqlbench 0.1.27__tar.gz → 0.1.28__tar.gz

{sqlbench-0.1.27 → sqlbench-0.1.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbench
-Version: 0.1.27
+Version: 0.1.28
 Summary: A multi-database SQL workbench with support for IBM i, MySQL, and PostgreSQL
 Project-URL: Homepage, https://github.com/jpsteil/sqlbench
 Project-URL: Repository, https://github.com/jpsteil/sqlbench

{sqlbench-0.1.27 → sqlbench-0.1.28}/sqlbench/app.py

@@ -1625,71 +1625,79 @@ class SQLBenchApp:
         self.db.set_setting("window_geometry", geometry)
 
     def _save_layout(self):
-        """Save paned window sash positions."""
+        """Save paned window sash positions as ratios for reliable restore."""
         try:
-            # Main paned window (connections | tabs)
+            # Main paned window (connections | tabs) - horizontal, save as ratio of width
             sash_pos = self.main_paned.sashpos(0)
-            self.db.set_setting("layout_main_sash", str(sash_pos))
+            pane_width = self.main_paned.winfo_width()
+            if pane_width > 100:
+                ratio = sash_pos / pane_width
+                self.db.set_setting("layout_main_ratio", f"{ratio:.4f}")
         except Exception:
             pass
 
-        # Save tab-level layouts (use last found position for each type)
-        sql_sash = None
-        spool_sash = None
-
+        # Save tab-level layouts as ratios
         for tab_id in self.notebook.tabs():
             try:
                 tab_frame = self.notebook.nametowidget(tab_id)
                 if hasattr(tab_frame, 'sql_tab') and hasattr(tab_frame.sql_tab, 'paned'):
-                    sql_sash = tab_frame.sql_tab.paned.sashpos(0)
-                elif hasattr(tab_frame, 'spool_tab') and hasattr(tab_frame.spool_tab, 'paned'):
-                    spool_sash = tab_frame.spool_tab.paned.sashpos(0)
+                    sash_pos = tab_frame.sql_tab.paned.sashpos(0)
+                    pane_height = tab_frame.sql_tab.paned.winfo_height()
+                    if pane_height > 100:
+                        ratio = sash_pos / pane_height
+                        self.db.set_setting("layout_sql_ratio", f"{ratio:.4f}")
+                    break  # Only need one SQL tab's position
             except Exception:
                 pass
 
-        if sql_sash is not None:
-            self.db.set_setting("layout_sql_sash", str(sql_sash))
-        if spool_sash is not None:
-            self.db.set_setting("layout_spool_sash", str(spool_sash))
+        for tab_id in self.notebook.tabs():
+            try:
+                tab_frame = self.notebook.nametowidget(tab_id)
+                if hasattr(tab_frame, 'spool_tab') and hasattr(tab_frame.spool_tab, 'paned'):
+                    sash_pos = tab_frame.spool_tab.paned.sashpos(0)
+                    pane_width = tab_frame.spool_tab.paned.winfo_width()
+                    if pane_width > 100:
+                        ratio = sash_pos / pane_width
+                        self.db.set_setting("layout_spool_ratio", f"{ratio:.4f}")
+                    break  # Only need one spool tab's position
+            except Exception:
+                pass
 
     def _restore_layout(self):
-        """Restore paned window sash positions."""
+        """Restore paned window sash positions from saved ratios."""
+        self.root.update_idletasks()
+
+        # Restore main paned (connections | tabs) from ratio
         try:
-            sash_pos = self.db.get_setting("layout_main_sash")
-            if sash_pos:
-                self.root.update_idletasks()
-                self.main_paned.sashpos(0, int(sash_pos))
+            ratio_str = self.db.get_setting("layout_main_ratio")
+            if ratio_str:
+                ratio = float(ratio_str)
+                pane_width = self.main_paned.winfo_width()
+                if pane_width > 100 and 0.05 <= ratio <= 0.95:
+                    sash_pos = int(ratio * pane_width)
+                    self.main_paned.sashpos(0, sash_pos)
         except Exception:
             pass
 
-        # Restore tab-level layouts (only if saved value is reasonable)
-        sql_sash = self.db.get_setting("layout_sql_sash")
-        spool_sash = self.db.get_setting("layout_spool_sash")
-
-        # Ignore sash positions that are too small (would hide the pane)
-        MIN_SASH_POS = 50
+        # Restore SQL tab sash from ratio
+        sql_ratio_str = self.db.get_setting("layout_sql_ratio")
+        spool_ratio_str = self.db.get_setting("layout_spool_ratio")
 
         for tab_id in self.notebook.tabs():
             try:
                 tab_frame = self.notebook.nametowidget(tab_id)
-                if sql_sash and hasattr(tab_frame, 'sql_tab') and hasattr(tab_frame.sql_tab, 'paned'):
-                    self.root.update_idletasks()
+                if sql_ratio_str and hasattr(tab_frame, 'sql_tab') and hasattr(tab_frame.sql_tab, 'paned'):
+                    ratio = float(sql_ratio_str)
                     pane_height = tab_frame.sql_tab.paned.winfo_height()
-                    sash_val = int(sql_sash)
-                    # Only apply bounds if pane is fully laid out (height > 300)
-                    if pane_height > 300:
-                        max_sash = pane_height - 150
-                        sash_val = max(MIN_SASH_POS, min(sash_val, max_sash))
-                    tab_frame.sql_tab.paned.sashpos(0, sash_val)
-                elif spool_sash and hasattr(tab_frame, 'spool_tab') and hasattr(tab_frame.spool_tab, 'paned'):
-                    self.root.update_idletasks()
-                    pane_height = tab_frame.spool_tab.paned.winfo_height()
-                    sash_val = int(spool_sash)
-                    # Only apply bounds if pane is fully laid out (height > 300)
-                    if pane_height > 300:
-                        max_sash = pane_height - 150
-                        sash_val = max(MIN_SASH_POS, min(sash_val, max_sash))
-                    tab_frame.spool_tab.paned.sashpos(0, sash_val)
+                    if pane_height > 100 and 0.1 <= ratio <= 0.9:
+                        sash_pos = int(ratio * pane_height)
+                        tab_frame.sql_tab.paned.sashpos(0, sash_pos)
+                elif spool_ratio_str and hasattr(tab_frame, 'spool_tab') and hasattr(tab_frame.spool_tab, 'paned'):
+                    ratio = float(spool_ratio_str)
+                    pane_width = tab_frame.spool_tab.paned.winfo_width()
+                    if pane_width > 100 and 0.1 <= ratio <= 0.9:
+                        sash_pos = int(ratio * pane_width)
+                        tab_frame.spool_tab.paned.sashpos(0, sash_pos)
             except Exception:
                 pass
 
@@ -1701,10 +1709,13 @@ class SQLBenchApp:
 
     def _reset_layout(self):
         """Reset layout to defaults."""
-        # Clear saved layout settings
+        # Clear saved layout settings (both old and new format)
         self.db.set_setting("layout_main_sash", "")
         self.db.set_setting("layout_sql_sash", "")
         self.db.set_setting("layout_spool_sash", "")
+        self.db.set_setting("layout_main_ratio", "")
+        self.db.set_setting("layout_sql_ratio", "")
+        self.db.set_setting("layout_spool_ratio", "")
 
         # Reset font size to default
         self.font_size = 10

{sqlbench-0.1.27 → sqlbench-0.1.28}/sqlbench/tabs/sql_tab.py

@@ -2606,14 +2606,35 @@ class SQLTab:
         self.sql_context_menu.add_separator()
         self.sql_context_menu.add_command(label="Find...", command=self._show_sql_search_dialog, accelerator="Ctrl+F")
 
-        self.sql_text.bind("<Button-3>", self._show_sql_context_menu)
+        self.sql_text.bind("<ButtonPress-3>", self._save_selection_for_context_menu)
+        self.sql_text.bind("<ButtonRelease-3>", self._show_sql_context_menu)
         self.sql_text.bind("<Control-f>", lambda e: self._show_sql_search_dialog())
         self.sql_text.bind("<Control-F>", lambda e: self._show_sql_search_dialog())
         self.sql_text.bind("<Control-z>", lambda e: self._sql_undo())
         self.sql_text.bind("<Control-Z>", lambda e: self._sql_redo())  # Ctrl+Shift+Z
+        self.sql_text.bind("<Control-v>", self._on_paste)
+        self.sql_text.bind("<Control-V>", self._on_paste)
+
+    def _on_paste(self, event):
+        """Handle paste to replace selection like a normal editor."""
+        self._sql_paste()
+        return "break"  # Prevent default paste behavior
+
+    def _save_selection_for_context_menu(self, event):
+        """Save selection before right-click clears it."""
+        try:
+            self._saved_selection = (self.sql_text.index("sel.first"), self.sql_text.index("sel.last"))
+        except tk.TclError:
+            self._saved_selection = None
+        return "break"  # Prevent default behavior from clearing selection
 
     def _show_sql_context_menu(self, event):
         """Show context menu at mouse position."""
+        # Restore selection if it was saved (right-click clears it)
+        if hasattr(self, '_saved_selection') and self._saved_selection:
+            self.sql_text.tag_remove("sel", "1.0", "end")
+            self.sql_text.tag_add("sel", self._saved_selection[0], self._saved_selection[1])
+
         # Enable/disable undo based on edit history
         try:
             self.sql_text.edit_undo()
@@ -2638,6 +2659,7 @@ class SQLTab:
             self.sql_context_menu.entryconfig("Paste", state=tk.DISABLED)
 
         self.sql_context_menu.tk_popup(event.x_root, event.y_root, 0)
+        return "break"  # Prevent default behavior that moves cursor/deselects
 
     def _sql_undo(self):
         """Undo last edit."""
@@ -2660,33 +2682,65 @@ class SQLTab:
     def _sql_cut(self):
         """Cut selected text to clipboard."""
         try:
-            selected = self.sql_text.get("sel.first", "sel.last")
-            self.app.root.clipboard_clear()
-            self.app.root.clipboard_append(selected)
-            self.sql_text.delete("sel.first", "sel.last")
+            # Use saved selection from context menu if available
+            if hasattr(self, '_saved_selection') and self._saved_selection:
+                sel_start, sel_end = self._saved_selection
+                selected = self.sql_text.get(sel_start, sel_end)
+                self.app.root.clipboard_clear()
+                self.app.root.clipboard_append(selected)
+                self.sql_text.delete(sel_start, sel_end)
+                self._saved_selection = None
+            else:
+                selected = self.sql_text.get("sel.first", "sel.last")
+                self.app.root.clipboard_clear()
+                self.app.root.clipboard_append(selected)
+                self.sql_text.delete("sel.first", "sel.last")
         except tk.TclError:
             pass  # No selection
 
     def _sql_copy(self):
         """Copy selected text to clipboard."""
         try:
-            selected = self.sql_text.get("sel.first", "sel.last")
-            self.app.root.clipboard_clear()
-            self.app.root.clipboard_append(selected)
+            # Use saved selection from context menu if available
+            if hasattr(self, '_saved_selection') and self._saved_selection:
+                sel_start, sel_end = self._saved_selection
+                selected = self.sql_text.get(sel_start, sel_end)
+                self.app.root.clipboard_clear()
+                self.app.root.clipboard_append(selected)
+                self._saved_selection = None
+            else:
+                selected = self.sql_text.get("sel.first", "sel.last")
+                self.app.root.clipboard_clear()
+                self.app.root.clipboard_append(selected)
         except tk.TclError:
             pass  # No selection
 
     def _sql_paste(self):
         """Paste text from clipboard."""
         try:
-            # Delete selection if any
-            try:
-                self.sql_text.delete("sel.first", "sel.last")
-            except tk.TclError:
-                pass
+            # Mark undo separator before paste
+            self.sql_text.edit_separator()
+
+            # Delete selection if any (check saved selection from context menu first)
+            deleted = False
+            if hasattr(self, '_saved_selection') and self._saved_selection:
+                # Use saved selection from context menu
+                self.sql_text.delete(self._saved_selection[0], self._saved_selection[1])
+                self.sql_text.mark_set("insert", self._saved_selection[0])
+                self._saved_selection = None
+                deleted = True
+            if not deleted:
+                try:
+                    self.sql_text.delete("sel.first", "sel.last")
+                except tk.TclError:
+                    pass
             # Get clipboard content and insert
             text = self.app.root.clipboard_get()
             self.sql_text.insert("insert", text)
+
+            # Mark undo separator after paste and update highlighting
+            self.sql_text.edit_separator()
+            self._highlight_sql()
         except tk.TclError:
             pass  # Nothing in clipboard
 

{sqlbench-0.1.27 → sqlbench-0.1.28}/sqlbench/version.py

@@ -4,7 +4,7 @@ import threading
 import urllib.request
 import json
 
-__version__ = "0.1.27"
+__version__ = "0.1.28"
 
 
 def get_installed_version():