data_editor not editable in full screen mode #10079

# /// script
# [tool.marimo.runtime]
# auto_instantiate = false
# ///

<img width="1920" height="1032" alt="Image" src="https://github.com/user-attachments/assets/52644e3f-f683-4fd0-b47c-8c03e335c5d5" />
<img width="1920" height="1032" alt="Image" src="https://github.com/user-attachments/assets/c188f3e4-cf3f-4257-a7a6-349da90fe42e" />

import marimo

__generated_with = "0.23.9"
app = marimo.App(
    width="medium",
    auto_download=["html"],
)


@app.cell
def _():
    import marimo as mo
    import pandas as pd
    import numpy as np
    import altair as alt

    # Utility to make a small, varied dataframe
    rng = np.random.default_rng(42)
    sample_size = 10
    sample_df = pd.DataFrame({
        "id": np.arange(1, sample_size+1),
        "bool": np.bool(rng.integers(0,1,size=sample_size)),
        "category": pd.Categorical(rng.choice(["A", "B", "C"], size=sample_size)),
        "value_int": rng.integers(0, 100, size=sample_size),
        "value_float": np.round(rng.normal(50, 15, size=sample_size), 2),
        "text": [f"row_{i}" for i in range(sample_size)],
        "date": pd.date_range("2024-01-01", periods=sample_size, freq="D")
    })

    mo.md("""
    # Repro: mo.ui.data_editor cannot edit in fullscreen

    Use this notebook to reproduce the issue where entering fullscreen on the data editor prevents editing cells.

    Instructions:
    1. Use the editor below and verify you can edit cells normally (e.g., change 'text' or numbers).
    2. Click the fullscreen button on the top-right of the editor element.
    3. Try to click into a cell and edit it while in fullscreen.
    4. Observe whether focus is placed and whether keystrokes update the cell.
    5. Exit fullscreen and compare behavior.

    Below we provide two editors:
    - A small dataframe with varied dtypes (int, float, categorical, text, date)
    - A larger dataframe to test virtualization/scrolling in fullscreen
    """)
    return alt, mo, np, pd, rng, sample_df


@app.cell
def _(mo, sample_df):
    # Small editor with varied dtypes
    small_editor = mo.ui.data_editor(sample_df.copy())

    # Display with some surrounding UI to ensure focus handling is realistic
    mo.vstack([
        mo.md("## Small editor (mixed dtypes)"),
        small_editor,
        mo.md("Selected summary (reactive): The table above is fully editable when not fullscreen. Enter fullscreen and try editing cells.")
    ])
    return (small_editor,)


@app.cell
def _(mo, np, pd, rng):
    # Larger editor to test scrolling/virtualization interactions in fullscreen
    rows = 500
    large_df = pd.DataFrame({
        "row": np.arange(rows),
        "group": rng.choice(list("ABCDE"), size=rows),
        "x": np.round(rng.uniform(0, 1, size=rows), 3),
        "y": np.round(rng.normal(0, 1, size=rows), 3),
        "label": [f"item_{i}" for i in range(rows)]
    })

    large_editor = mo.ui.data_editor(large_df.copy())

    mo.vstack([
        mo.md("## Large editor (500 rows)"),
        large_editor,
        mo.md("Try entering fullscreen and editing multiple cells while scrolling.")
    ])
    return (large_editor,)


@app.cell
def _(large_editor, mo, small_editor):
    # Echo back current values to confirm edits propagate reactively when not in fullscreen
    # Note: Access editor values from a separate cell
    small_value = small_editor.value
    large_value = large_editor.value

    mo.tabs({
        "Small head": mo.ui.data_editor(small_value.head(10)),
        "Small describe": mo.ui.data_editor(small_value.describe(include="all").fillna("")),
        "Large head": mo.ui.data_editor(large_value.head(10))
    })
    return (small_value,)


@app.cell
def _(alt, mo, np, pd, small_value):
    # Minimal visual check: build a chart from the edited data to ensure reactive pipeline still works
    chart_data = small_value.copy()

    # Coerce types safely for plotting
    if "value_float" in chart_data.columns:
        chart_data["value_float_num"] = pd.to_numeric(chart_data["value_float"], errors="coerce")
    else:
        chart_data["value_float_num"] = np.nan

    if "category" in chart_data.columns:
        chart_data["category_str"] = chart_data["category"].astype(str)
    else:
        chart_data["category_str"] = "unknown"

    chart = alt.Chart(chart_data).mark_bar().encode(
        x=alt.X("category_str:N", title="Category"),
        y=alt.Y("mean(value_float_num):Q", title="Mean value_float"),
        tooltip=["category_str", alt.Tooltip("mean(value_float_num):Q", title="Mean value_float")]
    ).properties(title="Reactive check: mean(value_float) by category (updates when edits apply)")

    mo.ui.altair_chart(chart)
    return


@app.cell
def _(mo):
    # Environment info to include in the issue
    import sys
    import platform

    info = {
        "python_version": sys.version.split(" ")[0],
        "platform": platform.platform(),
        "marimo_version": mo.__version__,
    }

    mo.md("""
    ### Environment
    Below is useful environment information to paste into the issue along with reproduction steps.
    """)

    info
    return


if __name__ == "__main__":
    app.run()