This example shows how you can work either the `headerContent, bodyContent, footerContent` attributes, to replace content in the Overlay's standard module sections, or use the `setStdModContent(section, content, where)` method to insert content before, or append it after existing content in the section.

{{>overlay-stdmod-source}}

Overlay's Standard Module Support

Setting Up The YUI Instance

To create an instance of an Overlay on your page, the only module you need to request is the `overlay` module. The `overlay` module will pull in the `widget`, `widget-stack`, `widget-position`, `widget-position-align`, `widget-position-constrain` and `widget-stdmod` extensions it uses.

``` YUI({...}).use("overlay", function(Y) { // We'll write example code here, where we have a Y.Overlay class available. }); ```

Note, using the `overlay` module, will also pull down the default CSS required for overlay, on top of which we only need to add our required look/feel CSS for the example.

{{>need-skin-note}} ``` {{>need-skin-comment}} ```

Creating The Overlay From Markup

For this example, we'll create the overlay instance from markup which already exists on the page, and is shown below. We mark the existing markup with the `yui3-overlay-loading` class, so that we can hide it while the rich control is being instantiated:

```
Overlay Header
Overlay Body
Overlay Footer
```

Instantiating The Overlay

To create an overlay instance, we use the overlay constructor `Y.Overlay`, and pass it the `srcNode` reference for the existing markup on the page:

``` var overlay = new Y.Overlay({ srcNode:"#overlay", width:"20em", align: { node:"#overlay-stdmod > .filler", points:["tl", "tl"] } }); overlay.render(); ```

We also set it's width and align it to the filler paragraph in the example box ("#overlay-stdmod > .filler"). We don't pass any node references to the `render` method, so the Overlay is rendered in the location of the contentBox provided.

Setting Content

The example provides a set of input fields, allowing the user to set content in either of the 3 standard module sections which Overlay supports using Overlay's `setStdModContent` method. The content can either be inserted before, appended after, or replace existing content in the specified section.

Additionally the new content can be converted to a node instance before being added to the specified section. Although it has no impact on the example, if the new content is added as a string, innerHTML is used to insert before or append after the existing section content, removing any event listeners which may have been attached to elements inside the section.

``` // Hold onto input field references. var content = Y.one("#content"); var where = Y.one("#where"); var section = Y.one("#section"); Y.on("click", function() { // New content to be added. For this example, we escape the HTML since it's // coming from an unknown source, however Overlay accepts HTML strings as // content (you should ensure it's coming from a trusted source). var newContent = Y.Escape.html(content.get("value")); overlay.setStdModContent(section.get("value"), newContent, where.get("value")); }, "#setHTML"); ```

CSS: Overlay Look/Feel

As with the other basic overlay examples, the overlay.css Sam Skin file (build/overlay/assets/skins/sam/overlay.css) provides the default functional CSS for the overlay. Namely the CSS rules to hide the overlay, and position it absolutely. However there's no default out-of-the-box look/feel applied to the Overlay widget.

The example provides it's own look and feel for the Overlay, by defining rules for the content box, header, body and footer sections:

``` /* Hide overlay markup while loading, if js is enabled */ .yui3-js-enabled .yui3-overlay-loading { top:-1000em; left:-1000em; position:absolute; } {{>overlay-css}} ```

Complete Example Source

``` {{>overlay-stdmod-source}} ```