Port Calculate activity to GTK4

This commit fully ports the Calculate activity to GTK4 and Sugar4.

- Port 'shareable_activity.py' with updated DBus and Sugar4 base classes.
- Rework 'layout.py' to use GTK4 box packing ('append', 'set_child') instead of deprecated containers like 'Gtk.Table'.
- Replace legacy per-widget styling ('modify_bg', 'modify_font') with semantic CSS classes ('calc-button', 'calc-numpad-btn', 'calc-operator-btn', 'calc-action-btn') to be painted by sugar-artwork's GTK4 theme.
- Use 'sugar_style.apply_css_to_widget()' for dynamic per-user XoColor styling on equation history and variable text views.
- Replace StackSwitcher with proper Sugar4 ToolbarBox architecture using ToolbarButton with icon resolution (local SVG fallback).
- Add EventControllerKey on text_entry and calculator buttons.
- Refactor 'toolbars.py' to gracefully render GTK4 toolbar items and correctly update text fallbacks when SVG icons are invalid.
- Port 'calculate.py' to use 'Gtk.EventControllerKey' for keystrokes and update clipboard operations to use GTK4 async mechanisms.
- Include 'main.py' standalone bootstrapper for isolated GTK4 testing.

Author: Inuth0603

calculate.py

@@ -26,13 +26,14 @@
 _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 sugar4.graphics import style as sugar_style
 
 from shareable_activity import ShareableActivity
 from layout import CalcLayout
@@ -64,8 +65,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
 
 
@@ -194,7 +194,7 @@ def create_lasteq_textbuf(self):
         tagsmallnarrow = buf.create_tag(font=CalcLayout.FONT_SMALL_NARROW)
         tagbignarrow = buf.create_tag(font=CalcLayout.FONT_BIG_NARROW)
         tagbigger = buf.create_tag(font=CalcLayout.FONT_BIGGER)
-        tagjustright = buf.create_tag(justification=Gtk.Justification.RIGHT)
+        tagjustright = buf.create_tag(justification=Gtk.Justification.LEFT)
         tagred = buf.create_tag(foreground='#FF0000')
 
         # Add label and equation
@@ -244,32 +244,50 @@ 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)
+        
+        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;
+            min-height: 20px;
+        }
+        """ % (stroke_color, fill_color, stroke_color, fill_color)
+        
+        sugar_style.apply_css_to_widget(w, css_str)
+        
         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'
+                                justification=Gtk.Justification.LEFT)
+        
+        # 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
@@ -279,13 +297,22 @@ def create_history_object(self):
         eqnstr = '%s\n' % str(self.equation)
         self.append_with_superscript_tags(buf, eqnstr, tagsmall)
 
-        resstr = self.ml.format_number(self.result)
-        resstr = str(resstr).rstrip('0').rstrip('.') \
-            if '.' in resstr else resstr
+        try:
+            resstr = self.ml.format_number(self.result)
+        except Exception:
+            resstr = str(self.result)
+            
+        resstr = str(resstr)
+        resstr = resstr.rstrip('0').rstrip('.') if '.' in resstr else resstr
+        
+        if not resstr or resstr == "None":
+             resstr = "0"
+
         if len(resstr) > 30:
             restag = tagsmall
         else:
             restag = tagbig
+            
         self.append_with_superscript_tags(buf, resstr, restag)
 
         buf.apply_tag(tagcolor, buf.get_start_iter(), buf.get_end_iter())
@@ -374,23 +401,28 @@ 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()
+        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()
@@ -399,7 +431,7 @@ def __init__(self, handle):
 
         self.parser.log_debug_info()
 
-    def ignore_key_cb(self, widget, event):
+    def ignore_key_cb(self, controller, keyval, keycode, state):
         return True
 
     def cleanup_cb(self, arg):
@@ -427,14 +459,15 @@ def equation_pressed_cb(self, eqn):
     def set_last_equation(self, eqn):
         """Set the 'last equation' TextView."""
 
-        if self.last_eq_sig is not None:
-            self.layout.last_eq.disconnect(self.last_eq_sig)
-            self.last_eq_sig = None
+        if self.last_eqn_controller is not None:
+            self.layout.last_eq.remove_controller(self.last_eqn_controller)
+            self.last_eqn_controller = None
 
         if not isinstance(eqn.result, ParserError):
-            self.last_eq_sig = self.layout.last_eq.connect(
-                'button-press-event',
-                lambda a1, a2, e: self.equation_pressed_cb(e), eqn)
+            self.last_eqn_controller = Gtk.GestureClick.new()
+            self.last_eqn_controller.set_button(0)
+            self.last_eqn_controller.connect('pressed', lambda gesture, n_press, x, y: self.equation_pressed_cb(eqn))
+            self.layout.last_eq.add_controller(self.last_eqn_controller)
 
         self.layout.last_eq.set_buffer(eqn.create_lasteq_textbuf())
 
@@ -490,8 +523,10 @@ def add_equation(self, eq, prepend=False, drawlasteq=False, tree=None):
 
         own = (eq.owner == self.get_owner_id())
         w = eq.create_history_object()
-        w.connect('button-press-event', lambda w,
-                  e: self.equation_pressed_cb(eq))
+        click_gesture = Gtk.GestureClick.new()
+        click_gesture.set_button(0)
+        click_gesture.connect('pressed', lambda gesture, n_press, x, y: self.equation_pressed_cb(eq))
+        w.add_controller(click_gesture)
         if drawlasteq:
             self.set_last_equation(eq)
 
@@ -551,7 +586,7 @@ def process(self):
                            self.get_owner_id(), ml=self.ml)
             self.set_error_equation(eqn)
         else:
-            eqn = Equation(label, _n(s), _n(str(res)), self.color,
+            eqn = Equation(label, _n(s), res, self.color,
                            self.get_owner_id(), ml=self.ml)
             self.add_equation(eqn, drawlasteq=True, tree=tree)
             self.send_message("add_eq", value=str(eqn))
@@ -576,28 +611,38 @@ def create_var_textview(self, name, value):
         if name in reserved:
             return None
         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()))
+        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;
+        }
+        """ % (fill_color, stroke_color, fill_color, stroke_color)
+        sugar_style.apply_css_to_widget(w, css_str)
+
         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()
 
-        # 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 = Gdk.color_parse('white')
+        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 = Gdk.color_parse('black')
+            col = 'black'
 
         tag = buf.create_tag(font=CalcLayout.FONT_SMALL_NARROW,
                              foreground=col)
@@ -792,67 +837,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("Error pasting text: %s", 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'
-            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)
+    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:
-                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)
@@ -970,14 +1014,3 @@ def format_insert_ans(self):
             return self.ml.format_number(ans)
         else:
             return ''
-
-
-def main():
-    win = Gtk.Window(Gtk.WindowType.TOPLEVEL)
-    Calculate(win)
-    Gtk.main()
-    return 0
-
-
-if __name__ == "__main__":
-    main()