Master spreads & overrides

A master spread is layout authored once and inherited by many body pages; an override is how one page keeps most of that master while replacing a single item.

In short: A long document repeats itself — the same header rule, the same folio, the same column frame, page after page. In IDML, a master spread holds that repeating layout once, and every body page that names it inherits its items at render time. An override is the escape hatch: a body page lists the Self id of a master item it wants to take over, and the renderer leaves that one item out so the page's own version can stand in. This chapter is the deep companion to the Layout model's introduction — it takes apart the two mechanics underneath masters and overrides: stamping (how a master item reaches a body page) and resolution (how a page suppresses the ones it replaces).

A long document repeats itself. The same header rule sits at the top of every chapter page; the same folio sits in the same corner of every spread; the same column frame waits to be filled on page after page. Re-drawing that furniture by hand on every page would be tedious to author and impossible to keep consistent. A master spread is IDML's answer: author the repeating layout once, then have each body page inherit it. An override is the escape hatch — the way a single page keeps most of the master but swaps out one item it needs to be different.

The Layout model chapter introduces both ideas in passing: Master spreads shows that a MasterSpread is structurally just a Spread, and Override resolution shows the one-item swap end to end. This chapter is the deeper companion. It does not re-teach those basics — it takes apart the two mechanics underneath them: how a master item actually reaches a body page (stamping), and how a body page's OverrideList tells the renderer which of those items to leave out (resolution). If you have not met spreads, pages, and the AppliedMaster link yet, read the layout model first; this chapter assumes them.

Why a reader ends up here

You are here because a page is showing too much, too little, or the wrong thing from its master. To predict what a body page renders you have to hold two facts at once:

• What the master contributes. Master items are not copied into the body page's XML — they are stamped onto it at render time, beneath the page's own items. Which master items land on which body page (and where) is a routing and transform question, not a parsing one.
• What the body page suppresses. A body page carries an OverrideList: the Self ids of master items it has taken over. The stamping pass skips exactly those ids, so the body's own replacement can stand in their place.

Get either half wrong and the page is off by one item. The two sub-pages below take each half in turn.

The two mechanics

• Master items and stamping — how a body page inherits its master's items: the per-page routing, the back-of-the-list placement, the MasterPageTransform offset, and the ShowMasterItems flag. This is the inheritance half.
• Override resolution — how OverrideList records which master items a page has replaced, how stamping skips them, and the honest limits of the current resolver. This is the exception half.

The ordering here is reader progression: you cannot reason about what an override removes until you know what stamping adds, so stamping comes first. It is not the source spec's arrangement (clean-room §6.1).

The master and body elements themselves — MasterSpread, Spread, Page, and the page-item shapes they hold — are the Layout model's subject. This chapter is about the relationship between a master and the pages that borrow from it.

Frequently asked questions

What is a master spread in IDML? A master spread is a reusable layout that other pages inherit from. Structurally it is just a Spread — the same parser reads both — but body pages can name it via AppliedMaster, and its items are stamped onto each of those pages at render time so repeating furniture (headers, folios, background panels) is authored once rather than redrawn on every page.

What is the difference between stamping and override resolution? Stamping is the inheritance half: the renderer copies a master's eligible items onto each body page that names the master, offset onto that page's origin. Override resolution is the exception half: a body page's OverrideList records which master-item ids it has taken over, and the stamping pass skips exactly those ids so the page's own replacement can stand in. Stamping adds; resolution subtracts.

Why does this chapter exist if the layout model already covers masters? The Layout model introduces masters and overrides at the level you need to read a layout: a MasterSpread is a Spread, and an override swaps one item. This chapter is the deeper companion for when a page renders too much, too little, or the wrong thing from its master — it documents the two mechanics underneath, including the attributes the renderer reads and the parts it does not yet honor.