Merge branch 'makeboxesoverhault'

Author: mmatera

mathics/builtin/__init__.py

@@ -85,7 +85,6 @@ def is_builtin(var):
 mathics_to_python = {}  # here we have: name -> string
 sympy_to_mathics = {}
 
-box_constructs = {}
 pattern_objects = {}
 builtins_precedence = {}
 
@@ -101,8 +100,6 @@ def add_builtins(new_builtins):
             mathics_to_sympy[name] = builtin
             for sympy_name in builtin.get_sympy_names():
                 sympy_to_mathics[sympy_name] = builtin
-        if isinstance(builtin, BoxConstruct):
-            box_constructs[name] = builtin
         if isinstance(builtin, Operator):
             builtins_precedence[name] = builtin.precedence
         if isinstance(builtin, PatternObject):

mathics/builtin/base.py

@@ -592,11 +592,101 @@ class BoxConstructError(Exception):
     pass
 
 
-class BoxConstruct(Builtin):
-    def get_option_values(self, leaves, evaluation=None, **options):
-        default = evaluation.definitions.get_options(self.get_name()).copy()
-        options = Expression("List", *leaves).get_option_values(evaluation)
-        default.update(options)
+class BoxConstruct(InstancableBuiltin):
+    def __new__(cls, *leaves, **kwargs):
+        instance = super().__new__(cls, *leaves, **kwargs)
+        instance._leaves = leaves
+        return instance
+
+    def evaluate(self, evaluation):
+        # Shall here evaluate the leaves?
+        return
+
+    def get_head_name(self):
+        return self.get_name()
+
+    def get_lookup_name(self):
+        return self.get_name()
+
+    def get_string_value(self):
+        return "-@" + self.get_head_name() + "@-"
+
+    def same(self, expr):
+        return expr.same(self)
+
+    def is_atom(self):
+        return False
+
+    def do_format(self, evaluation, format):
+        return self
+
+    def format(self, evaluation, fmt):
+        return self
+
+    def get_head(self):
+        return Symbol(self.get_name())
+
+    @property
+    def head(self):
+        return self.get_head()
+
+    @head.setter
+    def head(self, value):
+        raise ValueError('BoxConstruct.head is write protected.')
+
+    @property
+    def leaves(self):
+        return self._leaves
+
+    @leaves.setter
+    def leaves(self, value):
+        raise ValueError('BoxConstruct.leaves is write protected.')
+
+    # I need to repeat this, because this is not
+    # an expression...
+    def has_form(self, heads, *leaf_counts):
+        """
+        leaf_counts:
+            (,):        no leaves allowed
+            (None,):    no constraint on number of leaves
+            (n, None):  leaf count >= n
+            (n1, n2, ...):    leaf count in {n1, n2, ...}
+        """
+
+        head_name = self.get_name()
+        if isinstance(heads, (tuple, list, set)):
+            if head_name not in [ensure_context(h) for h in heads]:
+                return False
+        else:
+            if head_name != ensure_context(heads):
+                return False
+        if not leaf_counts:
+            return False
+        if leaf_counts and leaf_counts[0] is not None:
+            count = len(self._leaves)
+            if count not in leaf_counts:
+                if (len(leaf_counts) == 2 and   # noqa
+                    leaf_counts[1] is None and count >= leaf_counts[0]):
+                    return True
+                else:
+                    return False
+        return True
+
+    def flatten_pattern_sequence(self, evaluation)  -> 'BoxConstruct':
+        return self
+
+    def get_option_values(self, leaves, **options):
+        evaluation = options.get("evaluation", None)
+        if evaluation:
+            default = evaluation.definitions.get_options(self.get_name()).copy()
+            options = Expression("List", *leaves).get_option_values(evaluation)
+            default.update(options)
+        else:
+            from mathics.core.parser import parse_builtin_rule
+            default = {}
+            for option, value in self.options.items():
+                option = ensure_context(option)
+                default[option] = parse_builtin_rule(value)
         return default
 
     def boxes_to_text(self, leaves, **options) -> str:

mathics/builtin/compilation.py

@@ -149,20 +149,26 @@ def __hash__(self):
         return hash(("CompiledCode", ctypes.addressof(self.cfunc)))  # XXX hack
 
     def atom_to_boxes(self, f, evaluation):
-        return Expression('CompiledCodeBox')
+        return CompiledCodeBox(String("Nocode"))
 
 
 class CompiledCodeBox(BoxConstruct):
     """
     Used internally by <i>CompileCode[]</i>.
     """
-    def boxes_to_text(self, leaves, **options):
+    def boxes_to_text(self, leaves=None, **options):
+        if not leaves:
+            leaves = self._leaves
         return '-CompiledCode-'
 
-    def boxes_to_xml(self, leaves, **options):
+    def boxes_to_xml(self, leaves=None, **options):
+        if not leaves:
+            leaves = self._leaves
         return '-CompiledCode-'
 
-    def boxes_to_tex(self, leaves, **options):
+    def boxes_to_tex(self, leaves=None, **options):
+        if not leaves:
+            leaves = self._leaves
         return '-CompiledCode-'
 
 

mathics/builtin/graphics.py

@@ -470,7 +470,6 @@ class Graphics(Builtin):
     def apply_makeboxes(self, content, evaluation, options):
         """MakeBoxes[%(name)s[content_, OptionsPattern[%(name)s]],
         StandardForm|TraditionalForm|OutputForm]"""
-
         def convert(content):
             head = content.get_head_name()
 
@@ -508,8 +507,12 @@ def convert(content):
         for option in options:
             if option not in ("System`ImageSize",):
                 options[option] = Expression("N", options[option]).evaluate(evaluation)
-        box_name = "Graphics" + self.box_suffix
-        return Expression(box_name, convert(content), *options_to_rules(options))
+        #box_name = "Graphics" + self.box_suffix
+        from mathics.builtin.graphics3d import Graphics3DBox, Graphics3D
+        if type(self) is Graphics:
+            return GraphicsBox(convert(content), *options_to_rules(options))
+        elif type(self) is Graphics3D:
+            return Graphics3DBox(convert(content), *options_to_rules(options))
 
 
 class _GraphicsElement(InstancableBuiltin):
@@ -2598,8 +2601,8 @@ def to_svg(self):
         content = self.content.boxes_to_xml(evaluation=self.graphics.evaluation)
         style = create_css(font_color=self.color)
         svg = (
-            '<foreignObject x="%f" y="%f" ox="%f" oy="%f" style="%s">'
-            "<math>%s</math></foreignObject>"
+            '<foreignObject x="%f" y="%f" ox="%f" oy="%f" width="100" height="100" style="%s">'
+            '<math xmlns="http://www.w3.org/1998/Math/MathML">%s</math></foreignObject>'
         ) % (x, y, self.opos[0], self.opos[1], style, content)
         return svg
 
@@ -2768,7 +2771,6 @@ class _GraphicsElements(object):
     def __init__(self, content, evaluation):
         self.evaluation = evaluation
         self.elements = []
-
         builtins = evaluation.definitions.builtin
 
         def get_options(name):
@@ -2936,7 +2938,10 @@ class GraphicsBox(BoxConstruct):
 
     attributes = ("HoldAll", "ReadProtected")
 
-    def boxes_to_text(self, leaves, **options):
+    def boxes_to_text(self, leaves=None, **options):
+        if not leaves:
+            leaves = self._leaves
+
         self._prepare_elements(leaves, options)  # to test for Box errors
         return "-Graphics-"
 
@@ -2992,9 +2997,7 @@ def _get_image_size(self, options, graphics_options, max_width):
     def _prepare_elements(self, leaves, options, neg_y=False, max_width=None):
         if not leaves:
             raise BoxConstructError
-
         graphics_options = self.get_option_values(leaves[1:], **options)
-
         background = graphics_options["System`Background"]
         if (
             isinstance(background, Symbol)
@@ -3142,7 +3145,9 @@ def get_range(min, max):
 
         return elements, calc_dimensions
 
-    def boxes_to_tex(self, leaves, **options):
+    def boxes_to_tex(self, leaves=None, **options):
+        if not leaves:
+            leaves = self._leaves
         elements, calc_dimensions = self._prepare_elements(
             leaves, options, max_width=450
         )
@@ -3195,7 +3200,9 @@ def boxes_to_tex(self, leaves, **options):
 
         return tex
 
-    def boxes_to_xml(self, leaves, **options):
+    def boxes_to_xml(self, leaves=None, **options):
+        if not leaves:
+            leaves = self._leaves
         elements, calc_dimensions = self._prepare_elements(leaves, options, neg_y=True)
 
         xmin, xmax, ymin, ymax, w, h, width, height = calc_dimensions()
@@ -3229,7 +3236,7 @@ def boxes_to_xml(self, leaves, **options):
             " ".join("%f" % t for t in (xmin, ymin, w, h)),
             svg,
         )
-
+        print("svg=", svg_xml)
         return (
             '<mglyph width="%dpx" height="%dpx" src="data:image/svg+xml;base64,%s"/>'
             % (
@@ -3623,7 +3630,6 @@ class _ColorObject(Builtin):
 
     def __init__(self, *args, **kwargs):
         super(_ColorObject, self).__init__(*args, **kwargs)
-
         if self.text_name is None:
             text_name = strip_context(self.get_name()).lower()
         else:
@@ -3660,6 +3666,7 @@ class Black(_ColorObject):
     }
 
 
+
 class White(_ColorObject):
     """
     >> White
@@ -3737,6 +3744,7 @@ class Magenta(_ColorObject):
     }
 
 
+
 class Yellow(_ColorObject):
     """
     >> Yellow
@@ -3860,6 +3868,7 @@ class Large(Builtin):
 style_options = system_symbols_dict(
     {
         "FontColor": _style,
+        "ImageSizeMultipliers": (lambda *x: x[1])
     }
 )
 

mathics/builtin/graphics3d.py

@@ -154,7 +154,9 @@ class Graphics3D(Graphics):
 
 
 class Graphics3DBox(GraphicsBox):
-    def boxes_to_text(self, leaves, **options):
+    def boxes_to_text(self, leaves=None, **options):
+        if not leaves:
+            leaves = self._leaves
         return "-Graphics3D-"
 
     def _prepare_elements(self, leaves, options, max_width=None):
@@ -435,7 +437,10 @@ def calc_dimensions(final_pass=True):
 
         return elements, axes, ticks, calc_dimensions, boxscale
 
-    def boxes_to_tex(self, leaves, **options):
+    def boxes_to_tex(self, leaves=None, **options):
+        if not leaves:
+            leaves = self._leaves
+
         elements, axes, ticks, calc_dimensions, boxscale = self._prepare_elements(
             leaves, options, max_width=450
         )
@@ -624,7 +629,10 @@ def boxes_to_tex(self, leaves, **options):
         )
         return tex
 
-    def boxes_to_xml(self, leaves, **options):
+    def boxes_to_xml(self, leaves=None, **options):
+        if not leaves:
+            leaves = self._leaves
+
         elements, axes, ticks, calc_dimensions, boxscale = self._prepare_elements(
             leaves, options
         )

mathics/builtin/image.py

@@ -2124,18 +2124,20 @@ def test(self, expr):
 
 
 class ImageBox(BoxConstruct):
-    def boxes_to_text(self, leaves, **options):
+    def boxes_to_text(self, leaves=None, **options):
         return "-Image-"
 
-    def boxes_to_xml(self, leaves, **options):
+    def boxes_to_xml(self, leaves=None, **options):
+        if leaves is None:
+            leaves = self._leaves
         # see https://tools.ietf.org/html/rfc2397
         return '<mglyph src="%s" width="%dpx" height="%dpx" />' % (
             leaves[0].get_string_value(),
             leaves[1].get_int_value(),
             leaves[2].get_int_value(),
         )
 
-    def boxes_to_tex(self, leaves, **options):
+    def boxes_to_tex(self, leaves=None, **options):
         return "-Image-"
 
 
@@ -2259,8 +2261,7 @@ def atom_to_boxes(self, f, evaluation):
         encoded = base64.b64encode(contents)
         encoded = b"data:image/png;base64," + encoded
 
-        return Expression(
-            "ImageBox", String(encoded), Integer(scaled_width), Integer(scaled_height)
+        return ImageBox(String(encoded), Integer(scaled_width), Integer(scaled_height)
         )
 
     def __str__(self):