Merge branch 'main' into tkinter-text-sync

Author: serhiy-storchaka

Doc/library/tkinter.rst

@@ -5475,6 +5475,20 @@ Widget classes
       inserted or deleted.
       Otherwise set the flag to the boolean *arg*.
 
+   .. method:: edit_canundo()
+
+      Return ``True`` if there is an edit action on the undo stack that can be
+      undone, and ``False`` otherwise.
+
+      .. versionadded:: next
+
+   .. method:: edit_canredo()
+
+      Return ``True`` if there is an edit action on the redo stack that can be
+      reapplied, and ``False`` otherwise.
+
+      .. versionadded:: next
+
    .. method:: edit_undo()
 
       Undo the most recent edit action, that is, all the inserts and deletes

Doc/whatsnew/3.16.rst

@@ -147,6 +147,11 @@ shlex
 tkinter
 -------
 
+* Added new :class:`!tkinter.Text` methods :meth:`~tkinter.Text.edit_canundo`
+  and :meth:`~tkinter.Text.edit_canredo` which return whether an undo or redo
+  is possible.
+  (Contributed by Serhiy Storchaka in :gh:`151674`.)
+
 * Added new :class:`!tkinter.Text` methods :meth:`~tkinter.Text.sync` and
   :meth:`~tkinter.Text.pendingsync` which control and report the
   synchronization of the displayed view with the underlying text.

Lib/test/test_tkinter/test_font.py

@@ -21,6 +21,7 @@ def setUpClass(cls):
             cls.font = font.Font(root=cls.root, name=fontname, exists=False)
 
     def test_configure(self):
+        self.assertEqual(self.font.config, self.font.configure)
         options = self.font.configure()
         self.assertGreaterEqual(set(options),
             {'family', 'size', 'weight', 'slant', 'underline', 'overstrike'})
@@ -36,6 +37,26 @@ def test_configure(self):
             self.assertIsInstance(options[key], sizetype)
             self.assertIsInstance(self.font.cget(key), sizetype)
             self.assertIsInstance(self.font[key], sizetype)
+        self.assertRaisesRegex(tkinter.TclError, 'bad option "-spam"',
+                               self.font.cget, 'spam')
+        self.assertRaisesRegex(tkinter.TclError, 'bad option "-spam"',
+                               self.font.configure, spam='x')
+        self.assertRaises(TypeError, self.font.cget)
+        self.assertRaises(TypeError, self.font.cget, 'size', 'weight')
+
+    def test_copy(self):
+        f = font.Font(root=self.root, family='Times', size=10, weight='bold')
+        copied = f.copy()
+        self.assertIsInstance(copied, font.Font)
+        self.assertIsNot(copied, f)
+        self.assertNotEqual(copied.name, f.name)
+        self.assertEqual(copied.actual(), f.actual())
+        # The copy is independent of the original.
+        sizetype = int if self.wantobjects else str
+        copied.configure(size=20)
+        self.assertEqual(f.cget('size'), sizetype(10))
+        self.assertEqual(copied.cget('size'), sizetype(20))
+        self.assertRaises(TypeError, f.copy, 'x')
 
     def test_unicode_family(self):
         family = 'MS \u30b4\u30b7\u30c3\u30af'
@@ -60,6 +81,9 @@ def test_actual(self):
         for key in 'size', 'underline', 'overstrike':
             self.assertIsInstance(options[key], sizetype)
             self.assertIsInstance(self.font.actual(key), sizetype)
+        self.assertRaisesRegex(tkinter.TclError, 'bad option "-spam"',
+                               self.font.actual, 'spam')
+        self.assertRaises(TypeError, self.font.actual, 'size', 'weight', 'slant')
 
     def test_name(self):
         self.assertEqual(self.font.name, fontname)
@@ -83,15 +107,24 @@ def test_equality(self):
 
     def test_measure(self):
         self.assertIsInstance(self.font.measure('abc'), int)
+        self.assertEqual(self.font.measure(''), 0)
+        self.assertIsInstance(
+            self.font.measure('abc', displayof=self.root), int)
+        self.assertRaises(TypeError, self.font.measure)
+        self.assertRaises(TypeError, self.font.measure, 'a', 'b', 'c')
 
     def test_metrics(self):
         metrics = self.font.metrics()
         self.assertGreaterEqual(set(metrics),
             {'ascent', 'descent', 'linespace', 'fixed'})
         for key in metrics:
             self.assertEqual(self.font.metrics(key), metrics[key])
+            self.assertEqual(self.font.metrics(key, displayof=self.root),
+                             metrics[key])
             self.assertIsInstance(metrics[key], int)
             self.assertIsInstance(self.font.metrics(key), int)
+        self.assertRaisesRegex(tkinter.TclError, 'bad metric "-spam"',
+                               self.font.metrics, 'spam')
 
     def test_families(self):
         families = font.families(self.root)

Lib/test/test_tkinter/test_images.py

@@ -288,6 +288,11 @@ def test_configure_width_height(self):
         image.configure(height=10)
         self.assertEqual(image['width'], '20')
         self.assertEqual(image['height'], '10')
+        self.assertEqual(image.cget('width'), image['width'])
+        self.assertEqual(image.cget('height'), image['height'])
+        self.assertRaises(TypeError, image.cget)
+        self.assertRaises(TypeError, image.cget, 'width', 'height')
+        self.assertEqual(image.config, image.configure)
         self.assertEqual(image.width(), 20)
         self.assertEqual(image.height(), 10)
 
@@ -656,6 +661,14 @@ def test_transparency(self):
         self.assertEqual(image.transparency_get(4, 6), True)
         image.transparency_set(4, 6, False)
         self.assertEqual(image.transparency_get(4, 6), False)
+        self.assertRaises(tkinter.TclError, image.transparency_get, -1, 0)
+        self.assertRaises(tkinter.TclError, image.transparency_get, 16, 0)
+        self.assertRaises(tkinter.TclError, image.transparency_set, -1, 0, True)
+        self.assertRaises(tkinter.TclError, image.transparency_set, 16, 0, True)
+        self.assertRaises(TypeError, image.transparency_get, 0)
+        self.assertRaises(TypeError, image.transparency_get, 0, 0, 0)
+        self.assertRaises(TypeError, image.transparency_set, 0, 0)
+        self.assertRaises(TypeError, image.transparency_set, 0, 0, True, 0)
 
 
 if __name__ == "__main__":

Lib/test/test_tkinter/test_misc.py

@@ -7,6 +7,7 @@
 from tkinter import TclError
 import enum
 from test import support
+from test.support import os_helper
 from test.test_tkinter.support import setUpModule  # noqa: F401
 from test.test_tkinter.support import (AbstractTkTest, AbstractDefaultRootTest,
                                        requires_tk, get_tk_patchlevel)
@@ -357,6 +358,19 @@ def test_option(self):
         self.root.option_clear()
         self.assertEqual(b.option_get('background', 'Background'), '')
 
+    def test_option_readfile(self):
+        self.addCleanup(self.root.option_clear)
+        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+        with open(os_helper.TESTFN, 'w') as f:
+            f.write('*Button.background: red\n')
+        self.root.option_readfile(os_helper.TESTFN)
+        b = tkinter.Button(self.root)
+        self.assertEqual(b.option_get('background', 'Background'), 'red')
+        self.assertRaises(TclError, self.root.option_readfile,
+                          os_helper.TESTFN + '.nonexistent')
+        self.assertRaises(TypeError, self.root.option_readfile)
+        self.assertRaises(TypeError, self.root.option_readfile, 'a', 'b', 'c')
+
     def test_nametowidget(self):
         b = tkinter.Button(self.root, name='btn')
         self.assertIs(self.root.nametowidget('btn'), b)
@@ -417,6 +431,38 @@ def test_bell(self):
         self.root.bell()  # No exception.
         self.root.bell(displayof=self.root)
 
+    def test_tk_focusNext_focusPrev(self):
+        f = tkinter.Frame(self.root)
+        f.pack()
+        entries = [tkinter.Entry(f) for _ in range(3)]
+        for entry in entries:
+            entry.pack()
+        # tk_focusNext skips widgets that are not viewable.
+        entries[-1].wait_visibility()
+        self.assertIs(entries[0].tk_focusNext(), entries[1])
+        self.assertIs(entries[1].tk_focusNext(), entries[2])
+        self.assertIs(entries[2].tk_focusPrev(), entries[1])
+        self.assertIs(entries[1].tk_focusPrev(), entries[0])
+        self.assertRaises(TypeError, entries[0].tk_focusNext, 'x')
+        self.assertRaises(TypeError, entries[0].tk_focusPrev, 'x')
+
+    def test_tk_strictMotif(self):
+        self.addCleanup(self.root.tk_strictMotif, False)
+        self.assertIs(self.root.tk_strictMotif(), False)
+        self.assertIs(self.root.tk_strictMotif(True), True)
+        self.assertIs(self.root.tk_strictMotif(), True)
+        self.assertIs(self.root.tk_strictMotif(False), False)
+        self.assertRaises(TypeError, self.root.tk_strictMotif, 1, 2)
+
+    def test_tk_bisque(self):
+        # tk_bisque resets the color palette; use a separate root so that
+        # the shared one is not affected.
+        root = tkinter.Tk()
+        self.addCleanup(root.destroy)
+        root.tk_bisque()
+        self.assertEqual(root['background'], '#ffe4c4')
+        self.assertRaises(TypeError, root.tk_bisque, 'x')
+
     def test_event_repr_defaults(self):
         e = tkinter.Event()
         e.serial = 12345
@@ -819,6 +865,13 @@ def test_wm_iconbitmap(self):
 
         t.destroy()
 
+    def test_wm_iconphoto(self):
+        t = tkinter.Toplevel(self.root)
+        img = tkinter.PhotoImage(master=t, width=16, height=16)
+        t.wm_iconphoto(False, img)  # No exception.
+        t.wm_iconphoto(True, img)
+        self.assertRaises(tkinter.TclError, t.wm_iconphoto, False, 'spam')
+
     def test_wm_title(self):
         t = tkinter.Toplevel(self.root)
         t.title('Hello')

Lib/test/test_tkinter/test_scrolledtext.py

@@ -0,0 +1,65 @@
+import unittest
+import tkinter
+from tkinter.scrolledtext import ScrolledText
+from test.support import requires
+from test.test_tkinter.support import setUpModule  # noqa: F401
+from test.test_tkinter.support import AbstractTkTest
+
+requires('gui')
+
+
+class ScrolledTextTest(AbstractTkTest, unittest.TestCase):
+
+    def create(self, **kwargs):
+        st = ScrolledText(self.root, **kwargs)
+        self.addCleanup(st.destroy)
+        return st
+
+    def test_create(self):
+        st = self.create(background='red', height=5)
+        # It is a Text widget held in a Frame together with a Scrollbar.
+        self.assertIsInstance(st, tkinter.Text)
+        self.assertIsInstance(st.frame, tkinter.Frame)
+        self.assertIsInstance(st.vbar, tkinter.Scrollbar)
+        self.assertEqual(st.winfo_parent(), str(st.frame))
+        # str() returns the frame, so that geometry managers manage it.
+        self.assertEqual(str(st), str(st.frame))
+        # Keyword options configure the Text.
+        self.assertEqual(str(st['background']), 'red')
+        self.assertEqual(st['height'], 5 if self.wantobjects else '5')
+
+    def test_text_methods(self):
+        st = self.create()
+        st.insert('1.0', 'hello\nworld')
+        self.assertEqual(st.get('1.0', 'end-1c'), 'hello\nworld')
+        self.assertEqual(st.index('end-1c'), '2.5')
+        st.delete('1.0', 'end')
+        self.assertEqual(st.get('1.0', 'end-1c'), '')
+
+    def test_geometry_methods(self):
+        st = self.create()
+        # configure is not redirected; it configures the Text.
+        st.configure(height=8)
+        self.assertEqual(st['height'], 8 if self.wantobjects else '8')
+        # Pack, Grid and Place methods are redirected to the frame.
+        st.pack()
+        self.root.update()
+        self.assertEqual(st.frame.winfo_manager(), 'pack')
+        self.assertEqual(st.pack_info(), st.frame.pack_info())
+        st.pack_forget()
+        self.assertEqual(st.frame.winfo_manager(), '')
+
+    def test_scrollbar(self):
+        st = self.create(height=5)
+        st.pack()
+        st.insert('1.0', '\n'.join(map(str, range(100))))
+        self.root.update()
+        # The scrollbar tracks the text view.
+        self.assertEqual(st.vbar.get(), st.yview())
+        st.yview_moveto(1.0)
+        self.root.update()
+        self.assertEqual(st.vbar.get()[1], 1.0)
+
+
+if __name__ == "__main__":
+    unittest.main()

Lib/test/test_tkinter/test_text.py

@@ -318,6 +318,29 @@ def test_edit_undo_redo(self):
         text.edit_reset()
         self.assertRaises(TclError, text.edit_undo)
 
+    def test_edit_canundo_canredo(self):
+        text = self.text
+        text.configure(undo=True)
+
+        self.assertIs(text.edit_canundo(), False)
+        self.assertIs(text.edit_canredo(), False)
+
+        text.insert('1.0', 'spam')
+        self.assertIs(text.edit_canundo(), True)
+        self.assertIs(text.edit_canredo(), False)
+
+        text.edit_undo()
+        self.assertIs(text.edit_canundo(), False)
+        self.assertIs(text.edit_canredo(), True)
+
+        text.edit_redo()
+        self.assertIs(text.edit_canundo(), True)
+        self.assertIs(text.edit_canredo(), False)
+
+        text.edit_reset()
+        self.assertIs(text.edit_canundo(), False)
+        self.assertIs(text.edit_canredo(), False)
+
     def test_dump(self):
         text = self.text
         text.insert('1.0', 'hello')

Lib/test/test_tkinter/test_variables.py

@@ -111,13 +111,15 @@ def test_initialize(self):
         self.assertFalse(v.side_effect)
         v.set("value")
         self.assertTrue(v.side_effect)
+        self.assertEqual(Variable.initialize, Variable.set)
 
     def test_trace_old(self):
         if tcl_version >= (9, 0):
             self.skipTest('requires Tcl version < 9.0')
         # Old interface
         v = Variable(self.root)
         vname = str(v)
+        self.assertEqual(v.trace, v.trace_variable)
         trace = []
         def read_tracer(*args):
             trace.append(('read',) + args)
@@ -328,6 +330,7 @@ def test_set(self):
         self.assertEqual(self.root.globalgetvar("name"), false)
         v.set("on")
         self.assertEqual(self.root.globalgetvar("name"), true)
+        self.assertEqual(BooleanVar.initialize, BooleanVar.set)
 
     def test_invalid_value_domain(self):
         false = 0 if self.root.wantobjects() else "0"

Lib/tkinter/__init__.py

@@ -3970,6 +3970,22 @@ def edit(self, *args):
         """
         return self.tk.call(self._w, 'edit', *args)
 
+    def edit_canredo(self):
+        """Return whether redo is possible.
+
+        Return True if redo is possible, i.e. when the redo stack is
+        not empty, and False otherwise.
+        """
+        return self.tk.getboolean(self.edit("canredo"))
+
+    def edit_canundo(self):
+        """Return whether undo is possible.
+
+        Return True if undo is possible, i.e. when the undo stack is
+        not empty, and False otherwise.
+        """
+        return self.tk.getboolean(self.edit("canundo"))
+
     def edit_modified(self, arg=None):
         """Get or Set the modified flag
 

Misc/NEWS.d/next/Library/2026-06-19-12-00-00.gh-issue-151674.FCYTvs.rst

@@ -0,0 +1,3 @@
+Add the :meth:`~tkinter.Text.edit_canundo` and :meth:`~tkinter.Text.edit_canredo`
+methods of :class:`!tkinter.Text`, wrapping the Tk ``edit canundo`` and
+``edit canredo`` subcommands.