The type of segment includes some standard HTML partition elements, like frames, divisions and layers, listed below.

<table>
<frame> (dynamic)
<iframe>(dynamic)
<span>
<div>
<row>
<td>
<layer>

On some platforms, these could have implementation as dynamic components that could allow application of behaviors to their rendering and enabling capabilities.

Apart from the HTML segments, there are other segments that could be demarcated using dWebSpec annotations. They are listed as follows:

inline (default):
This allows demarcation of sections on the pages.

static-include:
Used to demarcate a segment of the page that is included by the server during assembly or compilation. In essence, identical segments could exist in multiple places: reuse. Of which, one of these would be declared as the template. Others would then extend the template.

See attributes extends, base-page-id and value.

dynamic-include: All information concerning static include also pertains to dynamic include. However, the dynamic include does involve dynamic request.

See attributes extends, base-page-id and event-id.

The data aspect of dynamic segments usually involves additional steps for the data interchange to work in cooperation with that of the rest of the page. This is owing to the fact that such segments might not share the same page or request scope with the rest of the page.

The support for dynamic include as well as the impact on bindings, would vary from platform to platform.

insert-include:

This could be similar to the dynamic includes, with the distinction that the assembly process is triggered by external controls rather than actions or directives from within the page. The presence of this tag on a page would normally signify that the page is involved in template scheme.

A page involved in a template scheme could either be the template, in some cases called the master page, or else the page could use a template. The distinction is that the user would specify the template page in use, in the page descriptor.

For the template page, the insert-include segments are those segment that should be or could be replace by the pages using the template. A page using a template would override the segments with its own segments that match the id of those segments in the template.

From the list of intrinsic HTML segments, Struts platform only provides dynamic version for the <frame> element.

Struts being an action framework provides means of terse entries for actions and parameters for all links or action related elements. The frame is represented with <html:frame> tag, which provides the parameters to load actions for rendering the frame.

inline (default):

This type of segment is mainly for partitioning the page for the application of behavior. In itself there is no implementation involved, but the behavior attached would translate into a logic tag.

Example of this is shown below:

  <logic:x>
  <!--aws:segment id="actionEqualNew" -->

  . . . . Code for Create . . . .
  <!--/aws:segment -->
  </logic:x>
  

static-include:
Static include is implemented with the @include tag.

<@include file= ""/>

The file entry is derived from the value entry of the segment descriptor.

dynamic-include:

Dynamic include is implemented with the jsp:include tag; example shown below.

<jsp:include page="included.html" />

The page entry is derived from the value attribute of the segment descriptor. This is for simple page include; whenever there is action involved, the action details would be derived from the event-id attribute of this descriptor.

insert-include:

This is used for template schemes.

For Struts the standard templates are provided by Tiles.

.

For a template page, this segment definition would be translated into the following syntax.

<tiles:insert attribute="segment-id"/>

The attribute above would be derived from the segment id.

For the page using this definition, the translation would be as follows.

<tiles:put name="segment-id" value="page-url"/>