Apply sensible page margin/padding defaults on CREATE PAGE

[ako]

Problem

When creating pages via MDL, no margin/padding defaults are applied, so generated layouts need manual spacing adjustment in Studio Pro.

Current behavior

The Container struct (sdk/pages/pages_widgets_container.go) has no margin/padding fields, and the page builder (mdl/executor/cmd_pages_builder_v3.go) applies none when wrapping content. Serialization (sdk/mpr/writer_pages.go) emits canvas dimensions but no spacing.

Request

Set page margins/padding to appropriate defaults automatically (and/or allow them to be set in MDL).

Touch points for a fix

• sdk/pages/pages_widgets_container.go — add Margin/Padding fields
• mdl/executor/cmd_pages_builder_v3.go — apply defaults
• sdk/mpr/writer_widgets.go — serialize them
• mdl/grammar/domains/MDLPage.g4 — accept Margin/Padding properties (if user-settable)

---

Source: customer feedback batch (2026-06). Reporter: Nagano. Reporter severity: 2/5.
Filed after codebase investigation at 297e0b0a.

[github-actions]

Issue Triage

Summary:
The issue requests that mxcli automatically apply sensible margin/padding defaults (or allow them to be set via MDL) when creating pages, to avoid manual spacing adjustments in Studio Pro.

Checklist for feature request

Required info	Present?	Details
Use case – why the feature is needed / problem it solves	✅	Described: generated pages lack margin/padding, requiring manual tweaks in Studio Pro.
Proposed syntax or behavior (if applicable)	✅	Request to set default margins/padding automatically (and/or expose them in MDL).
Mendix version relevance (if version‑specific)	⚠️	Not mentioned; the request appears version‑agnostic, so this is optional.

Feedback:
The issue provides a clear use case and the desired behavior. Since the request does not depend on a specific Mendix version, the missing version relevance is not required. The feature request is complete enough to proceed.

Thank you for the detailed suggestion! 🙌

---

Automated triage via OpenRouter — workflow source

[github-actions]

Enhancement Implementation Guide

We are given an enhancement request about setting sensible page margin/padding defaults on CREATE PAGE.

The issue states:

• When creating pages via MDL, no margin/padding defaults are applied, so generated layouts need manual spacing adjustment in Studio Pro.
• The Container struct (sdk/pages/pages_widgets_container.go) has no margin/padding fields, and the page builder (mdl/executor/cmd_pages_builder_v3.go) applies none when wrapping content.
• Serialization (sdk/mpr/writer_pages.go) emits canvas dimensions but no spacing.

The request is to set page margins/padding to appropriate defaults automatically (and/or allow them to be set in MDL).

We are to provide an implementation guide following the required sections.

Let's break down:

1. Completeness Assessment: The issue is fairly detailed. It points to specific files and even suggests the touch points. However, we might want to know:

   • What are the appropriate defaults? (e.g., 16px? or based on Mendix theme?)
   • Should the defaults be configurable? Or only applied on create?
   • The issue mentions allowing them to be set in MDL (if user-settable). So we need to decide if we are only adding defaults or also allowing user to set via MDL.

   Since the issue says "set page margins/padding to appropriate defaults automatically (and/or allow them to be set in MDL)", we can interpret that we are to add the fields and set defaults, and also allow the user to override via MDL if they wish.

   However, the issue does not specify the exact default values. We might need to look at what Mendix Studio Pro does by default when creating a page.

   But note: the issue is filed after codebase investigation at a specific commit. We can assume the reporter has looked into the code and knows what needs to be done.

   We might ask:

   • What Mendix version is this targeting? (because defaults might change)
   • Are there any existing margin/padding properties in the Container widget in Studio Pro that we can mirror?

   However, the issue is clear enough to proceed with the implementation guide, but we note that the exact default values might need to be determined by looking at a Studio Pro created page.

2. Overlap Check:

   • Currently, there is no way to set margin/padding on a Container via MDL because the Container struct doesn't have these fields and the builder doesn't set them.
   • We are adding the ability to set margin/padding (via defaults and possibly user input) so there is no overlap with existing functionality.

3. Proposed MDL Syntax:

   • The issue suggests that if we allow user-settable, we would need to modify the grammar to accept Margin/Padding properties in the page definition.
   • However, note that the issue is about setting defaults on CREATE PAGE. The user might not need to set it via MDL if we are setting sensible defaults. But the issue says "and/or allow them to be set in MDL".

   We have two options:
   Option A: Only set defaults automatically (no user input in MDL). Then we don't need to change the grammar.
   Option B: Allow the user to set margin/padding in the page properties (like title, layout) so that they can override the defaults.

   The issue says: "set page margins/padding to appropriate defaults automatically (and/or allow them to be set in MDL)". This implies that we are to do both: set defaults and allow user to set via MDL.

   Therefore, we will:

   • Add Margin and Padding fields to the Container struct (in sdk/pages/pages_widgets_container.go)
   • In the page builder (mdl/executor/cmd_pages_builder_v3.go), when creating a page, we will set default margin/padding values (if not provided by the user) OR if the user provided them in the MDL, use those.
   • We will also update the grammar to accept Margin and Padding as properties in the page definition (if we are allowing user input).

   However, note that the page definition in MDL currently looks like:

   create page MyModule.MyPage (
   params: { $MyParam: MyModule.MyEntity },
   title: 'My Page',
   layout: Atlas_Core.Atlas_Default
   ) {
   ... widgets ...
   }

   We would add:

   create page MyModule.MyPage (
   params: { $MyParam: MyModule.MyEntity },
   title: 'My Page',
   layout: Atlas_Core.Atlas_Default,
   margin: 16,
   padding: 8
   ) {
   ... widgets ...
   }

   But note: margin and padding in Mendix are often defined as four values (top, right, bottom, left) or as a single value for all sides? We need to check the BSON structure.

   According to the issue, the Container widget in the SDK (sdk/pages/pages_widgets_container.go) currently has no margin/padding fields. We are to add them.

   We must look at the existing Container widget in the Mendix model to see how margin and padding are stored.

   However, since we don't have the exact BSON structure, we can assume that margin and padding are stored as integers (in pixels) and perhaps as a single value for all sides? Or as a struct?

   The issue says: "Serialization (sdk/mpr/writer_pages.go) emits canvas dimensions but no spacing." So we are also to update the writer for pages? But note: the Container is a widget, so it should be in writer_widgets.go? The issue mentions writer_pages.go but that might be a mistake.

   Actually, the issue says:

   • sdk/pages/pages_widgets_container.go — add Margin/Padding fields
   • mdl/executor/cmd_pages_builder_v3.go — apply defaults
   • sdk/mpr/writer_widgets.go — serialize them [Note: the issue says writer_pages.go but then corrects to writer_widgets.go in the touch points?]

   The touch points list:

   • sdk/pages/pages_widgets_container.go
   • mdl/executor/cmd_pages_builder_v3.go
   • sdk/mpr/writer_widgets.go
   • mdl/grammar/domains/MDLPage.g4 (if user-settable)

   So we will follow that.

   Proposed MDL syntax for page creation (if user-settable):

   create page Module.PageName (
   ... existing properties ...,
   margin: ,
   padding:
   ) {
   ... widgets ...
   }

   But note: margin and padding might be more complex (e.g., separate top, right, bottom, left). However, the issue does not specify. We will start with a single integer for all sides (which is common in many UI frameworks) and then if needed, we can expand.

   However, looking at the Mendix Container widget in Studio Pro, it has:

   • Margin (top, right, bottom, left) as four separate fields? Or as a single field for all sides? Actually, in the Container widget properties, you can set margin and padding for each side individually.

   But for simplicity, and because the issue does not specify, we will assume that we are setting a uniform margin and padding (same for all sides). We can later expand to individual sides if needed.

   Alternatively, we can look at the existing BSON for a Container in a page to see how margin and padding are stored.

   Since we are to provide an implementation guide, we will propose:

   • We add two fields to the Container struct: Margin and Padding (both of type int, representing pixels for all sides).
   • In the page builder, when building a page, we set default values for Margin and Padding (e.g., 0? or 8? or 16?) if the user did not specify in the MDL.
   • We update the grammar to accept margin and padding as integer properties in the page definition.

   However, note: the issue says the Container struct currently has no margin/padding fields. So we are adding them.

   But wait: the Container widget might already have margin and padding in the BSON? We are just not mapping them in the Go struct.

   We must check the BSON structure of a Container widget in an existing MPR.

   Since we cannot do that in this guide, we will assume that the Container widget in the Mendix model has margin and padding properties (as integers) and we are missing them in our Go struct.

   Steps for the MDL syntax:

   We will allow the user to set margin and padding in the page properties (like title, layout) as integers.

   Example:

   create page MyModule.HomePage (
   title: 'Home',
   layout: Atlas_Core.Atlas_Default,
   margin: 16,
   padding: 16
   ) {
   ...
   }

   If the user does not specify margin and padding, we apply defaults (say, 0 for now? but note: the issue says "sensible defaults"). We might look at what Mendix Studio Pro does by default when creating a page.

   However, without a specific example, we can set the default to 0 and then adjust later based on investigation.

   But note: the issue says "sensible defaults", so we should set them to what Mendix uses by default.

   We might ask: what is the default margin and padding for a Container in a new page in Studio Pro?

   However, for the purpose of this guide, we will note that the default values need to be determined by examining a Studio Pro created page.

4. Implementation Roadmap:

   We will follow the full-stack pipeline as outlined in the project context.

   Steps:

   a. Investigation (BSON structure for Container margin/padding):
   - Create a simple page in Studio Pro with a Container widget.
   - Note the margin and padding values set (if any) in the Container properties.
   - Use mxcli bson dump to see how margin and padding are stored in the BSON for the Container widget.

   b. Grammar (if user-settable):
   - Modify mdl/grammar/domains/MDLPage.g4 to accept margin and padding as properties in the page definition.
   - We will add two new properties: margin and padding, each expecting an integer.
   - Regenerate the parser: make grammar

   c. AST:
   - Add Margin and Padding fields to the AST node for page creation (in mdl/ast/ast_page.go). We'll create a new struct for page properties or add to the existing one.

   d. Visitor:
   - In the visitor for page creation (mdl/visitor/visitor_page.go), parse the margin and padding properties and set them in the AST.

   e. SDK Types:
   - In sdk/pages/pages_widgets_container.go, add Margin and Padding fields to the Container struct.
   - We must also add BSON tags so that they are serialized correctly.

   f. Parser (BSON → Go):
   - In sdk/mpr/parser_page.go (or wherever Container widgets are parsed), we need to parse the margin and padding from the BSON and set them in the Container struct.
   - We will look for the BSON keys for margin and padding (which we found in the investigation step).

   g. Writer (Go → BSON):
   - In sdk/mpr/writer_widgets.go (since Container is a widget), we need to serialize the Margin and Padding fields of the Container struct to BSON.

   h. Executor:
   - In mdl/executor/cmd_pages_builder_v3.go, when building a page, we will:
   - If the user provided margin and padding in the MDL, use those.
   - Otherwise, apply the default values (to be determined from investigation).
   - We will set these values on the Container widget that wraps the page content.

   i. Testing:
   - Add a doctest in mdl-examples/doctype-tests/ that creates a page with margin and padding and verifies via describe and by opening in Studio Pro.
   - Also test that when margin and padding are not provided, the defaults are applied.

5. BSON Investigation:

   We need to understand how margin and padding are stored in the BSON for a Container widget.

   Steps:

   • Create a test project in Studio Pro.
   • Add a page with a Container widget.
   • Set the Container's margin and padding to some known values (e.g., margin: 16, padding: 8) for each side? Or if we are using uniform, set all sides to 16 and 8.
   • Save the project.
   • Use mxcli bson dump to dump the page document and look for the Container widget.

   Example command:

   mxcli bson dump -p test.mpr --type page --object "MyModule.MyPage"
   

   Then look in the output for the Container widget and see how margin and padding are stored.

   We are particularly interested in the field names and the data type (likely integers).

   We might find that margin and padding are stored as:
   "Margin": { "Top": 16, "Right": 16, "Bottom": 16, "Left": 16 }
   or as a single integer if they are uniform.

   But note: the Container widget in Mendix might have separate fields for each side.

   However, the issue does not specify if we are to support individual sides. We are starting with uniform for simplicity.

   If the BSON stores margin as a struct with Top, Right, Bottom, Left, then we have two options:
   Option 1: Support only uniform margin/padding in MDL (and set all sides to the same value).
   Option 2: Support individual sides in MDL (like margin-top, margin-right, etc.) but that would be more complex.

   Given the issue's context, we will assume that we are to set a uniform value for all sides.

   Therefore, in the BSON, if we see that margin is stored as a struct, we will set all four sides to the same value when writing, and when reading we will take one side (if they are all equal) or note that they are not uniform (but we are only setting uniform so we assume they are equal).

   However, to keep it simple, we will assume that the Container widget's margin and padding are stored as a single integer (for all sides) in the BSON. We must verify.

   If they are stored as a struct, we will need to adjust our Go struct to match.

   Let's assume from the investigation that we find:

    "Margin": 16   // meaning 16 pixels on all sides
   

   Then we can store Margin as an int in our Container struct.

   If we find:

    "Margin": { "Top": 16, "Right": 16, "Bottom": 16, "Left": 16 }
   

   Then we would need to store Margin as a struct with four fields.

   But note: the issue says the Container struct currently has no margin/padding fields. So we are free to design the Go struct as we see fit, as long as we serialize to the correct BSON.

   We will base our Go struct on what we find in the BSON.

6. Testing Strategy:

   • Add a doctest script in mdl-examples/doctype-tests/03-page-examples.mdl (or similar) that includes:
     create page Test.PageWithSpacing (
     title: 'Test Page',
     layout: Atlas_Core.Atlas_Default,
     margin: 16,
     padding: 8
     ) {
     container cont {
     textbox txt (label: 'Test', attribute: test)
     }
     }

   • Then run:
     mxcli check mdl-examples/doctype-tests/03-page-examples.mdl // to check syntax
     mxcli exec mdl-examples/doctype-tests/03-page-examples.mdl -p test.mpr // to create the page
     mxcli -p test.mpr -c "describe page Test.PageWithSpacing" // to see if the margin and padding are in the describe output
     Open the project in Studio Pro and verify the Container has the expected margin and padding.

   • Also test without specifying margin and padding to see if the defaults are applied.

   • We should also test that the describe output is valid MDL that can be re-executed (roundtrip).

7. Gotchas & Risks:

   • Storage name vs qualified name: Not directly applicable here because we are adding fields to an existing widget (Container). We must ensure that the BSON field names we use for margin and padding match what Mendix expects.

   • Missing BSON defaults: If we set default values in the Go struct, we must ensure that they are serialized even if they are the default? Or only if they are non-zero? We should follow the existing pattern in the codebase: only serialize if non-default? Or always serialize? We need to check how other properties are handled.

   • CE error codes: If we get the BSON structure wrong, we might see errors when opening in Studio Pro, such as CE0000 (unknown error) or more specific ones. We should verify by creating a page in Studio Pro and comparing the BSON.

   • Version compatibility: The margin and padding properties might not exist in older Mendix versions. We should check the minimum version that supports these properties on the Container widget. If they are recent, we might need to gate the feature by version.

   • Default values: We must choose sensible defaults. If we choose 0, then there is no spacing. But the issue says the current behavior is that no margin/padding are applied (so effectively 0). We want to change that to a sensible default (like 8 or 16). We must determine what Mendix uses by default.

   • User override: If we allow the user to set margin and padding via MDL, we must make sure that the values are integers and within a reasonable range.

   • Impact on existing pages: When we add default margin/padding on page creation, it will only affect pages created via MDL after the change. Existing pages are unaffected.

   • The Container widget might not be the only widget that needs margin/padding? But the issue is about the Container that wraps the page content. The page builder wraps the page content in a Container. So we are only concerned with that specific Container.

   • **We must update the page builder to apply the margin/padding to the Container

---

Automated guide via OpenRouter — workflow source