8/15

# 3 Extending the Administration Console

The Administration Console is a browser-based tool for administering GlassFish Server. It features an easy-to-navigate interface and online help. Extending the Administration Console enables you to provide a graphical user interface for administering your add-on component. You can use any of the user interface features of the Administration Console, such as tree nodes, links on the Common Tasks page, tabs and sub-tabs, property sheets, and JavaServer Faces pages. Your add-on component implements a marker interface and provides a configuration file that describes how your customizations integrate with the Administration Console.

This chapter refers to a simple example called `console-sample-ip` that illustrates how to provide Administration Console features for a hypothetical add-on component. Instructions for obtaining and using this example are available at the example's project page. When you check out the code, it is placed in a directory named `glassfish-samples/v3/plugin/adminconsole/console-sample-ip/` in your current directory. In this chapter, path names for the example files are relative to this directory.

The following topics are addressed here:

- Administration Console Architecture

- About Administration Console Templates

- About Integration Points

- Specifying the ID of an Add-On Component

- Adding Functionality to the Administration Console

- Adding Internationalization Support

- Changing the Theme or Brand of the Administration Console

- Creating an Integration Point Type

## Administration Console Architecture

The Administration Console is a web application that is composed of OSGi bundles. These bundles provide all the features of the Administration Console, such as the Web Applications, Update Center, and Security content. To provide support for your add-on component, create your own OSGi bundle that implements the parts of the user interface that you need. Place your bundle in the `modules` directory of your GlassFish Server installation, along with the other Administration Console bundles.

To learn how to package the Administration Console features for an add-on component, go to the `modules` directory of your GlassFish Server installation and examine the contents of the files named `console-`componentname`-plugin.jar`. Place the `console-sample-ip` project bundle in the same place to deploy it and examine the changes that it makes to the Administration Console.

The Administration Console includes a Console Add-On Component Service. The Console Add-On Component Service is an HK2 service that acts as a façade to all theAdministration Console add-on components. The Console Add-On Component Service queries the various console providers for integration points so that it can perform the actions needed for the integration (adding a tree node or a new tab, for example). The interface name for this service is `org.glassfish.api.admingui.ConsolePluginService`.

For details about the Hundred-Kilobyte Kernel (HK2) project, see Hundred-Kilobyte Kernel and HK2 Component Model.

Each add-on component must contain a console provider implementation. This is a Java class that implements the `org.glassfish.api.admingui.ConsoleProvider` interface and uses the HK2 `@Service` annotation. The console provider allows your add-on component to specify where your integration point configuration file is located. This configuration file communicates to the Console Add-On Component Service the customizations that your add-on component makes to the Administration Console.

### Implementing a Console Provider

The `org.glassfish.api.admingui.ConsoleProvider` interface has one required method, `getConfiguration`. The `getConfiguration` method returns the location of the `console-config.xml` file as a `java.net.URL`. If `getConfiguration` returns `null`, the default location, `META-INF/admingui/console-config.xml`, is used. The `console-config.xml` file is described in About Integration Points.

To implement the console provider for your add-on component, write a Java class that is similar to the following example.

Example 3-1 Example `ConsoleProvider` Implementation

This example shows a simple implementation of the `ConsoleProvider` interface:

    package org.glassfish.admingui.plugin;

    import org.glassfish.api.admingui.ConsoleProvider;
    import org.jvnet.hk2.annotations.Service;

    import java.net.URL;

    @Service
    public class SamplePlugin implements ConsoleProvider {

        public URL getConfiguration() { return null; }
    }

This implementation of `getConfiguration` returns null to specify that the configuration file is in the default location. If you place the file in a nonstandard location or give it a name other than `console-config.xml`, your implementation of `getConfiguration` must return the URL where the file can be found.

You can find this example code in the file `project/src/main/java/org/glassfish/admingui/plugin/SamplePlugin.java`.

## About Administration Console Templates

GlassFish Server includes a set of templates that make it easier to create JavaServer Faces pages for your add-on component. These templates use Templating for JavaServer Faces Technology, which is also known as JSFTemplating.

Examples of JSFTemplating technology can be found in the following sections of this chapter:

- Creating a JavaServer Faces Page for Your Node

- Creating JavaServer Faces Pages for Your Tabs

- Creating a JavaServer Faces Page for Your Task

- Creating a JavaServer Faces Page for Your Task Group

- Creating a JavaServer Faces Page for Your Page Content

- Adding a Page to the Administration Console

## About Integration Points

The integration points for your add-on component are the individual Administration Console user interface features that your add-on component will extend. You can implement the following kinds of integration points:

- Nodes in the navigation tree

- Elements on the Common Tasks page of the Administration Console

- JavaServer Faces pages

- Tabs and sub-tabs

Specify all the integration points in a file named `console-config.xml`. In the example, this file is in the directory `project/src/main/resources/META-INF/admingui/`. The following sections describe how to create this file.

In addition, create JavaServer Faces pages that contain JSF code fragments to implement the integration points. In the example, these files are in the directory `project/src/main/resources/`. The content of these files depends on the integration point you are implementing. The following sections describe how to create these JavaServer Faces pages.

For reference information on integration points, see Integration Point Reference.

## Specifying the ID of an Add-On Component

The `console-config.xml` file consists of a `console-config` element that encloses a series of `integration-point` elements. The `console-config` element has one attribute, `id`, which specifies a unique name or ID value for the add-on component.

In the example, the element is declared as follows:

    <console-config id="sample">
        ...
    </console-config>

You will also specify this ID value when you construct URLs to images, resources and pages in your add-on component. See Adding a Node to the Navigation Tree for an example.

For example, a URL to an image named `my.gif` might look like this:

    <sun:image url="/resource/sample/images/my.gif" />

The URL is constructed as follows:

- `/resource` is required to locate any resource URL.

- `sample` is the add-on component ID. You must choose a unique ID value.

- `images` is a folder under the root of the add-on component JAR file.

## Adding Functionality to the Administration Console

The `integration-point` elements in the `console-config.xml` file specify attributes for the user interface features that you choose to implement. The example file provides examples of most of the available kinds of integration points at this release. Your own add-on component can use some or all of them.

For each `integration-point` element, specify the following attributes.

`id`

  An identifier for the integration point.

`parentId`

  The ID of the integration point's parent.

`type`

  The type of the integration point.

`priority`

  A numeric value that specifies the relative ordering of integration points for add-on components that specify the same `parentId`. A lower number specifies a higher priority (for example, 100 represents a higher priority than 400). The integration points for add-on components are always placed after those in the basic Administration Console. You might need to experiment to place the integration point where you want it. This attribute is optional.

`content`

  The content for the integration point, typically a JavaServer Faces page. In the example, you can find the JavaServer Faces pages in the directory `project/src/main/resources/`.

Note:

The order in which these attributes are specified does not matter, and in the example `console-config.xml` file the order varies. To improve readability, this chapter uses the same order throughout.

The following topics are addressed here:

- Adding a Node to the Navigation Tree

- Adding Tabs to a Page

- Adding a Task to the Common Tasks Page

- Adding a Task Group to the Common Tasks Page

- Adding Content to a Page

- Adding a Page to the Administration Console

### Adding a Node to the Navigation Tree

You can add a node to the navigation tree, either at the top level or under another node. To add a node, use an integration point of type `org.glassfish.admingui:navNode`. Use the `parentId` attribute to specify where the new node should be placed. Any tree node, including those added by other add-on components, can be specified. Examples include the following:

`tree`

  At the top level

`applicationServer`

  Under the GlassFish Server node

`applications`

  Under the Applications node

`resources`

  Under the Resources node

`configuration`

  Under the Configuration node

`webContainer`

  Under the Web Container node

`httpService`

  Under the HTTP Service node

Note:

The `webContainer` and `httpService` nodes are available only if you installed the web container module for the Administration Console (the `console-web-gui.jar` OSGi bundle).

If you do not specify a `parentId`, the new content is added to the root of the integration point, in this case the top level node, `tree`.

Example 3-2 Example Tree Node Integration Point

For example, the following `integration-point` element uses a `parentId` of `tree` to place the new node at the top level.

            <integration-point
                    id="samplenode"
                    parentid="tree"
                    type="org.glassfish.admingui:treeNode"
                    priority="200"
                    content="sampleNode.jsf"
            />

This example specifies the following values in addition to the `parentId`:

- The `id` value, `sampleNode`, specifies the integration point ID.

- The `type` value, `org.glassfish.admingui:treeNode`, specifies the integration point type as a tree node.

- The `priority` value, `200`, specifies the order of the node on the tree.

- The `content` value, `sampleNode.jsf`, specifies the JavaServer Faces page that displays the node.

The example `console-config.xml` file provides other examples of tree nodes under the Resources and Configuration nodes.

#### Creating a JavaServer Faces Page for Your Node

A JavaServer Faces page for a tree node uses the tag `sun:treeNode`. This tag provides all the capabilities of the Project Woodstock tag `webuijsf:treeNode`.

Example 3-3 Example JavaServer Faces Page for a Tree Node

In the example, the `sampleNode.jsf` file has the following content:

    <sun:treeNode
            id="treenode1"
            text="SampleTop"
            url="/sample/page/testPage.jsf?name=SampleTop"
            imageURL="/resource/sample/images/sample.png"
           >
        <sun:treeNode
                id="treenodebb"
                text="SampleBB"
                url="/sample/page/testPage.jsf?name=SampleBB"
                imageURL="resource/sample/images/sample.png" />
    </sun:treeNode>

This file uses the `sun:treenode` tag to specify both a top-level tree node and another node nested beneath it. In your own JavaServer Faces pages, specify the attributes of this tag as follows:

`id`

  A unique identifier for the tree node.

`text`

  The node name that appears in the tree.

`url`

  The location of the JavaServer Faces page that appears when you click the node. In the example, most of the integration points use a very simple JavaServer Faces page called `testPage.jsf`, which is in the `src/main/resources/page/` directory. Specify the integration point `id` value as the root of the URL; in this case, it is `sample` (see Specifying the ID of an Add-On Component). The rest of the URL is relative to the `src/main/resources/` directory, where `sampleNode.jsf` resides.

  The `url` tag in this example passes a `name` parameter to the JavaServer Faces page.

`imageURL`

  The location of a graphic to display next to the node name. In the example, the graphic is always `sample.png`, which is in the `src/main/resources/images/` directory. The URL for this image is an absolute path, `/resource/`sample`/images/sample.png`, where sample in the path is the integration point `id` value (see Specifying the ID of an Add-On Component).

### Adding Tabs to a Page

You can add a tab to an existing tab set, or you can create a tab set for your own page. One way to add a tab or tab set is to use an integration point of type `org.glassfish.admingui:serverInstTab`, which adds a tab to the tab set on the main GlassFish Server page of the Administration Console. You can also create sub-tabs. Once again, the `parentId` element specifies where to place the tab or tab set.

Example 3-4 Example Tab Integration Point

In the example, the following `integration-point` element adds a new tab on the main GlassFish Server page of the Administration Console:

            <integration-point
                id="sampletab"
                parentid="serverinsttabs"
                type="org.glassfish.admingui:serverInstTab"
                priority="500"
                content="sampleTab.jsf"
            />

This example specifies the following values:

- The `id` value, `sampleTab`, specifies the integration point ID.

- The `parentId` value, `serverInstTabs`, specifies the tab set associated with the server instance. The GlassFish Server page is the only one of the default Administration Console pages that has a tab set.

- The `type` value, `org.glassfish.admingui:serverInstTab`, specifies the integration point type as a tab associated with the server instance.

- The `priority` value, `500`, specifies the order of the tab within the tab set. This value is optional.

- The `content` value, `sampleTab.jsf`, specifies the JavaServer Faces page that displays the tab.

Example 3-5 Example Tab Set Integration Points

The following `integration-point` elements add a new tab with two sub-tabs, also on the main GlassFish Server page of the Administration Console:

            <integration-point
                id="sampletabwithsubtab"
                parentid="serverinsttabs"
                type="org.glassfish.admingui:serverInstTab"
                priority="300"
                content="sampleTabWithSubTab.jsf"
            />

            <integration-point
                id="samplesubtab1"
                parentid="sampletabwithsubtab"
                type="org.glassfish.admingui:serverInstTab"
                priority="300"
                content="sampleSubTab1.jsf"
            />
            <integration-point
                id="samplesubtab2"
                parentid="sampletabwithsubtab"
                type="org.glassfish.admingui:serverInstTab"
                priority="400"
                content="sampleSubTab2.jsf"
            />

These examples specify the following values:

- The `id` values, `sampleTabWithSubTab`, `sampleSubTab1`, and `sampleSubTab2`, specify the integration point IDs for the tab and its sub-tabs.

- The `parentId` of the new tab, `serverInstTabs`, specifies the tab set associated with the server instance. The `parentId` of the two sub-tabs, `sampleTabWithSubTab`, is the `id` value of this new tab.

- The `type` value, `org.glassfish.admingui:serverInstTab`, specifies the integration point type for all the tabs as a tab associated with the server instance.

- The `priority` values specify the order of the tabs within the tab set. This value is optional. In this case, the priority value for `sampleTabWithSubTab` is `300`, which is higher than the value for `sampleTab`. That means that `sampleTabWithSubTab` appears to the left of `sampleTab` in the Administration Console. The priority values for `sampleSubTab1` and `sampleSubTab2` are `300` and `400` respectively, so `sampleSubTab1` appears to the left of `sampleSubTab2`.

- The `content` values, `sampleTabWithSubTab.jsf`, `sampleSubTab1.jsf`, and `sampleSubTab2.jsf`, specify the JavaServer Faces pages that display the tabs.

#### Creating JavaServer Faces Pages for Your Tabs

A JavaServer Faces page for a tab uses the tag `sun:tab`. This tag provides all the capabilities of the Project Woodstock tag `webuijsf:tab`.

Example 3-6 Example JavaServer Faces Page for a Tab

In the example, the `sampleTab.jsf` file has the following content:

    <sun:tab id="sampletab" immediate="true" text="Sample First Tab">
        <!command
            setSessionAttribute(key="serverInstTabs" value="sampleTab");
            gf.redirect(page="#{request.contextPath}/page/tabPage.jsf?name=Sample%20First%20Tab");
        />
    </sun:tab>

Note:

In the actual file there are no line breaks in the `gf.redirect` value.

In your own JavaServer Faces pages, specify the attributes of this tag as follows:

`id`

  A unique identifier for the tab, in this case `sampleTab`.

`immediate`

  If set to true, event handling for this component should be handled immediately (in the Apply Request Values phase) rather than waiting until the Invoke Application phase.

`text`

  The tab name that appears in the tab set.

The JSF page displays tab content differently from the way the page for a node displays node content. It invokes two handlers for the `command` event: `setSessionAttribute` and `gf.redirect`. The `gf.redirect` handler has the same effect for a tab that the `url` attribute has for a node. It navigates to a simple JavaServer Faces page called `tabPage.jsf`, in the `src/main/resources/page/` directory, passing the text "Sample First Tab" to the page in a `name` parameter.

The `sampleSubTab1.jsf` and `sampleSubTab2.jsf` files are almost identical to `sampleTab.jsf`. The most important difference is that each sets the session attribute `serverInstTabs` to the base name of the JavaServer Faces file that corresponds to that tab:

    setSessionAttribute(key="serverInstTabs" value="sampleTab");

    setSessionAttribute(key="serverInstTabs" value="sampleSubTab1");

    setSessionAttribute(key="serverInstTabs" value="sampleSubTab2");

### Adding a Task to the Common Tasks Page

You can add either a single task or a group of tasks to the Common Tasks page of the Administration Console. To add a task or task group, use an integration point of type `org.glassfish.admingui:commonTask`.

See Adding a Task Group to the Common Tasks Page for information on adding a task group.

Example 3-7 Example Task Integration Point

In the example `console-config.xml` file, the following `integration-point` element adds a task to the Deployment task group:

            <integration-point
                    id="samplecommontask"
                    parentid="deployment"
                    type="org.glassfish.admingui:commonTask"
                    priority="200"
                    content="sampleCommonTask.jsf"
            />

This example specifies the following values:

- The `id` value, `sampleCommonTask`, specifies the integration point ID.

- The `parentId` value, `deployment`, specifies that the task is to be placed in the Deployment task group.

- The `type` value, `org.glassfish.admingui:commonTask`, specifies the integration point type as a common task.

- The `priority` value, `200`, specifies the order of the task within the task group.

- The `content` value, `sampleCommonTask.jsf`, specifies the JavaServer Faces page that displays the task.

#### Creating a JavaServer Faces Page for Your Task

A JavaServer Faces page for a task uses the tag `sun:commonTask`. This tag provides all the capabilities of the Project Woodstock tag `webuijsf:commonTask`.

Example 3-8 Example JavaServer Faces Page for a Task

In the example, the `sampleCommonTask.jsf` file has the following content:

    <sun:commonTask
            text="Sample Application Page"
            toolTip="Sample Application Page"
            onClick="return admingui.woodstock.commonTaskHandler('treeForm:tree:applications:ejb',
            '#{request.contextPath}/sample/page/testPage.jsf?name=Sample%20Application%20Page');">
    </sun:commonTask>

Note:

In the actual file, there is no line break in the `onClick` attribute value.

This file uses the `sun:commonTask` tag to specify the task. In your own JavaServer Faces pages, specify the attributes of this tag as follows:

`text`

  The task name that appears on the Common Tasks page.

`toolTip`

  The text that appears when a user places the mouse cursor over the task name.

`onClick`

  Scripting code that is to be executed when a user clicks the task name.

### Adding a Task Group to the Common Tasks Page

You can add a new group of tasks to the Common Tasks page to display the most important tasks for your add-on component. To add a task group, use an integration point of type `org.glassfish.admingui:commonTask`.

Example 3-9 Example Task Group Integration Point

In the example `console-config.xml` file, the following `integration-point` element adds a new task group to the Common Tasks page:

           <integration-point
                id="samplegroup"
                parentid="commontaskssection"
                type="org.glassfish.admingui:commonTask"
                priority="500"
                content="sampleTaskGroup.jsf"
            />

This example specifies the following values:

- The `id` value, `sampleGroup`, specifies the integration point ID.

- The `parentId` value, `commonTasksSection`, specifies that the task group is to be placed on the Common Tasks page.

- The `type` value, `org.glassfish.admingui:commonTask`, specifies the integration point type as a common task.

- The `priority` value, `500`, specifies the order of the task group on the Common Tasks page. The low value places it at the end of the page.

- The `content` value, `sampleTaskGroup.jsf`, specifies the JavaServer Faces page that displays the task.

#### Creating a JavaServer Faces Page for Your Task Group

A JavaServer Faces page for a task group uses the tag `sun:commonTasksGroup`. This tag provides all the capabilities of the Project Woodstock tag `webuijsf:commonTasksGroup`.

Example 3-10 Example JavaServer Faces Page for a Task Group

In the example, the `sampleTaskGroup.jsf` file has the following content:

    <sun:commonTasksGroup title="My Own Sample Group">
        <sun:commonTask
                text="Go To Sample Resource"
                toolTip="Go To Sample Resource"
                onClick="return admingui.woodstock.commonTaskHandler('form:tree:resources:treeNode1',
                '#{request.contextPath}/sample/page/testPage.jsf?name=Sample%20Resource%20Page');">
        </sun:commonTask>
        <sun:commonTask
                text="Sample Configuration"
                toolTip="Go To Sample Configuration"
                onClick="return admingui.woodstock.commonTaskHandler('form:tree:configuration:sampleConfigNode',
                '#{request.contextPath}/sample/page/testPage.jsf?name=Sample%20Configuration%20Page');">
        </sun:commonTask>
    </sun:commonTasksGroup>

Note:

In the actual file, there are no line breaks in the `onClick` attribute values.

This file uses the `sun:commonTasksGroup` tag to specify the task group, and two `sun:commonTask` tags to specify the tasks in the task group. The `sun:commonTasksGroup` tag has only one attribute, `title`, which specifies the name of the task group.

### Adding Content to a Page

You can add content for your add-on component to an existing top-level page, such as the Configuration page or the Resources page. To add content to one of these pages, use an integration point of type `org.glassfish.admingui:configuration` or `org.glassfish.admingui:resources`.

Example 3-11 Example Resources Page Implementation Point

In the example `console-config.xml` file, the following `integration-point` element adds new content to the top-level Resources page:

            <integration-point
                    id="sampleresourcelink"
                    parentid="propsheetsection"
                    type="org.glassfish.admingui:resources"
                    priority="100"
                    content="sampleResourceLink.jsf"
            />

This example specifies the following values:

- The `id` value, `sampleResourceLink`, specifies the integration point ID.

- The `parentId` value, `propSheetSection`, specifies that the content is to be a section of a property sheet on the page.

- The `type` value, `org.glassfish.admingui:resources`, specifies the integration point type as the Resources page.

  To add content to the Configuration page, specify the `type` value as `org.glassfish.admingui:configuration`.

- The `priority` value, `100`, specifies the order of the content on the Resources page. The high value places it at the top of the page.

- The `content` value, `sampleResourceLink.jsf`, specifies the JavaServer Faces page that displays the new content on the Resources page.

Another `integration-point` element in the `console-config.xml` file places similar content on the Configuration page.

#### Creating a JavaServer Faces Page for Your Page Content

A JavaServer Faces page for page content often uses the tag `sun:property` to specify a property on a property sheet. This tag provides all the capabilities of the Project Woodstock tag `webuijsf:property`.

Example 3-12 Example JavaServer Faces Page for a Resource Page Item

In the example, the `sampleResourceLink.jsf` file has the following content:

    <sun:property>
        <sun:hyperlink
            toolTip="Sample Resource"
            url="/sample/page/testPage.jsf?name=Sample%20Resource%20Page">
            <sun:image url="/resource/sample/images/sample.png" />
            <sun:staticText text="Sample Resource" />
        </sun:hyperlink>
    </sun:property>

    <sun:property>
        <sun:hyperlink
            toolTip="Another"
            url="/sample/page/testPage.jsf?name=Another">
            <sun:image url="/resource/sample/images/sample.png" />
            <sun:staticText text="Another" />
        </sun:hyperlink>
    </sun:property>

The file specifies two simple properties on the property sheet, one above the other. Each consists of a `sun:hyperlink` element (a link to a URL). Within each `sun:hyperlink` element is nested a `sun:image` element, specifying an image, and a `sun:staticText` element, specifying the text to be placed next to the image.

Each `sun:hyperlink` element uses a `toolTip` attribute and a `url` attribute. Each `url` attribute references the `testPage.jsf` file that is used elsewhere in the example, specifying different content for the `name` parameter.

You can use many other kinds of user interface elements within a `sun:property` element.

### Adding a Page to the Administration Console

Your add-on component may require new configuration tasks. In addition to implementing commands that accomplish these tasks (see Chapter 4, "Extending the `asadmin` Utility"), you can provide property sheets that enable users to configure your component or to perform tasks such as creating and editing resources for it.

Example 3-13 Example JavaServer Faces Page for a Property Sheet

Most of the user interface features used in the example reference the file `testPage.jsf` or (for tabs) the file `tabPage.jsf`. Both files are in the `src/main/resources/page/` directory. The `testPage.jsf` file looks like this:

    <!composition template="/templates/default.layout" guiTitle="TEST Sample Page Title">
    <!define name="content">
    <sun:form id="propertyform">

    <sun:propertySheet id="propertysheet">
        <sun:propertySheetSection id="propertysection">
           <sun:property id="prop1" labelAlign="left" noWrap="true"
                         overlapLabel="false" label="Test Page Name:">
                <sun:staticText text="$pageSession{pageName}">
                    <!beforeCreate
                        getRequestValue(key="name" value=>$page{pageName});
                    />
                </sun:staticText>
            </sun:property>
        </sun:propertySheetSection>
    </sun:propertySheet>
    <sun:hidden id="helpkey" value="" />

    </sun:form>
    </define>
    </composition>

The page uses the `composition` directive to specify that the page uses the `default.layout` template and to specify a page title. The page uses additional directives, events, and tags to specify its content.

## Adding Internationalization Support

To add internationalization support for your add-on component to the Administration Console, you can place an event and handler like the following at the top of your page:

    <!initPage
        setResourceBundle(key="yourI18NKey" bundle="bundle.package.BundleName")
    />

Replace the values `yourI18NKey` and `bundle.package.BundleName` with appropriate values for your component.

## Changing the Theme or Brand of the Administration Console

To change the theme or brand of the Administration Console for your add-on component, use the integration point type `org.glassfish.admingui:customtheme`. This integration point affects the Cascading Style Sheet (CSS) files and images that are used in the Administration Console.

Example 3-14 Example Custom Theme Integration Point

For example, the following integration point specifies a custom theme:

            <integration-point
                    id="myownbrand"
                    type="org.glassfish.admingui:customtheme"
                    priority="2"
                    content="myOwnBrand.properties"
            />

The `priority` attribute works differently when you specify it in a branding integration point from the way it works in other integration points. You can place multiple branding add-on components in the `modules` directory, but only one theme can be applied to the Administration Console. The `priority` attribute determines which theme is used. Specify a value from 1 to 100; the lower the number, the higher the priority. The integration point with the highest priority will be used.

Additional integration point types also affect the theme or brand of the Administration Console:

`org.glassfish.admingui:masthead`

  Specifies the name and location of the include masthead file, which can be customized with a branding image. This include file will be integrated on the masthead of the Administration Console.

`org.glassfish.admingui:loginimage`

  Specifies the name and location of the include file containing the branding login image code that will be integrated with the login page of the Administration Console.

`org.glassfish.admingui:loginform`

  Specifies the name and location of the include file containing the customized login form code. This code also contains the login background image used for the login page for the Administration Console.

`org.glassfish.admingui:versioninfo`

  Specifies the name and location of the include file containing the branding image that will be integrated with the content of the version popup window.

Example 3-15 Example of Branding Integration Points

For example, you might specify the following integration points. The content for each integration point is defined in an include file.

           <integration-point
                   id="myownbrandmast"
                   type="org.glassfish.admingui:masthead"
                   priority="80"
                   content="branding/masthead.inc"
           />
           <integration-point
                   id="myownbrandlogimg"
                   type="org.glassfish.admingui:loginimage"
                   priority="80"
                   content="branding/loginimage.inc"
           />
           <integration-point
                   id="myownbrandlogfm"
                   type="org.glassfish.admingui:loginform"
                   priority="80"
                   content="branding/loginform.inc"
           />
           <integration-point
                   id="myownbrandversinf"
                   type="org.glassfish.admingui:versioninfo"
                   priority="80"
                   content="branding/versioninfo.inc"
           />

To provide your own CSS and images to modify the global look and feel of the entire application (not just the Administration Console), use the theming feature of Project Woodstock. Create a theme JAR file with all the CSS properties and image files that are required by your Woodstock component. Use a script provided by the Woodstock project to clone an existing theme, then modify the files and properties as necessary. Once you have created the theme JAR file, place it in the `WEB-INF/lib` directory of the Administration Console so that the Woodstock theme component will load the theme. In addition, edit the properties file specified by your integration point (`MyOwnBrand.properties`, for example) to specify the name and version of your theme.

## Creating an Integration Point Type

If your add-on component provides new content that you would like other people to extend, you may define your own integration point types. For example, if you add a new page that provides tabs of monitoring information, you might want to allow others to add their own tabs to complement your default tabs. This feature enables your page to behave like the existing Administration Console pages that you or others can extend.

### To Create an Integration Point Type

1. Decide on the name of your integration point type.

   The integration point type must be a unique identifier. You might use the package name of your integration point, with a meaningful name appended to the end, as in the following example:

       org.company.project:myMonitoringTabs

2. After you have an integration point ID, use handlers to insert the integration point implementation(s).

   Include code like the following below the place in your JavaServer Faces page where you would like to enable others to add their integration point implementations:

       <event>
           <!afterCreate
               getUIComponent(clientid="clientid:of:root"
                              component=>$attribute{rootComp});
               includeIntegrations(type="org.company.project:myMonitoringTabs"
                                   root="#{rootComp}");
           />
       </event>

   Change `clientId:of:root` to match the `clientId` of the outermost component in which you want others to be able to add their content (in this example, the tab set is the most likely choice). Also include your integration point ID in place of `org.company.project:myMonitoringTabs`. If you omit the `root` argument to `includeIntegrations`, all components on the entire page can be used for the `parentId` of the integration points.

3. To enable others to use this integration point, document it at the GlassFish Integration Point wiki page.

   Document the integration point only if your content is publicly available.

   You or others can now provide an integration point that will be integrated into this page.