munchboka-edutools 0.2.3__py3-none-any.whl

munchboka_edutools/directives/ggb_popup.py

@@ -0,0 +1,308 @@
+"""
+GeoGebra popup directive for creating interactive GeoGebra applets in dialog windows.
+
+This directive creates a button that opens a GeoGebra Classic applet in a
+draggable, resizable dialog window using jQuery UI.
+
+Usage:
+    Basic usage with defaults (700x500 window):
+    ```{ggb-popup}
+    ```
+
+    Custom size and text:
+    ```{ggb-popup} 800 600 "Open Calculator" "GeoGebra Calculator"
+    ```
+
+    With options:
+    ```{ggb-popup} 900 700 "Open Geometry" "Geometry Window"
+    :perspective: G
+    :menubar: true
+    :layout: sidebar
+    ```
+
+Arguments (all optional):
+    1. Width (default: 700) - Width of the GeoGebra applet in pixels
+    2. Height (default: 500) - Height of the GeoGebra applet in pixels
+    3. Button text (default: "Åpne Geogebra‑vindu") - Text shown on the button
+    4. Dialog title (default: "Geogebra‑vindu") - Title of the dialog window
+
+Options:
+    - perspective: GeoGebra perspective/view (default: "AG")
+      Common values: "AG" (Algebra & Graphics), "G" (Geometry), "GS" (Graphing), "CAS"
+    - menubar: Show menu bar (default: "false") - "true" or "false"
+    - layout: Layout style (default: none) - Use "sidebar" to wrap in sidebar-cas div
+
+Features:
+    - Draggable and resizable dialog window
+    - GeoGebra Classic applet with full features
+    - Responsive sizing when dialog is resized
+    - Centered on screen when opened
+    - jQuery UI styling
+"""
+
+from docutils import nodes
+from sphinx.util.docutils import SphinxDirective
+import uuid
+
+
+class GGBPopUpDirective(SphinxDirective):
+    """
+    Directive for creating GeoGebra popup windows.
+
+    Creates a button that opens a GeoGebra Classic applet in a jQuery UI dialog.
+    """
+
+    required_arguments = 0
+    optional_arguments = 4  # width, height, button text, dialog title
+    final_argument_whitespace = True
+    has_content = False
+    option_spec = {
+        "layout": lambda arg: arg,  # e.g., "sidebar"
+        "menubar": lambda arg: arg,  # e.g., "true" or "false"
+        "perspective": lambda arg: arg,  # e.g., "GS"
+    }
+
+    def run(self):
+        """Generate HTML for the GeoGebra popup."""
+        # 1 » Parse arguments
+        width = int(self.arguments[0]) if len(self.arguments) > 0 else 700
+        height = int(self.arguments[1]) if len(self.arguments) > 1 else 500
+
+        button_text = self.arguments[2] if len(self.arguments) > 2 else "Åpne Geogebra‑vindu"
+        dialog_title = self.arguments[3] if len(self.arguments) > 3 else "Geogebra‑vindu"
+
+        menubar = self.options.get("menubar", "false")
+
+        perspective = self.options.get("perspective", "AG").strip()
+
+        # 2 » Generate unique IDs
+        cid = f"ggb-geogebra-{uuid.uuid4().hex[:8]}"
+        dialog_id = f"dialog-{cid}"
+        button_id = f"button-{cid}"
+
+        # 3 » Handle layout option
+        layout = self.options.get("layout", "").strip().lower()
+        use_sidebar = layout == "sidebar"
+
+        wrapper_start = '<div class="sidebar-cas">' if use_sidebar else ""
+        wrapper_end = "</div>" if use_sidebar else ""
+
+        # 4 » Generate HTML content
+        html = f"""
+{wrapper_start}
+<meta name="viewport" content="width=device-width, initial-scale=1">
+
+<button id="{button_id}" class="ggb-cas-button">{button_text}</button>
+<div id="{dialog_id}" title="{dialog_title}" style="display:none;">
+    <div id="{cid}" class="ggb-window"></div>
+</div>
+
+<style>
+.ui-resizable-handle {{ min-width:16px;min-height:16px; }}
+.ui-dialog-content{{padding:0!important;}}
+.ggb-window       {{width:100%!important;height:100%!important;box-sizing:border-box;}}
+.ggb-popup-button {{margin-top: 1em; margin-bottom: 1em;}}
+.ggb-reset-btn {{
+  position: absolute;
+  right: 2.5em;
+  top: 50%;
+  transform: translateY(-50%);
+  width: 2em;
+  height: 2em;
+  padding: 0.25em;
+  margin: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border: none;
+  border-radius: 4px;
+  background: transparent;
+  cursor: pointer;
+  transition: background-color 0.2s, opacity 0.2s;
+  opacity: 0.7;
+}}
+.ggb-reset-btn:hover {{
+  opacity: 1;
+  background-color: rgba(0, 0, 0, 0.1);
+}}
+[data-theme="dark"] .ggb-reset-btn:hover,
+html[data-theme="dark"] .ggb-reset-btn:hover {{
+  background-color: rgba(255, 255, 255, 0.1);
+}}
+.ggb-reset-btn svg {{
+  color: inherit;
+}}
+</style>
+
+<script>
+(function() {{
+  $(function() {{
+    let ggbReady = false;
+    const storageKey = 'ggb-geogebra-state-{cid}';
+
+    function applySize() {{
+      if (!ggbReady) return;
+      const w = $("#{cid}").width(),
+            h = $("#{cid}").height();
+      window.ggbApplet.setSize(Math.round(w), Math.round(h));
+    }}
+
+    function saveState() {{
+      if (!ggbReady || !window.ggbApplet) return;
+      try {{
+        const state = window.ggbApplet.getBase64();
+        localStorage.setItem(storageKey, state);
+        // Update timestamp for this state
+        localStorage.setItem(storageKey + '-timestamp', Date.now().toString());
+      }} catch (e) {{
+        // If quota exceeded, try cleaning up old states and retry
+        if (e.name === 'QuotaExceededError') {{
+          cleanupOldStates();
+          try {{
+            const state = window.ggbApplet.getBase64();
+            localStorage.setItem(storageKey, state);
+            localStorage.setItem(storageKey + '-timestamp', Date.now().toString());
+          }} catch (retryError) {{
+            // Still failed after cleanup - silently give up
+          }}
+        }}
+      }}
+    }}
+
+    function cleanupOldStates() {{
+      try {{
+        // Find all GeoGebra states with timestamps (both CAS and regular)
+        const ggbStates = [];
+        for (let i = 0; i < localStorage.length; i++) {{
+          const key = localStorage.key(i);
+          if (key && (key.startsWith('ggb-geogebra-state-') || key.startsWith('ggb-cas-state-')) && key.endsWith('-timestamp')) {{
+            const stateKey = key.replace('-timestamp', '');
+            const timestamp = parseInt(localStorage.getItem(key) || '0', 10);
+            ggbStates.push({{ key: stateKey, timestamp: timestamp }});
+          }}
+        }}
+        
+        // Sort by timestamp (oldest first)
+        ggbStates.sort((a, b) => a.timestamp - b.timestamp);
+        
+        // Delete oldest 25% of states (minimum 1, maximum 10)
+        const numToDelete = Math.max(1, Math.min(10, Math.floor(ggbStates.length * 0.25)));
+        for (let i = 0; i < numToDelete && i < ggbStates.length; i++) {{
+          localStorage.removeItem(ggbStates[i].key);
+          localStorage.removeItem(ggbStates[i].key + '-timestamp');
+        }}
+      }} catch (e) {{
+        // Cleanup failed - silently continue
+      }}
+    }}
+
+    function restoreState() {{
+      if (!ggbReady || !window.ggbApplet) return;
+      try {{
+        const savedState = localStorage.getItem(storageKey);
+        if (savedState) {{
+          window.ggbApplet.setBase64(savedState);
+        }}
+      }} catch (e) {{
+        // Silently fail if restore fails
+      }}
+    }}
+
+    $("#{dialog_id}").dialog({{
+      autoOpen: false,
+      width: {width+40}, height: {height+80},
+      resizable: true, draggable: true,
+      position: {{ my: "center", at: "center", of: window }},
+      resize: () => window.requestAnimationFrame(applySize),
+      open: function() {{
+        if (!ggbReady) {{
+          new GGBApplet({{
+            appName: "classic", id: "{cid}",
+            width: {width}, height: {height},
+            perspective: "{perspective}", language: "nb",
+            showToolBar: true, showAlgebraInput: true,
+            borderRadius: 8, enableRightClick: true, showKeyboardOnFocus: false,
+            showMenuBar: {menubar},
+            appletOnLoad: () => {{ 
+              ggbReady = true; 
+              applySize();
+              // Restore state after a short delay to ensure GeoGebra is fully initialized
+              setTimeout(restoreState, 100);
+            }}
+          }}, true).inject("{cid}");
+        }} else {{
+          applySize();
+        }}
+      }},
+      close: function() {{
+        // Save state when dialog is closed
+        saveState();
+      }}
+    }});
+
+    // Add refresh button to title bar
+    const $dlg = $("#{dialog_id}");
+    const titleBar = $dlg.parent().find('.ui-dialog-titlebar');
+    const refreshBtn = $('<button type="button" class="ggb-reset-btn" title="Start på nytt (slett lagret innhold)"><svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M13.65 2.35C12.2 0.9 10.21 0 8 0 3.58 0 0.01 3.58 0.01 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L9 7h7V0l-2.35 2.35z" fill="currentColor"/></svg></button>');
+    refreshBtn.on('click', function() {{
+      if (confirm('Er du sikker på at du vil slette lagret innhold og starte på nytt?')) {{
+        try {{
+          localStorage.removeItem(storageKey);
+          localStorage.removeItem(storageKey + '-timestamp');
+          if (ggbReady && window.ggbApplet) {{
+            // Clear the container
+            $("#{cid}").empty();
+            // Reset the flag
+            ggbReady = false;
+            // Recreate the applet from scratch
+            new GGBApplet({{
+              appName: "classic", id: "{cid}",
+              width: {width}, height: {height},
+              perspective: "{perspective}", language: "nb",
+              showToolBar: true, showAlgebraInput: true,
+              borderRadius: 8, enableRightClick: true, showKeyboardOnFocus: false,
+              showMenuBar: {menubar},
+              appletOnLoad: () => {{ 
+                ggbReady = true; 
+                applySize();
+              }}
+            }}, true).inject("{cid}");
+          }}
+        }} catch (e) {{
+          console.error('Failed to reset:', e);
+        }}
+      }}
+    }});
+    titleBar.append(refreshBtn);
+
+    // Save state when page is unloaded (refresh, navigate away, close tab)
+    $(window).on('beforeunload', function() {{
+      if ($dlg.dialog('isOpen')) {{
+        saveState();
+      }}
+    }});
+
+    $("#{button_id}").button()
+      .on("click touchend pointerup", e => {{
+        e.preventDefault();
+        $("#{dialog_id}").dialog("open");
+      }});
+  }});
+}})();
+</script>
+{wrapper_end}
+        """
+        return [nodes.raw("", html, format="html")]
+
+
+def setup(app):
+    """Register the ggb-popup directive with Sphinx."""
+    app.add_directive("ggb-popup", GGBPopUpDirective)
+    # Also register without hyphen for MyST compatibility
+    app.add_directive("ggbpopup", GGBPopUpDirective)
+
+    return {
+        "version": "0.1.0",
+        "parallel_read_safe": True,
+        "parallel_write_safe": True,
+    }

munchboka_edutools/directives/horner.py

@@ -0,0 +1,326 @@
+"""
+Horner scheme (synthetic division) directive for Sphinx/Jupyter Book.
+
+Generates SVG visualizations of Horner's method/synthetic division using LaTeX.
+"""
+
+import os
+import shutil
+import hashlib
+import re
+import uuid
+from docutils import nodes
+from docutils.parsers.rst import directives
+from sphinx.util.docutils import SphinxDirective
+
+
+def _hash_key(*parts):
+    """Generate a hash key from multiple parts for caching."""
+    h = hashlib.sha1()
+    for p in parts:
+        if p is None:
+            p = "__NONE__"
+        h.update(str(p).encode("utf-8"))
+        h.update(b"||")
+    return h.hexdigest()[:12]
+
+
+def synthetic_div(
+    fname: str,
+    p: str,
+    x: float,
+    stage: int = 12,
+    svg: bool = True,
+    tutor: bool = False,
+):
+    """
+    Generate Horner scheme (synthetic division) figure using LaTeX.
+
+    Args:
+        fname: Base filename (without extension)
+        p: Polynomial as string (e.g., "x^3 + 2x^2 - 3x - 6")
+        x: Value to evaluate at
+        stage: Stage number for step-by-step display (default: 12 = complete)
+        svg: If True, convert to SVG; otherwise keep as PDF
+        tutor: If True, enable tutor mode with step-by-step guidance
+    """
+    if not tutor:
+        div_cmd = r"\polyhornerscheme[x={x}, resultstyle=\color{red}, showvar=true]{{p}}"
+        div_cmd = div_cmd.replace("{p}", p).replace("{x}", str(x))
+    else:
+        div_cmd = r"\polyhornerscheme[x={x}, stage={stage}, tutor=true, tutorlimit=12, resultstyle=\color{red}, showvar=true]{{p}}"
+        div_cmd = div_cmd.replace("{p}", p).replace("{x}", str(x)).replace("{stage}", str(stage))
+
+    s = f"""\\documentclass{{standalone}}
+\\usepackage{{polynom}}
+\\usepackage{{xcolor}}
+\\begin{{document}}
+{div_cmd}
+\\end{{document}}
+    """
+
+    with open("tmp.tex", "w") as f:
+        f.write(s)
+
+    os.system("pdflatex tmp.tex")
+    if fname.endswith(".svg"):
+        fname = fname.strip(".svg")
+
+    if svg:
+        os.system(f"pdf2svg tmp.pdf {fname}.svg")
+    else:
+        os.system(f"mv tmp.pdf {fname}.pdf")
+
+    os.system("rm tmp.*")
+
+
+class HornerDirective(SphinxDirective):
+    """
+    Generate (and cache) a Horner (synthetic division) scheme as inline SVG.
+
+    Usage (MyST):
+
+    ```
+    ::::{horner}
+    :p: x^3 + 2x^2 - 3x - 6
+    :x: 1
+    :stage: 2      # optional
+    :width: 60%    # optional
+
+    Optional caption here.
+    ::::
+    ```
+
+    Or classic reStructuredText:
+
+    ```
+    .. horner::
+       :p: x^3 + 2x^2 - 3x - 6
+       :x: 1
+       :stage: 2
+
+       Optional caption here.
+    ```
+    """
+
+    has_content = True
+    required_arguments = 0
+    optional_arguments = 0
+    final_argument_whitespace = False
+    option_spec = {
+        "p": directives.unchanged_required,
+        "x": directives.unchanged_required,
+        "stage": directives.nonnegative_int,
+        "tutor": directives.flag,
+        "align": lambda a: directives.choice(a, ["left", "center", "right"]),
+        "class": directives.class_option,
+        "name": directives.unchanged,
+        "nocache": directives.flag,
+        "alt": directives.unchanged,
+        "width": directives.length_or_percentage_or_unitless,
+    }
+
+    def run(self):
+        env = self.state.document.settings.env
+        app = env.app
+
+        # Required options
+        p = self.options.get("p")
+        x_val = self.options.get("x")
+        if p is None or x_val is None:
+            return [
+                self.state_machine.reporter.error(
+                    "Directive 'horner' requires both :p: and :x: options.",
+                    line=self.lineno,
+                )
+            ]
+
+        # Optional options
+        stage = self.options.get("stage", 12)
+        tutor_mode = "tutor" in self.options
+        explicit_name = self.options.get("name")
+
+        # Cache key must include tutor mode so variants don't collide
+        content_hash = _hash_key(p, x_val, stage, int(tutor_mode))
+        base_name = explicit_name or f"horner_{content_hash}"
+
+        # Paths / caching
+        src_dir = app.srcdir
+        rel_dir = os.path.join("_static", "horner")
+        abs_dir = os.path.join(src_dir, rel_dir)
+        os.makedirs(abs_dir, exist_ok=True)
+        svg_filename = f"{base_name}.svg"
+        abs_svg_path = os.path.join(abs_dir, svg_filename)
+
+        regenerate = "nocache" in self.options or not os.path.exists(abs_svg_path)
+        if regenerate:
+            cwd = os.getcwd()
+            try:
+                os.chdir(abs_dir)
+                synthetic_div(
+                    fname=base_name,
+                    p=p,
+                    x=x_val,
+                    stage=stage,
+                    svg=True,
+                    tutor=tutor_mode,
+                )
+            except Exception as e:
+                return [
+                    self.state_machine.reporter.error(
+                        f"Error generating Horner scheme: {e}",
+                        line=self.lineno,
+                    )
+                ]
+            finally:
+                os.chdir(cwd)
+
+        # Post-process: strip explicit width/height if viewBox present for responsiveness
+        try:
+            if os.path.exists(abs_svg_path):
+                with open(abs_svg_path, "r", encoding="utf-8") as f_svg:
+                    raw_tmp = f_svg.read()
+                if "viewBox" in raw_tmp:
+                    cleaned = re.sub(r'\swidth="[^"]+"', "", raw_tmp)
+                    cleaned = re.sub(r'\sheight="[^"]+"', "", cleaned)
+                    if cleaned != raw_tmp:
+                        with open(abs_svg_path, "w", encoding="utf-8") as f_out:
+                            f_out.write(cleaned)
+        except Exception:
+            pass
+
+        if not os.path.exists(abs_svg_path):
+            return [
+                self.state_machine.reporter.error(
+                    (
+                        f"horner: failed to generate SVG '{svg_filename}'. "
+                        "Check that 'pdflatex' and 'pdf2svg' are installed."
+                    ),
+                    line=self.lineno,
+                )
+            ]
+
+        # Track dependency & copy to output for HTML builder
+        env.note_dependency(abs_svg_path)
+        try:
+            out_static = os.path.join(app.outdir, "_static", "horner")
+            os.makedirs(out_static, exist_ok=True)
+            shutil.copy2(abs_svg_path, os.path.join(out_static, svg_filename))
+        except Exception:
+            pass
+
+        # Alt text construction
+        if stage is not None and stage != 12:
+            default_alt = f"Horner's scheme for ({p}) at x={x_val} – stage {stage}"
+        else:
+            default_alt = f"Horner's scheme for ({p}) at x={x_val}"
+        if tutor_mode:
+            default_alt += " (tutor mode)"
+        alt = self.options.get("alt", default_alt)
+
+        width_opt = self.options.get("width")
+        percentage_width = isinstance(width_opt, str) and width_opt.strip().endswith("%")
+
+        # Read generated SVG
+        try:
+            with open(abs_svg_path, "r", encoding="utf-8") as f_svg:
+                raw_svg = f_svg.read()
+        except Exception as e:
+            return [
+                self.state_machine.reporter.error(
+                    f"horner inline: could not read SVG: {e}",
+                    line=self.lineno,
+                )
+            ]
+
+        # Ensure unique IDs per embedding
+        def _uniquify_ids(svg_text: str, prefix: str) -> str:
+            ids = set(re.findall(r'\bid="([^"]+)"', svg_text))
+            if not ids:
+                return svg_text
+            mapping = {old: f"{prefix}{old}" for old in ids}
+            for old, new in mapping.items():
+                svg_text = re.sub(rf'\bid="{re.escape(old)}"', f'id="{new}"', svg_text)
+            for old, new in mapping.items():
+                svg_text = re.sub(
+                    rf'(?:xlink:)?href="#?{re.escape(old)}"', f'href="#{new}"', svg_text
+                )
+                svg_text = re.sub(
+                    rf'xlink:href="#?{re.escape(old)}"',
+                    f'xlink:href="#{new}"',
+                    svg_text,
+                )
+            for old, new in mapping.items():
+                svg_text = re.sub(rf"url\(#\s*{re.escape(old)}\s*\)", f"url(#{new})", svg_text)
+            for old, new in mapping.items():
+                svg_text = re.sub(rf"#({re.escape(old)})\b", f"#{new}", svg_text)
+            return svg_text
+
+        unique_prefix = f"hnr_{_hash_key(p, x_val, stage, int(tutor_mode))}_{uuid.uuid4().hex[:6]}_"
+        raw_svg = _uniquify_ids(raw_svg, unique_prefix)
+
+        # Augment root <svg> (unified width handling)
+        def _augment(match):
+            tag = match.group(0)
+            if "class=" not in tag:
+                tag = tag[:-1] + ' class="horner-inline-svg"' + ">"
+            else:
+                tag = tag.replace('class="', 'class="horner-inline-svg ')
+            if alt and "aria-label=" not in tag:
+                tag = tag[:-1] + f' role="img" aria-label="{alt}"' + ">"
+            if width_opt:
+                w_raw = width_opt.strip()
+                if percentage_width:
+                    w_css = w_raw
+                    margin = "margin:0 auto;" if "margin:" not in tag else ""
+                    style_frag = f"width:{w_css}; height:auto; display:block; {margin}".strip()
+                else:
+                    w_css = (w_raw + "px") if w_raw.isdigit() else w_raw
+                    style_frag = f"width:{w_css}; height:auto; display:block;"
+                if "style=" in tag:
+                    tag = re.sub(
+                        r'style="([^"]*)"',
+                        lambda m: f'style="{m.group(1)}; {style_frag}"',
+                        tag,
+                        count=1,
+                    )
+                else:
+                    tag = tag[:-1] + f' style="{style_frag}"' + ">"
+            return tag
+
+        raw_svg = re.sub(r"<svg\b[^>]*>", _augment, raw_svg, count=1)
+
+        # Build docutils figure
+        figure = nodes.figure()
+        figure.setdefault("classes", []).extend(["adaptive-figure", "horner-figure", "no-click"])
+
+        raw_node = nodes.raw("", raw_svg, format="html")
+        raw_node.setdefault("classes", []).extend(["horner-image", "no-click", "no-scaled-link"])
+        figure += raw_node
+
+        extra_classes = self.options.get("class")
+        if extra_classes:
+            figure["classes"].extend(extra_classes)
+        figure["align"] = self.options.get("align", "center")
+
+        if self.content:
+            caption_node = nodes.caption()
+            caption_text = "\n".join(self.content)
+            # Parse as inline text to support math while avoiding extra paragraph nodes
+            parsed_nodes, messages = self.state.inline_text(caption_text, self.lineno)
+            caption_node.extend(parsed_nodes)
+            figure += caption_node
+
+        if explicit_name:
+            self.add_name(figure)
+
+        return [figure]
+
+
+def setup(app):
+    app.add_directive("horner", HornerDirective)
+    return {
+        "version": "0.1",
+        "parallel_read_safe": True,
+        "parallel_write_safe": True,
+    }