Fix GTK4 Port: Layout, Focus Management, and Arrow Navigation

Author: Inuth0603

calculate.py

@@ -26,13 +26,13 @@
 _logger = logging.getLogger('Calculate')
 
 import gi
-gi.require_version('Gtk', '3.0')
+gi.require_version('Gtk', '4.0')
 from gi.repository import Gtk
 from gi.repository import Gdk
 import base64
 
-import sugar3.profile
-from sugar3.graphics.xocolor import XoColor
+import sugar4.profile
+from sugar4.graphics.xocolor import XoColor
 
 from shareable_activity import ShareableActivity
 from layout import CalcLayout
@@ -64,8 +64,7 @@ def findchar(text, chars, ofs=0):
 
 def _textview_realize_cb(widget):
     '''Change textview properties once window is created.'''
-    win = widget.get_window(Gtk.TextWindowType.TEXT)
-    win.set_cursor(Gdk.Cursor.new(Gdk.CursorType.HAND1))
+    widget.set_cursor_from_name("pointer")
     return False
 
 
@@ -244,32 +243,51 @@ def create_history_object(self):
             return self.result.get_image()
 
         w = Gtk.TextView()
-        w.modify_base(
-            Gtk.StateType.NORMAL, Gdk.color_parse(self.color.get_fill_color()))
-        w.modify_bg(
-            Gtk.StateType.NORMAL,
-            Gdk.color_parse(self.color.get_stroke_color()))
+        w.set_editable(False)
+        w.set_cursor_visible(False)
+        
+        provider = Gtk.CssProvider()
+        fill_color = self.color.get_fill_color()
+        stroke_color = self.color.get_stroke_color()
+        
+        css_str = """
+        textview {
+            background-color: %s;
+            color: %s;
+        }
+        textview text {
+            background-color: %s;
+            color: %s;
+        }
+        """ % (stroke_color, fill_color, stroke_color, fill_color)
+        
+        provider.load_from_data(css_str.encode())
+        w.get_style_context().add_provider(provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
+        
         w.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
-        w.set_border_window_size(Gtk.TextWindowType.LEFT, 4)
-        w.set_border_window_size(Gtk.TextWindowType.RIGHT, 4)
-        w.set_border_window_size(Gtk.TextWindowType.TOP, 4)
-        w.set_border_window_size(Gtk.TextWindowType.BOTTOM, 4)
+        w.set_left_margin(4)
+        w.set_right_margin(4)
+        w.set_top_margin(4)
+        w.set_bottom_margin(4)
         w.connect('realize', _textview_realize_cb)
         buf = w.get_buffer()
 
         tagsmall = buf.create_tag(font=CalcLayout.FONT_SMALL)
         tagsmallnarrow = buf.create_tag(font=CalcLayout.FONT_SMALL_NARROW)
         tagbig = buf.create_tag(font=CalcLayout.FONT_BIG,
                                 justification=Gtk.Justification.RIGHT)
-        # TODO Fix for old Sugar 0.82 builds, red_float not available
-        bright = (
-            Gdk.color_parse(self.color.get_fill_color()).red_float +
-            Gdk.color_parse(self.color.get_fill_color()).green_float +
-            Gdk.color_parse(self.color.get_fill_color()).blue_float) / 3.0
-        if bright < 0.5:
-            col = 'white'
+        
+        # Calculate brightness
+        c = Gdk.RGBA()
+        if c.parse(fill_color):
+            bright = (c.red + c.green + c.blue) / 3.0
+            if bright < 0.5:
+                col = 'white'
+            else:
+                col = 'black'
         else:
             col = 'black'
+            
         tagcolor = buf.create_tag(foreground=col)
 
         # Add label, equation and result
@@ -374,23 +392,29 @@ def __init__(self, handle):
         self.KEYMAP['divide'] = self.ml.div_sym
         self.KEYMAP['equal'] = self.ml.equ_sym
 
-        self.clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
+        self.clipboard = Gdk.Display.get_default().get_clipboard()
         self.select_reason = self.SELECT_SELECT
         self.buffer = ""
         self.showing_version = 0
         self.showing_error = False
         self.ans_inserted = False
         self.show_vars = False
 
-        self.connect("key_press_event", self.keypress_cb)
-        self.connect("destroy", self.cleanup_cb)
-        self.color = sugar3.profile.get_color()
+        # Input handling for GTK4
+        key_controller = Gtk.EventControllerKey()
+        key_controller.connect("key-pressed", self.keypress_cb)
+        self.add_controller(key_controller)
+        
+        # self.connect("destroy", self.cleanup_cb) # handled by activity?
+        
+        self.color = sugar4.profile.get_color()
 
         self.layout = CalcLayout(self)
         self.label_entry = self.layout.label_entry
         self.text_entry = self.layout.text_entry
         self.last_eq_sig = None
         self.last_eqn_textview = None
+        self.last_eqn_controller = None
 
         self.reset()
         self.layout.show_it()
@@ -792,67 +816,66 @@ def expand_selection(self, dir):
 
     def text_copy(self):
         if self.layout.graph_selected is not None:
-            self.clipboard.set_image(
-                self.layout.graph_selected.get_child().get_pixbuf())
-            self.layout.toggle_select_graph(self.layout.graph_selected)
+            # TODO: Port image copying for GTK4 (requires Texture)
+            pass
+            # texture = Gdk.Texture.new_for_pixbuf(self.layout.graph_selected.get_child().get_pixbuf())
+            # self.clipboard.set_texture(texture)
+            # self.layout.toggle_select_graph(self.layout.graph_selected)
         else:
             str = self.text_entry.get_text()
             sel = self.text_entry.get_selection_bounds()
             # _logger.info('text_copy, sel: %r, str: %s', sel, str)
             if len(sel) == 2:
                 (start, end) = sel
-                self.clipboard.set_text(str[start:end], -1)
+                self.clipboard.set_text(str[start:end])
 
     def text_select_all(self):
         end = self.text_entry.get_text_length()
         self.text_entry.select_region(0, end)
 
-    def get_clipboard_text(self):
-        text = self.clipboard.wait_for_text()
-        if text is None:
-            return ""
-        else:
-            return text
-
     def text_paste(self):
-        self.button_pressed(self.TYPE_TEXT, self.get_clipboard_text())
+        self.clipboard.read_text_async(None, self._on_paste_text_received, None)
+
+    def _on_paste_text_received(self, clipboard, result, user_data):
+        try:
+            text = clipboard.read_text_finish(result)
+            if text:
+                self.button_pressed(self.TYPE_TEXT, text)
+        except Exception as e:
+            _logger.error(f"Error pasting text: {e}")
 
     def text_cut(self):
         self.text_copy()
         self.remove_character(1)
 
-    def keypress_cb(self, widget, event):
-        if not self.text_entry.is_focus():
-            return
-
-        key = Gdk.keyval_name(event.keyval)
-        if event.hardware_keycode == 219:
-            if (event.get_state() & Gdk.ModifierType.SHIFT_MASK):
-                key = 'divide'
+    def keypress_cb(self, controller, keyval, keycode, state):
+        keyname = Gdk.keyval_name(keyval)
+        
+        is_ctrl = (state & Gdk.ModifierType.CONTROL_MASK)
+        is_shift = (state & Gdk.ModifierType.SHIFT_MASK) and not is_ctrl
+
+        if is_ctrl:
+            if keyname in self.CTRL_KEYMAP:
+                self.CTRL_KEYMAP[keyname](self)
+                return True
+        elif is_shift:
+            if keyname in self.SHIFT_KEYMAP:
+                self.SHIFT_KEYMAP[keyname](self)
+                return True
+
+        if "KP_" in keyname:
+            if keyname == "KP_Enter":
+                keyname = "Return"
+
+        if keyname in self.KEYMAP:
+            action = self.KEYMAP[keyname]
+            if callable(action):
+                action(self)
             else:
-                key = 'multiply'
-        _logger.debug('Key: %s (%r, %r)', key,
-                      event.keyval, event.hardware_keycode)
-
-        if event.get_state() & Gdk.ModifierType.CONTROL_MASK:
-            if key in self.CTRL_KEYMAP:
-                f = self.CTRL_KEYMAP[key]
-                return f(self)
-        elif (event.get_state() & Gdk.ModifierType.SHIFT_MASK) and \
-                key in self.SHIFT_KEYMAP:
-            f = self.SHIFT_KEYMAP[key]
-            return f(self)
-        elif str(key) in self.IDENTIFIER_CHARS:
-            self.button_pressed(self.TYPE_TEXT, key)
-        elif key in self.KEYMAP:
-            f = self.KEYMAP[key]
-            if isinstance(f, str) or \
-                    isinstance(f, str):
-                self.button_pressed(self.TYPE_TEXT, f)
-            else:
-                return f(self)
+                self.button_pressed(self.TYPE_TEXT, action)
+            return True
 
-        return True
+        return False
 
     def get_older(self):
         self.showing_version = max(0, self.showing_version - 1)
@@ -973,10 +996,15 @@ def format_insert_ans(self):
 
 
 def main():
-    win = Gtk.Window(Gtk.WindowType.TOPLEVEL)
-    Calculate(win)
-    Gtk.main()
-    return 0
+    app = Gtk.Application(application_id="org.laptop.Calculate.Test")
+    
+    def activate(app):
+        win = Calculate(None)
+        win.set_application(app)
+        win.present()
+        
+    app.connect("activate", activate)
+    app.run(None)
 
 
 if __name__ == "__main__":