#
# Copyright 2004-2013 ICEsoft Technologies Canada Corp.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the
# License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an "AS
# IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
# express or implied. See the License for the specific language
# governing permissions and limitations under the License.
#

showcase.title = ICEfaces Showcase
menu.ace.title = ACE Components
menu.compat.title = ICE Components
menu.ee.title = EE Components

menu.ace.tooltip = ACE Components Showcase
menu.compat.tooltip = ICE Components Showcase
################################################################################
# ICEfaces Advanced Components (ACE)                                           #
################################################################################
### ACE - Overview
menu.ace.aceSuiteOverview.title = ACE Overview
menu.ace.aceSuiteOverview.subMenu.title = Examples
menu.ace.aceSuiteOverview.subMenu.main = Overview
# Overview
example.ace.aceSuiteOverview.title = ACE Overview
example.ace.aceSuiteOverview.description = <h2>What are the ACE Components?</h2><p>The ACE Components (ICEfaces Advanced Components) are the next-generation of open source ICEfaces components. Featuring over 40 components including the industry-leading ace:dataTable, the ACE Components utilize a blend of server-side and client-based rendering techniques to provide a rich, responsive user-experience with reduced network and server-processing requirements.</p><br/><p>Key features of the ACE Components include:<br/><ul><li><b>&#187;</b> Leverage powerful JavaScript components from leading 3rd-party libraries, such as jQuery, while shielding ICEfaces application developers from having to learn/use JavaScript directly.</li><li><b>&#187;</b> Support extensive client-side functionality to improve component richness, responsiveness, and scalability.</li><li><b>&#187;</b> Provide a flexible and consistent approach to UI theming/skinning across all components, based on jQuery ThemeRoller themes.</li></ul></p><br/><p>The ACE Components are authored using the ICEfaces Advanced Component Environment, which implements a consistent approach to component authoring, meta-data management, and automates common component development tasks and optimizations.</p><h2>When should I use the ACE Components?</h2><p>The ACE Components are ideally suited to ICEfaces projects that are able to leverage the power of modern browsers to provide a richer, more dynamic and responsive user-interface. The ACE Components provide a higher degree of client-side rendering, behaviours, and Ajax transaction flexibility. This reduces both the number and size of render-cycles required for typical interactions, and provides a highly responsive user-interface. In future ICEfaces releases, new component features will be implemented primarily on the ACE component platform, therefore the ACE Components will continue to evolve rapidly.</p><h2>How are the ACE Components Licensed?</h2><p>The ACE Components are made available under the Apache License Version 2 open source License. All code modifications and component enhancements are free for developers to use, distribute and modify.</p><h2>How can I find out more about the components?</h2><p>The component samples included in this ICEfaces Showcase application include source code for each sample, located at the bottom of each page. In addition, links to technical documentation and the component TLD documentation are provided on the right-hand side menu on the header bar for each sample.</p><br><p>The complete source code for this sample application is included in the <a href="http://www.icesoft.org/java/downloads/icefaces-downloads.jsf" style="text-decoration: underline;" target="_blank" >ICEfaces release bundle</a>.</p>

### ACE - Accordion Panel
menu.ace.accordionpanel.title = ace:accordion
menu.ace.accordionpanel.subMenu.title = Examples
menu.ace.accordionpanel.subMenu.main = Overview
menu.ace.accordionpanel.subMenu.dynamic = Pane Change
menu.ace.accordionpanel.subMenu.effect = Toggle Effect
# Overview
example.ace.accordionpanel.title = ace:accordion - Overview
example.ace.accordionpanel.description = <p>The <b>&lt;ace:accordion&gt;</b> component is a container element with collapsible / expandable panes stacked vertically. Once placed on a page it can have any number of tabs, each having its own content. Click on any of the three headers below to expand the pane and view its associated content.</p>
# Dynamic
example.ace.accordionpanel.dynamic.title = ace:accordion - Pane Change Listener Example
example.ace.accordionpanel.dynamic.description = <p>A paneChangeListener can be attached to the <b>&lt;ace\:accordion&gt;</b> component and used in scenarios where server side logic needs to be executed when a user switches between tabs. A component update command can be bundled with paneChangeListener to partially update the page once an AJAX call has been completed. To view the demo, click on any of the tab\u2019s below. The pane selection is identified to the application logic on the server which then mirrors back the selection details by updating the text field below the tabs.</p>
# Effect
example.ace.accordionpanel.effect.title = ace:accordion - Animation Effect Example
example.ace.accordionpanel.effect.description = <p>Animation effects can be added to the accordion panel which will be activated on tab expansion and close. Hover over the tabs below with the mouse to view the animation results.</p>

### ACE - Animation Panel
menu.ace.animation.title = ace:animation
menu.ace.animation.subMenu.title = Examples
menu.ace.animation.subMenu.main = Overview
# Overview
example.ace.animation.title = ace:animation - Overview
example.ace.animation.description = <p>ICEFaces provides an animation system using attachable behavior, which allows developers to add various animation(s) to many of the ACE components. Click on the panels below in order to view the associated animation effect.</p>

### ACE - AutoCompleteEntry
menu.ace.autocompleteentry.title = ace:autoCompleteEntry
menu.ace.autocompleteentry.subMenu.main = Overview
menu.ace.autocompleteentry.subMenu.title = Example
menu.ace.autocompleteentry.subMenu.select = Select Items
menu.ace.autocompleteentry.subMenu.facet = Custom Facet
menu.ace.autocompleteentry.subMenu.match = Match Criteria
menu.ace.autocompleteentry.subMenu.rows = Displayed Rows
menu.ace.autocompleteentry.subMenu.lazy = Lazy Loading
menu.ace.autocompleteentry.subMenu.label = Label Position
menu.ace.autocompleteentry.subMenu.indicator = Indicator Text
menu.ace.autocompleteentry.subMenu.reqStyle = Required Styling
# Overview
example.ace.autocompleteentry.title = ace:autoCompleteEntry - Overview
example.ace.autocompleteentry.description = <p>The <b>&lt;ace:autoCompleteEntry&gt;</b> component is a text input component that displays a list of possible valid options as the user types.</p>
# Select Items
example.ace.autocompleteentry.select.title = ace:autoCompleteEntry - Select Items
example.ace.autocompleteentry.select.description = <p>The autoCompleteEntry component can define the selectable items using standard a f:selectItems component pointing to a list of SelectItem objects. This example demonstrates that using a list of cities.</p>
# Facet
example.ace.autocompleteentry.facet.title = ace:autoCompleteEntry - Custom Facet
example.ace.autocompleteentry.facet.description = <p>The autoCompleteEntry component can define the selectable items using a custom facet with any desired formatting. In this example we use an image icon, the city and country name all defined in a styled custom facet.</p>
# Match Criteria
example.ace.autocompleteentry.match.title = ace:autoCompleteEntry - Match Criteria
example.ace.autocompleteentry.match.description = <p>The autoCompleteEntry component can define how it will attempt to match and filter user entry in relation to the list of items.</p>
# Displayed Rows
example.ace.autocompleteentry.rows.title = ace:autoCompleteEntry - Displayed Rows
example.ace.autocompleteentry.rows.description = <p>The autoCompleteEntry component can customize how many rows to display in the dropdown of filtered items.</p>
# Lazy Loading
example.ace.autocompleteentry.lazy.title = ace:autoCompleteEntry - Lazy Loading
example.ace.autocompleteentry.lazy.description = <p>This example shows how to load the possible options lazily from an external data source (e.g. a database) and perform some custom filtering. The application checks the latitudes of the cities and only shows those which lie between the tropics (roughly -23.0 to 23.0), so American and Canadian cities will not appear in the list of possible values.</p>
# Label Position
example.ace.autocompleteentry.label.title = ace:autoCompleteEntry - Label Position
example.ace.autocompleteentry.label.description = <p>This example shows to render, customize, and position an inline label for the autoCompleteEntry component.</p>
# Indicator Text
example.ace.autocompleteentry.indicator.title = ace:autoCompleteEntry - Indicator Text
example.ace.autocompleteentry.indicator.description = <p>This example shows how to customize the text of the required and optional indicator message.</p>
# Required Styling
example.ace.autocompleteentry.reqStyle.title = ace:autoCompleteEntry - Required Styling
example.ace.autocompleteentry.reqStyle.description = <p>This example shows how the autoCompleteEntry field can be customized to better indicate required or optional status beyond a simple message.</p>

### ACE - BreadcrumbMenu
menu.ace.breadcrumbmenu.title = ace:breadcrumbMenu
menu.ace.breadcrumbmenu.submenu.main = Overview
# Overview
example.ace.breadcrumbmenu.title = ace:breadcrumbMenu - Overview
example.ace.breadcrumbmenu.description = <p>The <b>&lt;ace:breadcrumbMenu&gt;</b> component is a horizontal bar of breadcrumb menu items. The crumbs are encoded by child menuItem tags. The menu items can be encoded inline or dynamically using a menu model.</p>

### ACE - CheckBoxButton
menu.ace.checkboxButton.title = ace:checkboxButton
menu.ace.checkboxButton.subMenu.title = Examples
menu.ace.checkboxButton.subMenu.main = Overview
menu.ace.checkboxButton.subMenu.custom = Custom Style
# Overview
example.ace.checkboxButton.title = ace:checkboxButton - Overview
example.ace.checkboxButton.description = <p>The <b>&lt;ace:checkboxButton&gt;</b> component is a simple UI button control for toggling boolean input values (ie. Select / De-Select). Click on the box below to toggle button select / deselect functionality. In this particular demo, server based application code reflects button state back to the user through the text located below the button.</p>
# Custom
example.ace.checkboxButton.custom.title = ace:checkboxButton - Custom Style
example.ace.checkboxButton.custom.description = <p>Below is an example of a  <b>&lt;ace:checkboxButton&gt;</b> component styling itself using custom state images.</p>

### ACE - ComboBox
menu.ace.combobox.title = ace:comboBox
menu.ace.combobox.subMenu.main = Overview
menu.ace.combobox.subMenu.title = Example
menu.ace.combobox.subMenu.facet = Facet Rendering
menu.ace.combobox.subMenu.filtering = Filtering
menu.ace.combobox.subMenu.label = Label Position
menu.ace.combobox.subMenu.indicator = Indicator Text
menu.ace.combobox.subMenu.reqStyle = Required Styling
# Overview
example.ace.combobox.title = ace:comboBox - Overview
example.ace.combobox.description = <p>The <b>&lt;ace:comboBox&gt;</b> component allows users to select a value from a number of given options, while also allowing them to enter a custom value in the text field. It provides client-side autocomplete functionality as the user types to suggest possible options.
example.ace.combobox.facet.title = ace:comboBox - Facet Rendering
example.ace.combobox.facet.description = <p>The <b>&lt;ace:comboBox&gt;</b> component allows developers to render custom entries by using nested components.
example.ace.combobox.filtering.title = ace:comboBox - Filtering
example.ace.combobox.filtering.description = <p>The <b>&lt;ace:comboBox&gt;</b> component also supports client-side filtering.
# Label Position
example.ace.combobox.label.title = ace:comboBox - Label Position
example.ace.combobox.label.description = <p>This example shows how to render, customize, and position an inline label for the comboBox component.</p>
# Indicator Text
example.ace.combobox.indicator.title = ace:comboBox - Indicator Text
example.ace.combobox.indicator.description = <p>This example shows how to customize the text of the required and optional indicator message.</p>
# Required Styling
example.ace.combobox.reqStyle.title = ace:comboBox - Required Styling
example.ace.combobox.reqStyle.description = <p>This example shows how the comboBox field can be customized to better indicate required or optional status beyond a simple message.</p>

### ACE - Confirm Dialog
menu.ace.confirmationdialog.title = ace:confirmationDialog
menu.ace.confirmationdialog.subMenu.title = Examples
menu.ace.confirmationdialog.subMenu.main = Overview
menu.ace.confirmationdialog.subMenu.modal = Modal
menu.ace.confirmationdialog.subMenu.effect = Effect
# Overview
example.ace.confirmationdialog.title = ace:confirmationDialog - Overview
example.ace.confirmationdialog.description = <p>The <b>&lt;ace:confirmationDialog&gt;</b> component generates a popup dialog window with confirmation input. Client side APIs, show() and hide() functions, can be used to display and close the dialog. These functions can be called from other components, such as the commandButton, commandLink, menuitem etc. A number of attributes are available to the developer to allow them to change message, actions, dimensions etc. To demonstrate the component click on the Save button below.</p>
# Modal
example.ace.confirmationdialog.modal.title = ace:confirmationDialog - Modal Confirmation Example
example.ace.confirmationdialog.modal.description = <p>If the modal attribute of the <b>&lt;ace:confirmationDialog&gt;</b> component is set to true, other items on the page will be disabled (i.e. cannot be interacted with). Modality creates an overlay below the dialog but above other page elements. Click on the Display dialog button below and notice other page buttons are disabled until the dialog is responded to. Click either the yes or no button on the box to exit.</p>
# Effect
example.ace.confirmationdialog.effect.title = ace:confirmationDialog - Display Effects Example
example.ace.confirmationdialog.effect.description = <p>The  confirmationDialog component supports a number of different effects to draw attention to the popup, as seen in the demo below.  . Select the desired effect for the show and hide events from the pull down menus below and click the display dialog button.  Close the dialog window to view the animation on close.  Possible options are: <i>blind bounce, clip, drop, explode, fade, fold, highlight, puff, pulsate, scale, shake, size, slide and transfer.</i></p>

### ACE - Context Menu
menu.ace.contextMenu.title = ace:contextMenu
menu.ace.contextMenu.subMenu.title = Examples
menu.ace.contextMenu.subMenu.main = Overview
menu.ace.contextMenu.subMenu.global = Global
menu.ace.contextMenu.subMenu.component = Per Component
menu.ace.contextMenu.subMenu.table = Table Integration
menu.ace.contextMenu.subMenu.effect = Effect
menu.ace.contextMenu.subMenu.multicolumn = Multi Column
# Overview
example.ace.contextMenu.title = ace:contextMenu - Overview
example.ace.contextMenu.description = <p>The <b>&lt;ace:contextMenu&gt;</b> component provides a robust popup menu system that is accessed when a designated page region is right clicked. The example below demonstrates the context menu as applied on an application wide basis. Right-click anywhere on this page to display the global menu.  Use the mouse left click to exit or select a menu entry.</p>
# Component
example.ace.contextMenu.component.title = ace:contextMenu - Per Component Context Menu Example
example.ace.contextMenu.component.description = <p>The <b>&lt;ace:contextMenu&gt;</b> component can also be used to display different menu options depending on the page region or component the mouse is on when being right clicked.  To demonstrate right click on the first sentence in the demo below and then again when the mouse is over the Submit Button.  Notice that a different popup menu is provided depending on the context or position of the mouse at the time of right click.</p>
# In Table
example.ace.contextMenu.table.title = ace:contextMenu - Table Integration Example
example.ace.contextMenu.table.description = <p>The <b>&lt;ace:contextMenu&gt;</b> component also provides context menu functionality within a data table. Right-click on the data table below to optionally add or undo addition of the items in the list.</p>
# Effect
example.ace.contextMenu.effect.title = ace:contextMenu - Display Effects Example
example.ace.contextMenu.effect.description = <p>Transition effects can be applied to the <b>&lt;ace:contextMenu&gt;</b> component. Select the desired transition effect and right-click on the image to display a context menu using the specified effect.</p>
# Multi-Column Submenu
example.ace.contextMenu.multicolumn.title = ace:contextMenu -  ace:contextMenu - Multi-Column Submenu Example
example.ace.contextMenu.multicolumn.description = <p>The <b>&lt;ace:contextMenu&gt;</b> supports submenus with multiple columns, instead of just one.</p>

### ACE - Data Exporter
menu.ace.dataExporter.title = ace:dataExporter
menu.ace.dataExporter.subMenu.title = Examples
menu.ace.dataExporter.subMenu.main = Overview
menu.ace.dataExporter.subMenu.columns = Specify Columns
menu.ace.dataExporter.subMenu.rows = Specify Rows
menu.ace.dataExporter.subMenu.excludeFromExport = Specify Data
menu.ace.dataExporter.subMenu.custom = Custom Exporter
# Overview
example.ace.dataExporter.title = ace:dataExporter - Overview
example.ace.dataExporter.description = <p>The <b>&lt;ace:dataExporter&gt;</b>  component is used to export data table content into CSV, XLS, PDF and XML formats.  Select the desired export format and click the Export File button below.  The table will be exported into your computers default download location in the target format.</p>
# Columns
example.ace.dataExporter.columns.title = ace:dataExporter - Specify Columns Example
example.ace.dataExporter.columns.description = <p>The <b>&lt;ace:dataExporter&gt;</b> can be configured to export only specified data columns.  Select the targeted data columns from the option list below and click Export File.  View the file from your default download location and confirm that only the select columns were exported. </p>
#Rows
example.ace.dataExporter.rows.title = ace:dataExporter - Specify Rows Example
example.ace.dataExporter.rows.description = <p>The <b>&lt;ace:dataExporter&gt;</b> can be configured to export only specified rows from data table. Select rows by clicking on them from the table below and click Export File.  View the file from your default download location and confirm that only selected rows were exported. </p>
#Exclude From Export
example.ace.dataExporter.excludeFromExport.title = ace:dataExporter - Specify Data Example
example.ace.dataExporter.excludeFromExport.description = <p>Addition of the <b>&lt;ace:excludeFromExport&gt;</b> tag can be used in order to prevent certain data to be exported in the file. In the example below select select the type of file and click Export button. View the file from your default download location and confirm that only name, weight, MPG and cost data has been imported from the table.</p>
#Custom
example.ace.dataExporter.custom.title = ace:dataExporter - Custom Exporter Example
example.ace.dataExporter.custom.description = <p>The <b>&lt;ace:dataExporter&gt;</b> can be configured to use a custom type of exporting. This allows developers to present the data in any format required by the end users of the application or to add custom additions to the built-in export types. This example illustrates how to extend the built-in CSV exporter type to export inner tables that are included inside an &lt;ace:panelExpansion&gt; component. This example allows the user to select from a list which inner tables to include. These custom exporters are already included in ICEfaces, under the ACE data exporter folder.</p>

### ACE - Data Table
menu.ace.dataTable.title = ace:dataTable
menu.ace.dataTable.subMenu.title = Examples
menu.ace.dataTable.subMenu.main = Overview
menu.ace.dataTable.subMenu.filtering = Filtering
menu.ace.dataTable.subMenu.sorting = Sorting
menu.ace.dataTable.subMenu.paginator = Paginator
menu.ace.dataTable.subMenu.scrolling = Scrolling
menu.ace.dataTable.subMenu.lazyLoading = Lazy Loading
menu.ace.dataTable.subMenu.selector = Row Selector
menu.ace.dataTable.subMenu.listener = Row Listener
menu.ace.dataTable.subMenu.rowexpansion = Row Expansion
menu.ace.dataTable.subMenu.panelexpansion = Panel Expansion
menu.ace.dataTable.subMenu.configpanel = Table Configuration
menu.ace.dataTable.subMenu.rowstate = Row State
menu.ace.dataTable.subMenu.stackable = Column Stacking
menu.ace.dataTable.subMenu.columnReordering = Column Reorder
menu.ace.dataTable.subMenu.columnResizing = Column Resizing
menu.ace.dataTable.subMenu.dynamicColumns = Dynamic Columns
menu.ace.dataTable.subMenu.rowEditing = Row/Cell Editing
menu.ace.dataTable.subMenu.find = Find
menu.ace.dataTable.subMenu.grouping = Grouping
menu.ace.dataTable.subMenu.multiRowHeader = Multi Row Header
menu.ace.dataTable.subMenu.pinning = Pin Columns

# Overview
example.ace.dataTable.title = ace:dataTable - Overview
example.ace.dataTable.description = <p>The <b>&lt;ace\:dataTable&gt;</b>  is a rich data table component and arguably one of the most comprehensive and versatile components available in the industry. A large set of features is supported by this tag including sorting, scrolling, pagination, data filtering, lazy loading, column stacking etc. The demo example below represents a superset of some more common features.  To view filtering functionality enter a sample of text or characters in the open text boxes at the top of each column (i.e. enter \u201C11\u201D in the text box in the MPG column.  The filtered data rows will appear.  Delete the entry to return to the original table.  View pagination capability by clicking on the page numbers at the bottom of the table. </p>
# Column Reordering
example.ace.dataTable.columnReordering.title = ace:dataTable - Column Reordering Example
example.ace.dataTable.columnReordering.description = <p>The <b>&lt;ace:dataTable&gt;</b> supports re-ordering of columns through drag and drop if the columnOrdering attribute of the <ace:dataTable> is set to true. Column re-ordering can be turned on or off on a column by column basis.  In the example below click and hold the Cost column header cell with the left mouse button.  Drag the mouse / column to the left side of the table and release.</p>
# Column Resizing
example.ace.dataTable.columnResizing.title = ace:dataTable - Column Resizing Example
example.ace.dataTable.columnResizing.description = <p>The <b>&lt;ace:dataTable&gt;</b> supports resizing of columns if resizableColumns attribute of the dataTable is set to true. In the example below click and hold one of the column header borders with the left mouse button. Drag the mouse to the left or right side of the table and release.</p>
# Column Stacking
example.ace.dataTable.stackable.title = ace:dataTable - Column Stacking Example
example.ace.dataTable.stackable.description = <p>The <b>&lt;ace\:dataTable&gt;</b> component also allows developers to implement the \u201Cstacking\u201D  of multiple columns in order to facilitate alternative viewing options when space is at a premium. The sample below illustrates a 7 column data table rendered in 4 columns.</p>
# Dynamic Columns
example.ace.dataTable.dynamicColumns.title = ace:dataTable - Dynamic Columns Example
example.ace.dataTable.dynamicColumns.description = <p>The <b>&lt;ace:dataTable&gt;</b> supports dynamic columns by using the <b>&lt;c:forEach&gt;</b> technique for defining dynamic columns through a column model. In the example below check / uncheck the column name checkboxes to dynamically add / remove columns.</p>
# Filtering
example.ace.dataTable.filtering.title = ace:dataTable - Filtering Example
example.ace.dataTable.filtering.description = <p>The <b>&lt;ace\:dataTable&gt;</b> supports both column and multi-column filtering capabilities.  To view the demo, enter the character combination you wish to filter for by column in the blank field under the column header information. For example enter \u201C2\u201D in the Weight column field to view all cars with a \u201C2\u201D in their weight.  Next enter a \u201CM\u201D in the Chassis column to further refine the search</p>
#Lazy Loading
example.ace.dataTable.lazyLoading.title = ace:dataTable - Ultra-large Table Support
example.ace.dataTable.lazyLoading.description = <p>The <b>&lt;ace:dataTable&gt;</b> contains lazy loading algorithms to enable viewing and loading of very large data tables in quick and responsive manner. This table example below loads over 3,000,000+ records of random cars, displaying 31 rows of data per page across 2,000+ pages. Use the Data Table paginator option to move between pages, noting how quickly each page is loaded and rendered.</p>
#Multi Row Header
example.ace.dataTable.multiRowHeader.title = ace:dataTable - Multi Row Header
example.ace.dataTable.multiRowHeader.description = <p>The <b>&lt;ace\:dataTable&gt;</b> component allows developers to implement the \u201Cstacking\u201D  of multiple row headers in order to group related columns into different sections. The sample below illustrates a 6 column data table which headers are combined into logical groups for easy viewing .</p>
# Paginator
example.ace.dataTable.paginator.title = ace:dataTable - Paginator Example
example.ace.dataTable.paginator.description = <p>The <b>&lt;ace:dataTable&gt;</b> allows developers to implement table navigational controls and embedded them at the bottom or top of the data table.  This allows users to view specific data table pages, to increment / decrement page views or to skip to first / last pages. Use the control inputs located above the table to modify data table formatting options, then click through the data table using the navigational controls provided.</p>
# Panel Expansion
example.ace.dataTable.panelexpansion.title = ace:dataTable - Panel Expansion Example
example.ace.dataTable.panelexpansion.description = <p>The <b>&lt;ace:dataTable&gt;</b> supports a panel expansion feature which allows developers to embed a panel that can contain any kind of arbitrary information, immediately below a data table row.  The panel can be exposed / hidden by clicking on an icon embedded in the table.  Click on the arrows in the leftmost column to expand and collapse inserted panel views for this demo.</p>
# Row Expansion
example.ace.dataTable.rowexpansion.title = ace:dataTable - Row Expansion Example
example.ace.dataTable.rowexpansion.description = <p>The <b>&lt;ace:dataTable&gt;</b> allows developers to group two or more rows within a table together and expand / collapse them based on the user clicking an icon embedded in the table.  Note that the expanded rows must follow the original data table structure.  Click on the row expansion arrows to the left side of the table to expand / collapse table row entries.</p>
# Listener
example.ace.dataTable.listener.title = ace:dataTable - Row Listener Example
example.ace.dataTable.listener.description = <p>The <b>&lt;ace:dataTable&gt;</b> allows for the addition of server side listeners to the data table which will signal the application when rows or cells have been selected or deselected. In this example, listeners have been added at the row level.  Click on one of the table rows, and view the event log feedback below (from the server), which indicates which rows have been and are currently selected.</p>
# Selector
example.ace.dataTable.selector.title = ace:dataTable - Row Selector Example
example.ace.dataTable.selector.description = <p>The <b>&lt;ace:dataTable&gt;</b> provides functionality that allows users to select one or multiple rows  or cells within a data table. The selected row(s) or cell(s) can be identified through format changes to the selection and the selection details can be passed to the application resident on the server for additional processing.  In the demo below, select the desired selection behavior attributes and select the appropriate row(s) / cell(s).  The selection status as identified by the application is updated in the text below the table.</p>
# Row State
example.ace.dataTable.rowstate.title = ace:dataTable - Row State Example
example.ace.dataTable.rowstate.description = <p>The row state example demonstrates some of the enhanced control functions associated with row selection, visibility and cell / row editability. Click on the desired Selection, Visibility, and Editability attributes, then click on the desired cell / row in the table. To demonstrate in-cell editing, select Enable Editing for All, select the desired row of the cell you wish to edit, then click the pencil icon associated with the row you wish to edit.  The data table entries will become editable in place.  Once finished, click the checkmark to confirm and update or the \u201Cx\u201D  under the Edit row to reject the changes.</p>
# Scrolling
example.ace.dataTable.scrolling.title = ace:dataTable - Scrolling Example
example.ace.dataTable.scrolling.description = <p>The <b>&lt;ace:dataTable&gt;</b> support scrolling features via mouse scroll wheel, multi-touch or through dragging of scroll bars located on the side of the table.  In the example below the user can Enable or Disable scrolling through selecting the checkbox button and can control the table height in pixels through the data input box.</p>
# Sorting
example.ace.dataTable.sorting.title = ace:dataTable - Sorting Example
example.ace.dataTable.sorting.description = <p>The <b>&lt;ace\:dataTable&gt;</b> supports both single and multi-row sorting options.  Click on the up and down arrows embedded in the column headers below to view the sort function in ascending or descending orders.  To add in additional columns for sorting press the control or command key on your keyboard while simultaneously clicking on the up / down arrow key of the addition column sorting parameter.  For example first click the up arrow of the chassis column to view the chassis types in alphabetical order (Bus to Van).  Then click the down arrow of the weight column while holding down the command / control key.  You should see that the \u201CBus\u201D entries at the top of the table are now re-ordered by descending weight options.</p>
# Table Config
example.ace.dataTable.configpanel.title = ace:dataTable - Configuration Example 
example.ace.dataTable.configpanel.description = <p>Features and functions such as column renaming, sortability, column ordering and sizing etc. can be dynamically specified through an ace\:dataTable configuration panel.  In this example, click on the \u201Cgear\u201D icon in the header of the rightmost column to access the configuration panel. Change the column names, visibility, ordering parameters etc. to the desired states.  Click on the \u201Carrow\u201D in the configuration panel header to save the new settings or the \u201Cx\u201D to ignore and return to prior settings.  View the updates in the table below.</p>
# Row Editing
example.ace.dataTable.rowEditing.title = ace:dataTable - Row / Cell Editing Example
example.ace.dataTable.rowEditing.description = <p>The <b>&lt;ace\:dataTable&gt;</b> supports both row and cell editing.  In the demo below, select the pencil icon in the Options column for the row you wish to edit.  Once clicked, notice the cell components of the selected row become editable.  Make desired changes and select the checkmark to save and refresh the row, or the \u201Cx\u201D to reject and revert the row back to the original settings.</p>
# Find
example.ace.dataTable.find.title = ace:dataTable - Table Search Example
example.ace.dataTable.find.description = <p>Find a row in the table and highlight it.</p>
# Grouping
example.ace.dataTable.grouping.title = ace:dataTable - Column Grouping Example
example.ace.dataTable.grouping.description = <p>Rowspan equal values in columns. Conditional row used to summarize chassis groups.</p>
# Pinning
example.ace.dataTable.pinning.title = ace:dataTable - Column Pinning Example
example.ace.dataTable.pinning.description = <p>Statically position particular columns alongside scrollable table in a particular order.</p>


### ACE - Date Time Entry
menu.ace.dateentry.title = ace:dateTimeEntry
menu.ace.dateentry.subMenu.title = Examples
menu.ace.dateentry.subMenu.main = Overview
menu.ace.dateentry.subMenu.popup = Popup
menu.ace.dateentry.subMenu.timeentry = Time Entry
menu.ace.dateentry.subMenu.ajax = Ajax Submit
menu.ace.dateentry.subMenu.pages = Multiple Months
menu.ace.dateentry.subMenu.minmax = Restrict Min/Max
menu.ace.dateentry.subMenu.navigator = Navigator
menu.ace.dateentry.subMenu.label = Label Position
menu.ace.dateentry.subMenu.indicator = Indicator Text
menu.ace.dateentry.subMenu.reqStyle = Required Styling
# Overview
example.ace.dateentry.title = ace:dateTimeEntry - Overview
example.ace.dateentry.description = <p> The <b>&lt;ace\:dateTimeEntry&gt;</b> component is a calendar component used to capture date entry.  It supports features such as paging, localization etc. and can operate client based or from the server.  The sample below demonstrates server side operation.  Click on a desired date and press the \u201CSubmit Date\u201D button at the bottom of the calendar.  The application will process the date submission and mirror it back in the text line at the top of the calendar.</p>
# Popup
example.ace.dateentry.popup.title = ace:dateTimeEntry - Popup Example
example.ace.dateentry.popup.description = <p>The <b>&lt;ace\:dateTimeEntry&gt;</b> component supports both popup or input text operations. In the example below, check the \u201CDisplay as Popup\u201D checkbox and click the calendar icon to view a calendar popup.  Select a date from the calendar popup and click the Submit Date button to view the processed date submission in the text field below.  With the Display as Popup deselected, the calendar will remain permanently visible.</p>
# Time Entry
example.ace.dateentry.timeentry.title = ace:dateTimeEntry - Time Entry Example
example.ace.dateentry.timeentry.description = <p>The <b>&lt;ace:dateTimeEntry&gt;</b> component supports entering time as well as the date.</p>
# Ajax Submit
example.ace.dateentry.ajax.title =  ace:dateTimeEntry - AJAX Submit Example
example.ace.dateentry.ajax.description = <p>The <b>&lt;ace:dateTimeEntry&gt;</b> component can operate client side using localized Ajax controls.  Ajax processing is enabled in the example below.  To view click on the text entry panel below to trigger the calendar popup.  Select a date and notice that the selected date field below is processed and updated immediately upon date selection without submitting the selection to the server.</p>
# Multiple Months
example.ace.dateentry.pages.title = ace:dateTimeEntry - Multiple Months Example
example.ace.dateentry.pages.description = <p>The <b>&lt;ace:dateTimeEntry&gt;</b> component supports display of multiple months in a single calendar.  In the example below, toggle through months by selecting the right / left arrow elements in the calendar header.  Notice selected dates are immediately updated upon date selection in the text field below.  Using the pull down menu at the bottom of the calendar you can select multiple calendar months to be displayed and selectable at any one time.</p>
# Restrict Min/Max
example.ace.dateentry.minmax.title = ace:dateTimeEntry - Restrict Min/Max
example.ace.dateentry.minmax.description = <p>The <b>&lt;ace:dateTimeEntry&gt;</b> component supports restricting the minimum and maximum date and time values that can be entered. By default the date range can be from one year ago or five years in the future. Notice how invalid dates are not selectable by the user.</p>
# Navigator
example.ace.dateentry.navigator.title =  ace:dateTimeEntry - Dropdown Navigator Example
example.ace.dateentry.navigator.description = <p>The example below demonstrates how the <b>&lt;ace\:dateTimeEntry&gt;</b> component can be configured for optional navigation through drop down month / year menus.  To run the demo, ensure the \u201CEnable Dropdown Navigation \u201C box is selected.  Click on the month pull down menu to select desired month entry and repeat with desired year selection.  Click on selected date and notice the update to the Selected Date in the text box below.</p>
# Label Position
example.ace.dateentry.label.title =  ace:dateTimeEntry - Label Position
example.ace.dateentry.label.description = <p>The example below demonstrates how the <b>&lt;ace:dateTimeEntry&gt;</b> component can have an associated inline label which can have custom text and a custom position.</p>
# Indicator Text
example.ace.dateentry.indicator.title =  ace:dateTimeEntry - Indicator Text
example.ace.dateentry.indicator.description = <p>The example below demonstrates how the <b>&lt;ace:dateTimeEntry&gt;</b> component can have custom text indicating that the field is required or optional.</p>
# Required Styling
example.ace.dateentry.reqStyle.title =  ace:dateTimeEntry - Required Styling
example.ace.dateentry.reqStyle.description = <p>The example below demonstrates how the <b>&lt;ace:dateTimeEntry&gt;</b> component can be uniquely styled to demonstrate to the user that the field is required.</p>

### ACE - Dialog
menu.ace.dialog.title = ace:dialog
menu.ace.dialog.subMenu.main = Overview
menu.ace.dialog.subMenu.effectsAndSize = Effects & Size
menu.ace.dialog.subMenu.modalDialog = Modal & Movable
# Overview
example.ace.dialog.title = ace:dialog - Overview
example.ace.dialog.description = <p>The <b>&lt;ace\:dialog&gt;</b> component allows developers to deploy a floating window constructed of a customizable title bar and a content region.  The component can be moved across the page using drag and drop, can be resized and will introduce scollbars automatically should content exceed available space.  It supports a number of display options including semi-transparent overlay, open / close effects etc.  In the sample below click the \u201CShow Dialog\u201D button to open the dialog window.  Click and hold down the left mouse button over the bottom right corner to experiment with resizing the dialog box. Enter desired text in the two available fields and select the click me button when complete.  The entered text is mirrored back by the application in the text entry field below.</p>
# Size & Effects
example.ace.dialog.dialogEffectAndSize.title =  ace:dialog - Animation and Size Configuration Example
example.ace.dialog.dialogEffectAndSize.description = <p>The dialog box supports minimum width / height definitions as well as a variety of animation effects that are triggered on open and close operations.  Use the pull down menus below to set desired dialog box dimensions and show / hide animations.  Click on the Show Dialog button once completed to view the results. Resizing of the dialog box is achieved by clicking and holding the left mouse button over the bottom right corner of the box.  Notice that resizing is bound by minimum width / height constraints previously established.  Box is closed by selecting the \u201Cx\u201D in header bar.</p>
# Modal Dialog
example.ace.dialog.modalDialog.title =  ace:dialog - Modal and Movable Example
example.ace.dialog.modalDialog.description = <p>The <b>&lt;ace:dialog&gt;</b> component supports both modal operation and drag and drop operation.  The modal option will create an overlay below the dialog box and above the other page elements. Select the desired option in the customization panel below.  Click on the Show Dialog button to view the dialog component.  Click and hold the left mouse button down over the dialog component header bar and drag the component to the desire position.  Drop the component into place by releasing the left mouse button.</p>

### ACE - Drag and Drop
menu.ace.dragDrop.title = ace:draggable/droppable
menu.ace.dragDrop.subMenu.main = Overview
menu.ace.dragDrop.subMenu.draggable = Draggable
menu.ace.dragDrop.subMenu.dataTableIntegration = Table Integration
# Overview
example.ace.dragDrop.title = ace:draggable/droppable - Overview
example.ace.dragDrop.description = <p>The ace library supports drag and drop operation through its <b>&lt;ace:draggable&gt;</b> and <b>&lt;ace:droppable&gt;</b> components. When embedded within other components (i.e. panels, menus etc.) the components will become draggable and droppable.  Both elements support a wide range of features that allow developers to constrain drag behaviors and drop regions as well as controlling appearance etc.  In the demo below select and hold the images of objects in the list on the left with the left mouse button.  Drag them over an available box on the right.  Note that this particular example demonstrates a restriction on the drop region in that only certain elements can be dropped in certain regions (i.e. electronic elements can only be dropped into electronic labeled boxes). Also note that in this example the object must be 100% inside the box before dropping is allowed.</p>
# Draggable 
example.ace.draggable.title = ace:draggable - Configuration Example
example.ace.draggable.description = <p>The <b>&lt;ace:draggable&gt;</b> component supports a number of features that control the drag operation.  These include restricting the direction of drag (vertical / horizontal / any), containing drag within a certain page region, dragging by predetermined grid steps, having the drag object remain opaque or translucent etc.  In the example below select the desired drag characteristics using the pull down menus below.  Left click and hold on the image and drag the element to its new position.  Release the mouse button to drop.  Note that certain option settings may restrict how the image moves and where it can be dropped.</p>
# Data Table Integration
example.ace.dataTableIntegration.title = ace:draggable/droppable - Data Table Integration Example
example.ace.dataTableIntegration.description = <p>The ace drag and drop features are supported within data tables.  In the example below select one of the picture elements from the top table. Drag it and drop it onto the Shopping Cart Table below.  Notice the Shopping Cart Table is updated with new content on the drop action.</p>

### ACE - FileEntry
menu.ace.fileentry.title = ace:fileEntry
menu.ace.fileentry.subMenu.title = Examples
menu.ace.fileentry.subMenu.main = Overview
menu.ace.fileentry.subMenu.listener = Listener
menu.ace.fileentry.subMenu.validation = Validation
menu.ace.fileentry.subMenu.multiple = Multiple
menu.ace.fileentry.subMenu.failpop = Failed Popup
menu.ace.fileentry.subMenu.callback = Callback
# Overview
example.ace.fileentry.title = ace:fileEntry - Overview
example.ace.fileentry.description = <p>The <b>&lt;ace\:fileEntry&gt;</b> component allows users to select a file from a local machine or network, and submit that file for upload to a specified location. The component supports limitations on location selection, file size and provides file validation functionality to the application.  In the example below select the \u201CChoose File\u201D button.  A selection window will open allowing you to navigate your local machine to select a file. Once selected the file name will be mirrored onto the page for confirmation. Click \u201CSend File\u201D to temporarily upload the file to the ICEsoft server (limited to 6 MB per file and 18 MB for all uploaded files).</p>
# Basic
example.ace.fileentry.listener.title = ace:fileEntry - File Upload Listener Example 
example.ace.fileentry.listener.description = <p>The following example demonstrates a custom listener for the <b>&lt;ace:fileEntry&gt;</b> component, which only allow <b>pdf</b> file uploads.  Select the Choose File button below, select a target file for upload and press the Send File button to upload the target file into a sub-directory within the root application directory on the ICEsoft servers. Notice a warning message every time you are trying to upload a non PDF file </p>
# Callback
example.ace.fileentry.callback.title = ace:fileEntry - File Upload Callback Example 
example.ace.fileentry.callback.description = <p>The following example demonstrates a custom callback for the <b>&lt;ace:fileEntry&gt;</b> component, which custom fails on <b>pdf</b> file uploads.  Select the Choose File button below, select a target file for upload and press the Send File button to upload the target file into a sub-directory within the root application directory on the ICEsoft servers. Notice an error message when you try to upload a PDF file </p>
example.ace.fileentry.callback.error = PDF files cannot be uploaded. Upload cancelled for :
example.ace.fileentry.callback.success = Upload successful for : 
# Validation Options
example.ace.fileentry.valid.title = ace:fileEntry - Validation Example 
example.ace.fileentry.valid.description = <p>The <b>&lt;ace:fileEntry&gt;</b> component supports a number of attributes that developers can set to regulate and assess the validity of the file to be uploaded.  Restrictions can be placed as to file size, file type etc. as well feedback messages can be set for the user in the event of validation failure.  In the example below, set size restriction for the file to be uploaded by using the slider below. Choose a file to be uploaded that complies with the validation settings and press Send File to upload the file.  Repeat with a file that violates the settings and view the customized response.</p>

# Multiple File Upload Options (inactive)
example.ace.fileentry.multiple.title = ace:fileEntry - Multiple Upload Example 
example.ace.fileentry.multiple.description = <p>The file entry example below demonstrates attributes related to functionality of the component that has not yet been completed, though they are documented in the TLD.</p>
# Fail Popup (inactive)
example.ace.fileentry.failpop.title = ace:fileEntry - Popup Validation Example
example.ace.fileentry.failpop.description = <p>The file entry example below demonstrates a compound example of functionality whose completion that is waiting on a showcase wide popup component.</p>

### ACE - LinkButton
menu.ace.linkButton.title = ace:linkButton
menu.ace.linkButton.subMenu.title = Examples
menu.ace.linkButton.subMenu.main = Overview
# Overview
example.ace.linkButton.title = ace:linkButton - Overview
example.ace.linkButton.description = <p>The <b>&lt;ace\:linkButton&gt;</b> is a navigational component used for executing application listeners, performing action navigation and form submission. The demo below demonstrates active and static navigation to both relative and absolute URL\u2019s.  Click the links to view a page jump to the designated URL\u2019s. </p>

### ACE - Masked Entry
menu.ace.maskedEntry.title = ace:maskedEntry
menu.ace.maskedEntry.subMenu.main = Overview
menu.ace.maskedEntry.subMenu.label = Label Position
menu.ace.maskedEntry.subMenu.indicator = Indicator Text
menu.ace.maskedEntry.subMenu.reqStyle = Required Styling
# Overview
example.ace.maskedEntry.title = ace:maskedEntry - Overview
example.ace.maskedEntry.description = <p>The <b>&lt;ace:maskedEntry&gt;</b> component  is a text input element that allows developers to restrict text input fields to be formatted in a particular manner.  Masking allows the developers to specify the number and type of characters (alphabetical / numeric / optional etc.).  The example below illustrates various masking options around numerical inputs.  Click in the text entry boxes below to enter date of birth, work phone number etc.  Notice the specific formatting requirements of the box (i.e. number of characters) etc.  Tab through to the next entry box and view the text updates in the Entered Data Frame below.</p>
# Label Position
example.ace.maskedLabel.title = ace:maskedEntry - Label Position
example.ace.maskedLabel.description = <p>The example below demonstrates how the <b>&lt;ace:maskedEntry&gt;</b> component can have an associated inline label which can have custom text and a custom position.
# Indicator Text
example.ace.maskedIndicator.title = ace:maskedEntry - Indicator Text
example.ace.maskedIndicator.description = <p>The example below demonstrates how the <b>&lt;ace:maskedEntry&gt;</b> component can have custom text indicating that the field is required or optional.</p>
# Required Styling
example.ace.maskedReqStyle.title = ace:maskedEntry - Required Styling
example.ace.maskedReqStyle.description = <p>The example below demonstrates how the <b>&lt;ace:maskedEntry&gt;</b> component can be uniquely styled to demonstrate to the user that the field is required.</p>

### ACE - Text Entry
menu.ace.textEntry.title = ace:textEntry
menu.ace.textEntry.subMenu.main = Overview
menu.ace.textEntry.subMenu.autotab = Auto Tab
menu.ace.textEntry.subMenu.label = Label Position
menu.ace.textEntry.subMenu.indicator = Indicator Text
menu.ace.textEntry.subMenu.reqStyle = Required Styling
# Overview
example.ace.textEntry.title = ace:textEntry - Overview
example.ace.textEntry.description = <p>The <b>&lt;ace:textEntry&gt;</b> component is a text input component with &lt;ace:ajax&gt; support. Users can optionally specify a label and/or a required/optional indicator and place them in various positions in and around the input field. The input field, label, indicator, as well as the input field validation error state, can all be styled separately using predefined style class names in the theme stylesheet. The auto tab feature will automatically tab out of the input field when the maxlength (if specified) is reached.</p>
# Auto Tab
example.ace.textEntry.autotab.title = ace:textEntry - Auto Tab
example.ace.textEntry.autotab.description = <p>The <b>&lt;ace:textEntry&gt;</b> component supports "auto tab" functionality where the next field will be focused when the current field has a set number of characters entered into it. This is extremely useful for quick data entry in inventory and point-of-sales systems.</p>
# Label Position
example.ace.textEntry.label.title = ace:textEntry - Label Position
example.ace.textEntry.label.description = <p>This example shows to render, customize, and position an inline label for the textEntry component.</p>
# Indicator Text
example.ace.textEntry.indicator.title = ace:textEntry - Indicator Text
example.ace.textEntry.indicator.description = <p>This example shows how to customize the text of the required and optional indicator message.</p>
# Required Styling
example.ace.textEntry.reqStyle.title = ace:textEntry - Required Styling
example.ace.textEntry.reqStyle.description = <p>This example shows how the textEntry field can be customized to better indicate required or optional status beyond a simple message.</p>

### ACE - Message(s)
menu.ace.message.title = ace:message(s)
menu.ace.message.subMenu.main = Overview
# Overview
example.ace.message.title = ace:message(s) - Overview
example.ace.message.description = <p>The <b>&lt;ace:message&gt;</b> component renders the fisrt Faces message for a specific component. The <b>&lt;ace:messages&gt;</b> component renders all Faces messages, all Faces messages for a specific component, or all Faces messages not associated with any component. Messages can be shown with effects initially and/or whey they change. Styling is done by predefined jQuery classes in theme stylesheets:<ul><li>Info: ui-icon-info w/ ui-state-highlight css</li><li>Warn: ui-icon-notice w/ ui-state-highlight css</li><li>Error: ui-icon-alert w/ ui-state-error css</li><li>Fatal: ui-icon-alert w/ ui-state-error css</li></ul>In the following entry form, empty inputs or inputs same as the label will generate sample Faces messages with sample effects.</p>

### ACE - Text Area Entry
menu.ace.textAreaEntry.title = ace:textAreaEntry
menu.ace.textAreaEntry.subMenu.main = Overview
menu.ace.textAreaEntry.subMenu.label = Label Position
menu.ace.textAreaEntry.subMenu.indicator = Indicator Text
menu.ace.textAreaEntry.subMenu.reqStyle = Required Styling
# Overview
example.ace.textAreaEntry.title = ace:textAreaEntry - Overview
example.ace.textAreaEntry.description = <p>The <b>&lt;ace:textAreaEntry&gt;</b> component is a text input component with &lt;ace:ajax&gt; support. Users can optionally specify a label and/or a required/optional indicator and place them in various positions in and around the input field. The input field, label, indicator, as well as the input field validation error state, can all be styled separately using predefined style class names in the theme stylesheet. The ace:textAreaEntry component is also user-resizable.</p>
# Label Position
example.ace.textAreaEntry.label.title = ace:textAreaEntry - Label Position
example.ace.textAreaEntry.label.description = <p>This example shows to render, customize, and position an inline label for the textAreaEntry component.</p>
# Indicator Text
example.ace.textAreaEntry.indicator.title = ace:textAreaEntry - Indicator Text
example.ace.textAreaEntry.indicator.description = <p>This example shows how to customize the text of the required and optional indicator message.</p>
# Required Styling
example.ace.textAreaEntry.reqStyle.title = ace:textAreaEntry - Required Styling
example.ace.textAreaEntry.reqStyle.description = <p>This example shows how the textAreaEntry field can be customized to better indicate required or optional status beyond a simple message.</p>


### ACE - Menu
menu.ace.menu.title = ace:menu
menu.ace.menu.subMenu.title = Examples
menu.ace.menu.subMenu.main = Overview
menu.ace.menu.subMenu.type = Layout
menu.ace.menu.subMenu.events = Events
menu.ace.menu.subMenu.effect = Effects
menu.ace.menu.subMenu.display =  As Popup
menu.ace.menu.subMenu.dynamic = Dynamic
# Overview
example.ace.menu.title = ace:menu - Overview
example.ace.menu.description = <p>The <b>&lt;ace:menu&gt;</b> component is a general purpose vertically oriented navigational aid that supports various animation effects, layout formats and positioning options. The sample below highlights the selected entry on mouse over and if clicked generates a log message in the panel on the right side from menu.</p>
# Type
example.ace.menu.type.title = ace:menu - Layout Example
example.ace.menu.type.description = <p>The <b>&lt;ace\:menu&gt;</b> supports plain, tiered and sliding menu types.  In the example below, select the menu type then view the effects on mouse over and mouse click.  Note the \u201COpen\u201D / \u201CSave\u201D \u2026 entries have no specific action tied to them in this demo.</p>
# Events
example.ace.menu.events.title = ace:menu - Events Example
example.ace.menu.events.description = <p>The <b>&lt;ace:menu&gt;</b> component supports both action listeners and links.  In the example below click on either the Actions or Example menu item and select one of the options.  Notice the actions / listeners fire and update the status in the text field below.  Click on the links and select one of the options to view a sample of the component opening a new window to the selected link</p>
# Effects
example.ace.menu.effect.title = ace:menu - Effects Example
example.ace.menu.effect.description = <p>The <b>&lt;ace:menu&gt;</b> component supports a variety of transitional animations.  The example below highlights two transitions, fade and slide for the exposure of sub menu elements.  Select a desired transition, enter the desired affect duration in the text field and hover the mouse over the menu item to view the effects.</p>
# Display
example.ace.menu.display.title = ace:menu - As Popup Example
example.ace.menu.display.description = <p>The <b>&lt;ace:menu&gt;</b> component supports a popup feature during mouse overs of specific page regions.  To view the menu popup, hover the mouse over the region identified below.  Click outside the menu region to cause the menu to disappear.</p>
# Dynamic (INACTIVE)
example.ace.menu.dynamic.title = ace:menu - Dynamic Example
example.ace.menu.dynamic.description = <p>Dynamic menu description</p>

### ACE - Menu Bar
menu.ace.menuBar.title = ace:menuBar
menu.ace.menuBar.subMenu.title = Examples
menu.ace.menuBar.subMenu.main = Overview
menu.ace.menuBar.subMenu.effect = Effects
menu.ace.menuBar.subMenu.click = Click to Display
menu.ace.menuBar.subMenu.dynamic = Dynamic
menu.ace.menuBar.subMenu.multicolumn = Multi Column
# Overview
example.ace.menuBar.title = ace:menuBar - Overview
example.ace.menuBar.description = <p>The <b>&lt;ace:menuBar&gt;</b> is a general purpose horizontally oriented navigational component that provides customizable menu functions in a menu bar format.  Hover over the menu items below to view the sub-menu elements or click on any item to display your selection in the panel below menu bar. Please note that choosing "Home" will redirect you to the icefaces.org site.</p>
# Effects
example.ace.menuBar.effect.title = ace:menuBar -  Effects Example
example.ace.menuBar.effect.description = <p>The <b>&lt;ace:menuBar&gt;</b> component supports a variety of transitional animations.  The example below highlights two transitions, fade and slide for the exposure of sub menu elements.  Select a desired transition and effect duration below and hover the mouse over the menu item to view the effect.</p>
# Click to Display
example.ace.menuBar.click.title = ace:menuBar - Click to Display Example
example.ace.menuBar.click.description = <p>The <b>&lt;ace:menuBar&gt;</b> supports both auto display and click to display features for uncovering submenu items.  Click the radio button element below to enable or disable auto display mode then click or hover over the menu elements to as required to view the submenu items.</p>
# Dynamic (INACTIVE)
example.ace.menuBar.dynamic.title = ace:menuBar -  ACE Menu Bar Dynamic Example
example.ace.menuBar.dynamic.description = <p>The ability to modify (add / delete) Menu Bar elements dynamically is seen in the example below.</p>
# Multi-Column Submenu
example.ace.menuBar.multicolumn.title = ace:menuBar -  ACE Menu Bar Multi-Column Submenu Example
example.ace.menuBar.multicolumn.description = <p>The <b>&lt;ace:menuBar&gt;</b> supports submenus with multiple columns, instead of just one.</p>

### ACE - Menu Button
menu.ace.menuButton.title = ace:menuButton
menu.ace.menuButton.subMenu.title = Examples
menu.ace.menuButton.subMenu.main = Overview
# Overview
example.ace.menuButton.title = ace:menuButton - Overview
example.ace.menuButton.description = <p>The <b>&lt;ace:menuButton&gt;</b> is a general purpose navigational component that provides customizable menu functions in a button format.  Click on the button to view the sub-menu elements or click on any item to display your selection in the panel below menu bar. Please note that choosing an option with "Home" icon will open a new tab in your browser and redirect you to another page.</p>

### ACE - Notification Panel
menu.ace.notificationpanel.title = ace:notificationPanel
menu.ace.notificationpanel.subMenu.title = Examples
menu.ace.notificationpanel.subMenu.main = Server Side
menu.ace.notificationpanel.subMenu.clientSide = Client Side
# Overview
example.ace.notificationpanel.title = ace:notificationPanel - Server Side
example.ace.notificationpanel.description = <p>The <b>&lt;ace:notificationPanel&gt;</b> is a container component into which any content can be placed.  The panel is typically positioned at either the top or bottom of the page and can shown or hidden based on the application state.  The component supports fade and slide animations on show and hide commands available in slow, normal, and fast transition speeds. The example below demonstrate how notification panel can be used in a server based mode. To view operation click on the Show Using Server button below.</p>
#Client Side
example.ace.notificationpanel.client.title = ace:notificationPanel - Client Side
example.ace.notificationpanel.client.description = <p>The <b>&lt;ace:notificationPanel&gt;</b> is a container component into which any content can be placed.  The panel is typically positioned at either the top or bottom of the page and can shown or hidden based on the application state.  The component supports fade and slide animations on show and hide commands available in slow, normal, and fast transition speeds. The example below demonstrate how notification panel can be used in a client side based mode. In this example "Show/Hide via client" buttons can be used to manipulate notification panel.</p>

### ACE - Panel
menu.ace.panel.title = ace:panel
menu.ace.panel.subMenu.title = Examples
menu.ace.panel.subMenu.main = Overview
menu.ace.panel.subMenu.header = Header&amp;Footer
menu.ace.panel.subMenu.toggle = Toggleable
menu.ace.panel.subMenu.close = Closeable
menu.ace.panel.subMenu.listener = Listener
menu.ace.panel.subMenu.menu = Menu
# Overview 
example.ace.panel.title = ace:panel - Overview
example.ace.panel.description = <p>The <b>&lt;ace\:panel&gt;</b>  component is a generic layout container that supports customizable header / footers, accordion toggling, open and close popup features as well as embedded menu operations.  In the example below, the panel collapse and expansion can be viewed by toggling the \u201CCollapse\u201D button at the bottom of the panel. Likewise the panel can be minimized by pressing the \u201C-\u201C icon in the panel header.  Pressing the gear icon in the panel header illustrates the embedded menu feature of the component.</p>
# Headers
example.ace.panel.header.title = ace:panel - Header and Footer Example
example.ace.panel.header.description = <p>The example below demonstrates the dynamic addition, deletion and modification of panel header and footer text.  Toggle Header and Footer presence on / off through the check box components as well.  Modify the contents of the text box to edit the header and footer title content.</p>
# Toggleable
example.ace.panel.toggle.title = ace:panel - Toggleable Example
example.ace.panel.toggle.description = <p>The example below illustrates how the <b>&lt;ace\:panel&gt;</b> component can be expanded or collapsed by the viewer in an accordion like fashion.  To run the demo, enable or disable the Toggleable feature by clicking on the checkbox below.  Set the speed of the Toggle transition in the text entry box below.  With Toggle enabled, click on the \u201C-\u201C sign on the panel header to close the panel and on the \u201C+\u201D sign on the panel header to re-expand it.</p>
# Closeable
example.ace.panel.close.title = ace:panel - Closeable Example
example.ace.panel.close.description = <p>The example below illustrates the \u201Ccloseable\u201D feature of the <b>&lt;ace\:panel&gt;</b> component.  To activate the feature ensure the Closeable select button is set to on.  Set the close speed option in the text field below.  Once set, click on the \u201Cx\u201D on the right side of the panel header to close the panel.  To reactivate the panel, toggle the \u201CCloseable\u201D select button to off and the closed panel will reappear.</p>
# Listener
example.ace.panel.listener.title = ace:panel - Listener Example
example.ace.panel.listener.description = <p>The example below demonstrates how application listeners can be attached to the component to monitor various toggle events and report the actions back to the application. Click on the \u201C-\u201C icon on the panel header below to minimize the icon and see that the Listener Status text field below is updated by the application with the most panel action.</p>
# Menu
example.ace.panel.menu.title = ace:panel - Menu Example
example.ace.panel.menu.description = <p>The example below illustrates how a menu item can be integrated within the panel header.  Click on the gear icon located at the top right of the panel header to expose the menu options. Note that the menu commands have been intentionally disabled for this demo.  Click outside the menu to have it collapse.</p>

### ACE - Printer
menu.ace.printer.title = ace:printer
menu.ace.printer.subMenu.title = Examples
menu.ace.printer.subMenu.main = Overview
# Overview
example.ace.printer.title = ace:printer - Overview
example.ace.printer.description = <p>The <b>&lt;ace:printer&gt;</b> component component / tag can be used to send specific component on a page to a printer, such as an image or table, without having to print an entire page.  In the case of tables, only visible columns / rows / panels will be printed.  Collapsed rows or columns or panels will not be printed. To view the demo below click on one of the three print options located below.</p>

### ACE - Progress Bar
menu.ace.progressbar.title = ace:progressBar
menu.ace.progressbar.subMenu.title = Examples
menu.ace.progressbar.subMenu.main = Overview
menu.ace.progressbar.subMenu.polling = Polling
menu.ace.progressbar.subMenu.push = Push
menu.ace.progressbar.subMenu.client = Client Side
menu.ace.progressbar.subMenu.clientAndServer = Client&amp;Server
# Overview
example.ace.progressbar.title = ace:progressBar - Overview
example.ace.progressbar.description = <p>The <b>&lt;ace\:progressBar&gt;</b> is a status indicator component capable of working on the client side only or as a server side component using AJAX.  The component supports polling and ICEfaces Push technology.  In the example below click on \u201CPrevious\u201D or \u201CNext\u201D below the image to advance the image carrousel to the right or the left. Notice the progress bar located above the image advances and recedes based on the image number being shown.</p>
# Polling
example.ace.progressBarPoling.title = ace:progressBar - Polling Example
example.ace.progressBarPoling.description = <p>The <b>&lt;ace\:progressBar&gt;</b> supports AJAX polling. The component will \u201Cpoll\u201D the application to ascertain the level of task completion and will update the progress bar to reflect the status result.  The developer can access a number of component options including the frequency of polling, start and cancel poling options and a completeListener which will fire and execute a desire action once the progress reaches completion.  The example below illustrates a progress bar using polling during a simulated image upload.  Select an image to be uploaded from the pull down menu below.  Click the upload button embedded into the rightmost column of the table and view the simple progress bar.  Notice that the Description text changes once the upload is complete.</p>
# Push
example.ace.progressBarPush.title = ace:progressBar - Push Example
example.ace.progressBarPush.description = <p>The <b>&lt;ace:progressBar&gt;</b> can be integrated with ICEfaces Push technology to reflect action status related to events being carried out by another client or thread. In the example below use start, pause (shown after progress start up) and stop buttons to control push updates from server to the progressBar.</p>
# Progress Bar on Client Side
example.ace.progressBarClientSideOnly.title = ace:progressBar - Client Side Example
example.ace.progressBarClientSideOnly.description = <p>The <b>&lt;ace:progressBar&gt;</b> can operate purely as a client side component as demonstrated below.  Click the start button below to initiate client side rendering of the progress bar, and the cancel button to terminate monitoring.</p>
#Progress Bar on Client and Server side
example.ace.progressBarClientAndServer.title =  ace:progressBar - Client&amp;Server Example
example.ace.progressBarClientAndServer.description = <p>The client side progress bar APIs can also be used in conjunction with service side listeners to reflect server based application changes by updating the client side progress bar.  In the example below, click on the Add 10% / Remove 10% buttons located below the progress bar.  The button clicks are passed up to the server application and the cumulative change in state is reflected back down to the progress bar which then updates its status accordingly.</p>

### ACE - PushButton
menu.ace.pushButton.title = ace:pushButton
menu.ace.pushButton.subMenu.title = Examples
menu.ace.pushButton.subMenu.main = Overview
# Overview
example.ace.pushButton.title = ace:pushButton - Overview
example.ace.pushButton.description = <p>The <b>&lt;ace:pushButton&gt;</b> component performs basic button functionality and can be used for executing listeners, action navigation and form submission.</p>

### ACE - Resizable
menu.ace.resizable.title = ace:resizable
menu.ace.resizable.subMenu.main = Overview
menu.ace.resizable.subMenu.resizeListener = Resize Listener
# Overview
example.ace.resizable.title = ace:resizable - Overview
example.ace.resizable.description = <p>The <b>&lt;ace:resizable&gt;</b> component component is an embeddable element that when used in conjunction with other components such as input fields, panels, menus etc. will allow them to be resized.  Options allow the target component to be resized in one or two directions, and to be combined with various animations that will activate upon completion of the resizing.  In the example below, select the small triangle at the bottom of either of the panels below with the left mouse button.  Keeping the button depressed drag the mouse to resize the element.  Release the button when the desired size is reached.  The black panel is set to resize in a manner that preserves its original aspect ratio, while the white panel will resize horizontally and vertically according to preset grid sizes.</p>
# Resizable Listener
example.ace.resizableListener.title = ace:resizable - Listener Example
example.ace.resizableListener.description = <p>A listener can be attached to any resizable component which can be used to process custom server side logic.  In the example below, click and hold the small triangle in the bottom right panel corner.  Holding down the left mouse button, resize the panel.  Listeners monitoring the dimensions will fire on completion of the resize action and will advise the server application of new positioning.  The server calculates the new panel size and reflects the information by updating the text within the panel. Resize the panel below to be at least 255x235(WxH) in order to display an image in addition to the text.</p>

### ACE - RichTextEntry
menu.ace.richtextentry.title = ace:richTextEntry
menu.ace.richtextentry.subMenu.main = Overview
menu.ace.richtextentry.subMenu.title = Example
# Overview
example.ace.richtextentry.title = ace:richtextentry - Overview
example.ace.richtextentry.description = <p>The <b>&lt;ace:richTextEntry&gt;</b> component is an editor that allows users to enter and edit rich text in an application.</p>

### ACE - SelectMenu
menu.ace.selectmenu.title = ace:selectMenu
menu.ace.selectmenu.subMenu.main = Overview
menu.ace.selectmenu.subMenu.facet = Facet Rendering
menu.ace.selectmenu.subMenu.title = Example
menu.ace.selectmenu.subMenu.label = Label Position
menu.ace.selectmenu.subMenu.indicator = Indicator Text
menu.ace.selectmenu.subMenu.reqStyle = Required Styling
# Overview
example.ace.selectmenu.title = ace:selectMenu - Overview
example.ace.selectmenu.description = <p>The <b>&lt;ace:selectMenu&gt;</b> component permits selecting a value from a number of given options.
example.ace.selectmenu.facet.title = ace:selectMenu - Facet Rendering
example.ace.selectmenu.facet.description = <p>The <b>&lt;ace:selectMenu&gt;</b> component allows developers to render custom entries by using nested components.
# Label Position
example.ace.selectmenu.label.title = ace:selectMenu - Label Position
example.ace.selectmenu.label.description = <p>This example shows how to render, customize, and position an inline label for the selectMenu component.</p>
# Indicator Text
example.ace.selectmenu.indicator.title = ace:selectMenu - Indicator Text
example.ace.selectmenu.indicator.description = <p>This example shows how to customize the text of the required and optional indicator message.</p>
# Required Styling
example.ace.selectmenu.reqStyle.title = ace:selectMenu - Required Styling
example.ace.selectmenu.reqStyle.description = <p>This example shows how the selectMenu field can be customized to better indicate required or optional status beyond a simple message.</p>

### ACE - SimpleSelectOneMenu
menu.ace.simpleselectonemenu.title = ace:simpleSelectOneMenu
menu.ace.simpleselectonemenu.subMenu.main = Overview
menu.ace.simpleselectonemenu.subMenu.title = Example
menu.ace.simpleselectonemenu.subMenu.label = Label Position
menu.ace.simpleselectonemenu.subMenu.indicator = Indicator Text
menu.ace.simpleselectonemenu.subMenu.reqStyle = Required Styling
# Overview
example.ace.simpleselectonemenu.title = ace:simpleSelectOneMenu - Overview
example.ace.simpleselectonemenu.description = <p>The <b>&lt;ace:simpleSelectOneMenu&gt;</b> component permits selecting a value from a number of given options, using the browser's native &lt;select&gt; element, while integrating well with the ACE environment and supporting features like Themeroller, ARIA, label positioning and &lt;ace:ajax&gt;.
# Label Position
example.ace.simpleselectonemenu.label.title = ace:simpleSelectOneMenu - Label Position
example.ace.simpleselectonemenu.label.description = <p>This example shows how to render, customize, and position an inline label for the simpleSelectOneMenu component.</p>
# Indicator Text
example.ace.simpleselectonemenu.indicator.title = ace:simpleSelectOneMenu - Indicator Text
example.ace.simpleselectonemenu.indicator.description = <p>This example shows how to customize the text of the required and optional indicator message.</p>
# Required Styling
example.ace.simpleselectonemenu.reqStyle.title = ace:simpleSelectOneMenu - Required Styling
example.ace.simpleselectonemenu.reqStyle.description = <p>This example shows how the simpleSelectOneMenu field can be customized to better indicate required or optional status beyond a simple message.</p>

### ACE - Slider
menu.ace.slider.title = ace:sliderEntry
menu.ace.slider.subMenu.title = Examples
menu.ace.slider.subMenu.main = Overview
menu.ace.slider.subMenu.asyncinput = Input
menu.ace.slider.subMenu.listener = Listener
menu.ace.slider.subMenu.submitionExample = Submit
# Overview
example.ace.slider.title = ace:sliderEntry - Overview
example.ace.slider.description = <p>The <b>&lt;ace:sliderEntry&gt;</b> component component is a scalable data input element.  It allows a user to enter an input value by dragging or clicking on the slider path.  The component supports a variety of features including  synchronous and asynchronous data inputs, slider range and gradients as well as fixed minimum and maximum  values.  Click the slider box and drag it along the bar to the left or right.  Release the slider at the desire location and view the value update in the example below.</p>
# Ansynchronous Input
example.ace.slider.asyncinput.title = ace:sliderEntry - Input Example
example.ace.slider.asyncinput.description = <p>The example below illustrates <b>&lt;ace:sliderEntry&gt;</b> functionality in asynchronous input mode. To operate the demo below, input any number from 0 to 99 in the text entry box located beneath the slider. Hit the enter or return key and the slider will automatically re-position itself to the new value.</p>
# Listener
example.ace.slider.listener.title = ace:sliderEntry - Listener Example
example.ace.slider.listener.description = <p>The example below illustrates <b>&lt;ace:sliderEntry&gt;</b> value change listener functionality. To operate the demo, drag slider to change its position. With each slider switch a circuit on the server side recalculates a new value via listener and either power the bulb ON or turn it OFF.</p>
#Submit Examples
example.ace.slider.submition.title = ace:sliderEntry - Submit Example
example.ace.slider.submition.description =<p>The example below illustrates <b>&lt;ace\:sliderEntry&gt;</b> submit functionality in basic and AJAX mode. To operate \u201CBasic Slider\u201D demo, click the slider rail or drag the slider to a new position. Once done push Set Slider Value button in order to update the value located above it. For \u201CAJAX Slider\u201D demo just click the rail or drag the slider to a new position. Notice how corresponding value is updated automatically each time you move the slider.</p>

### ACE - SubmitMonitor
menu.ace.submitMonitor.title = ace:submitMonitor
menu.ace.submitMonitor.subMenu.title = Examples
menu.ace.submitMonitor.subMenu.main = Overview
# Overview
example.ace.submitMonitor.title = ace:submitMonitor - Overview
example.ace.submitMonitor.description = <p>The <b>&lt;ace\:submitMonitor&gt;</b> component is used to display the status of the browser's connection with the server, whether it is currently idle, actively processing a submission, experiencing a network or server error, or if the session has expired.</p> <p>When a long duration submission is underway, the submitMonitor may block configurable portions of the user interface, to prevent users from further interacting with the page until the results of their submission have been returned, and the user interface has been updated. This can be used to enforce a consistent state.</p> <p>For each connection status that the submitMonitor can display, it's representation is customisable. By default an image is shown, and a label property can be specified as well, or, alternatively, a facet may be used to completely customise the representation. All of which can be styled with CSS.</p> <p>Multiple submitMonitor components may exist on the page, each listening to submissions from components in different regions of the page. This way, each submitMonitor may be customised to best inform the user of the submission status of the particular component(s).</p>

### ACE - TabSet
menu.ace.tabSet.title = ace:tabSet
menu.ace.tabSet.subMenu.title = Examples
menu.ace.tabSet.subMenu.main = Overview
menu.ace.tabSet.subMenu.clientSide = Client Side
menu.ace.tabSet.subMenu.serverSide = Server Side
menu.ace.tabSet.subMenu.proxy = Proxy
# Overview
example.ace.tabSet.title = ace:tabSet - Overview
example.ace.tabSet.description = <p>The <b>&lt;ace\:tabSet&gt;</b> component allows page content to be loaded into separate panels or \u201Ctabs\u201D that can be viewed one at a time. The tabs can be stored in the client side browser to latency in viewing or on a server to reduce initial bandwidth and start up times.  The ace\:tabSet component is highly versatile and can be run from within a larger form or can contain its own forms, tables etc.  Tab labels and formats are all fully programmable.  Example below demonstrates basic ace\:tabSet functionality with the tabs being hosted server-side.  Select any tab to view its content.</p>
# Client Side
example.ace.tabSet.clientSide.title = ace:tabSet - Client Side Example
example.ace.tabSet.clientSide.description = <p>In the example below, the tab content of the <b>&lt;ace:tabSet&gt;</b> component is kept loaded within the client browser.  This eliminates any unnecessary data transfer between the server and the client when the tab views are changed, speeding up the view times.  Click through the three tabs to view the content that has been retained inside the client browser.</p>
# Server Side
example.ace.tabSet.serverSide.title = ace:tabSet - Server Side Example
example.ace.tabSet.serverSide.description  = <p>In the example below, the tab content is maintained on the server.  Initial data transfer is less (meaning initial rendering times are faster)  and the memory footprint on the client is minimized, but the content requires transfer from the server every time a tab view is changed.</p>
# Proxy
example.ace.tabSet.proxy.title = ace:tabSet - Proxy Example
example.ace.tabSet.proxy.description = <p>The example below demonstrates the <b>&lt;ace:tabSet&gt;</b> component operating with a tabSetProxy feature enabled.  This feature allows the various tabs to contain their own forms and facilitates tab to tab communication and state changes through the server.  In this mode, updates in one tab can generate new content that will be reflected in the other tab elements.  In the example below click on the Text Entry tab and enter some text content in the input field.  Hit enter or return.  Click the Confirmation tab to view and confirm the content from the previous tab. Finally click the Outcome tab to view the accepted change of state.</p>

### ACE - Tooltip
menu.ace.tooltip.title = ace:tooltip
menu.ace.tooltip.subMenu.title = Examples
menu.ace.tooltip.subMenu.main = Overview
menu.ace.tooltip.subMenu.globalTooltip = Global
menu.ace.tooltip.subMenu.delegateTooltip = Delegate
# Overview
example.ace.tooltip.title = ace:tooltip - Overview
example.ace.tooltip.description = <p>The <b>&lt;ace:tooltip&gt;</b> is a graphical user interface element used in conjunction with a cursor or a mouse pointer. When the user hovers the mouse over a selected page region or component, a window appears containing related information or content.  The ace:tooltip supports a variety of animations which can be activated as the tooltip appears or is hidden, delay times governing how long the hover must occur before the tool tip appears, as well as its position and appearance.  In the example below, select the programmable tooltip options from the pull down menus below. Hover the cursor over the text boxes below to view the tooltip.</p>
# Global
example.ace.globalTooltip.title = ace:tooltip - Global Tooltip Example
example.ace.globalTooltip.description = <p>The <b>&lt;ace:tooltip&gt;</b> component supports a global mode of operation. When this feature is activated, it allows the ace:tooltip to override any title attributes or default tooltip with a commonly formatted ace:tooltip solution.   In the example below hover over the various active components to display a common tooltip operation.</p>
# Delegate
example.ace.delegateTooltip.title = ace:tooltip - Delegate Tooltip Example
example.ace.delegateTooltip.description = <p>The <b>&lt;ace:tooltip&gt;</b> component supports delegate events, which allow developers to only apply one tooltip component to an entire table or iterative container, rather than applying one tooltip component per row. This increases performance on the page substantially. As you can see in this demo, the <b>&lt;ace:tooltip&gt;</b> component is defined outside the table. You can hover over the names of the cars to see specific data for that car, in the tooltip. The contents of the tooltip are updated dynamically just before displaying it, using row-specific data.</p>

### ACE - Tree
menu.ace.tree.title = ace:tree
menu.ace.tree.subMenu.title = Examples
menu.ace.tree.subMenu.main = Overview
menu.ace.tree.subMenu.nested = Nested
menu.ace.tree.subMenu.client = Client
menu.ace.tree.subMenu.lazy = Lazy Loading
menu.ace.tree.subMenu.reorder = Drag / Drop
menu.ace.tree.subMenu.selection = Selection
# Overview
example.ace.tree.title = ace:tree - Overview
example.ace.tree.description = The <b>ace:tree</b> is a component for displaying a hierarchy of objects. The component supports many features including: lazy loading, client/server selection modes, client/server subnode expansion modes, node reordering, state initialization callback, ajax behaviours and multiple node template support.
example.ace.tree.nested.title = ace:tree - Nested Trees
example.ace.tree.nested.description =
example.ace.tree.client.title = ace:tree - Client Mode Selection / Expansion
example.ace.tree.client.description = The components below demonstrate the client expansion and selection modes.
example.ace.tree.lazy.title = ace:tree - Lazy Loading
example.ace.tree.lazy.description = The components below demonstrate  the Lazy Loading capabilities of the ace:tree. The loadChildrenForNode method of the LazyDataModel is called only when the sub-nodes of a Node are first displayed. Thereafter they are kept cached by the LazyDataModel and can be cleared from the cache using a supplied API as needed.
example.ace.tree.selection.title = ace:tree - Node Selection
example.ace.tree.selection.description = The components below demonstrate the selection capabilities of the ace:tree.
example.ace.tree.reorder.title = ace:tree - Node Dragging
example.ace.tree.reorder.description = The components below demonstrate the reordering capabilities of the ace:tree.

### ACE - List
menu.ace.list.title = ace:list
menu.ace.list.subMenu.title = Examples
menu.ace.list.subMenu.main = Overview
menu.ace.list.subMenu.block = Simple Block Object
menu.ace.list.subMenu.blockComplex = Complex Block Object
menu.ace.list.subMenu.selection = Selection
menu.ace.list.subMenu.selectionAjax = Selection (Ajax)
menu.ace.list.subMenu.selectionMini = Selection (Compact)
menu.ace.list.subMenu.reordering = Reordering
menu.ace.list.subMenu.reorderingAjax = Reordering (Ajax)
menu.ace.list.subMenu.drag = Drag & Drop
menu.ace.list.subMenu.dual = Dual List
menu.ace.list.subMenu.multi = Multi List
# Overview
example.ace.list.title = ace:list - Overview
example.ace.list.description = <p>Two examples using many of the features available on ace:list.</p>
# Simple Block Object
example.ace.list.block.title = ace:list - Simple Block Object
example.ace.list.block.description = <p>Simple examples of block layout.</p>
# Complex Block Object
example.ace.list.blockComplex.title = ace:list - Complex Block Object
example.ace.list.blockComplex.description = <p>Complex example of a floating block object multi list.</p>
# Reordering
example.ace.list.reorder.title = ace:list - Reordering
example.ace.list.reorder.description = <p>Simple example of reordering using the reorder controls, with dragging disabled.</p>
# Reordering (Ajax)
example.ace.list.reorderAjax.title = ace:list - Reordering (Ajax)
example.ace.list.reorderAjax.description = <p>Simple example of reordering using the reorder controls, with dragging disabled. The submission of the reorder is done automatically using Ajax.</p>
# Drag & Drop
example.ace.list.drag.title = ace:list - Drag & Drop
example.ace.list.drag.description = <p>Simple examples of drag and drop, to reorder items in a list and to migrate between lists.</p>
# Dual List
example.ace.list.dual.title = ace:list - Dual List
example.ace.list.dual.description = <p><Simple example of the listControl dual list mode./p>
# Multi
example.ace.list.multi.title = ace:list - Multi
example.ace.list.multi.description = <p>Simple example of the listControl n-list mode.</p>
# Selection
example.ace.list.selection.title = ace:list - Selection
example.ace.list.selection.description = <p>Simple example of list item selection.</p>
# Selection (Ajax)
example.ace.list.selectionAjax.title = ace:list - Selection (Ajax)
example.ace.list.selectionAjax.description = <p>Simple example of list item selection using Ajax.</p>
# Selection (Mini)
example.ace.list.selectionMini.title = ace:list - Selection (Compact)
example.ace.list.selectionMini.description = <p>A selection example using f:selectItems as an ace:list model along with 'compact' mode styling. <br/><br/> Note that when f:selectItem(s) children are used as the model to this ace:list that selections are instead added to the Collection bound to the value attribute, to more closely emulate the h:selectManyListbox component. Also reordering and migrations of an f:selectItem(s)-backed list are not allowed, since f:selecItem(s) are not an editable collection.</p>

### ACE - Chart
menu.ace.chart.title = ace:chart
menu.ace.chart.subMenu.title = Examples
menu.ace.chart.subMenu.main = Overview
menu.ace.chart.subMenu.combined = Combined
menu.ace.chart.subMenu.pie = Pie
menu.ace.chart.subMenu.donut = Donut
menu.ace.chart.subMenu.candlestick = Candlestick
menu.ace.chart.subMenu.dynamic = Dynamic
menu.ace.chart.subMenu.bubble = Bubble
menu.ace.chart.subMenu.gauge = Gauge
menu.ace.chart.subMenu.export = Export
menu.ace.chart.subMenu.bar = Bar
menu.ace.chart.subMenu.line = Line

# Overview
example.ace.chart.title = ace:chart - Overview
example.ace.chart.description = <p>The chart component can be used to display data in a variety of forms and styles.</p>
# Combined Chart
example.ace.chart.combined.title = ace:chart - Combined Chart
example.ace.chart.combined.description = <p>The chart component can combine different styles of charts together to display complex data in a unique fashion.</p>
# Pie Chart
example.ace.chart.pie.title = ace:chart - Pie Chart
example.ace.chart.pie.description = <p>The chart component can render data in a standard pie chart.</p>
# Donut Chart
example.ace.chart.donut.title = ace:chart - Donut Chart
example.ace.chart.donut.description = <p>The chart component can render data in a donut chart.</p>
# Candlestick Chart
example.ace.chart.candlestick.title = ace:chart - Candlestick Chart
example.ace.chart.candlestick.description = <p>The chart component can render data in a candlestick chart.</p>
# Dynamic Chart
example.ace.chart.dynamic.title = ace:chart - Dynamic Chart
example.ace.chart.dynamic.description = <p>The chart component can dynamically generate charts from changing data or conditions, such as a user clicking on a row in a dataTable.</p>
# Bubble Chart
example.ace.chart.bubble.title = ace:chart - Bubble Chart
example.ace.chart.bubble.description = <p>The chart component can render one or more series of 'bubble' points with specific areas.</p>
# Gauge Chart
example.ace.chart.gauge.title = ace:chart - Gauge Chart
example.ace.chart.gauge.description =  <p>The chart component can render one value point on a analog-style 'gauge' with configurable intervals and sizing.</p>
# Export Chart
example.ace.chart.export.title = ace:chart - Export Chart
example.ace.chart.export.description =  <p>The chart component can export itself as a PNG image via an img tag using the JavaScript api. Note that this is unavailable in IE 7 and 8 due limitations of the compatibility technology used to enabled charting on those browsers.</p>
# Export Chart
example.ace.chart.line.title = ace:chart - Line Chart
example.ace.chart.line.description =  <p>The chart component can render data in a line chart.</p>
# Export Chart
example.ace.chart.bar.title = ace:chart - Bar Chart
example.ace.chart.bar.description =  <p>The chart component can render data in a bar chart.</p>
### ACE - GMap
menu.ace.gMap.title = ace:gMap
menu.ace.gMap.subMenu.title = ace:gMap
menu.ace.gMap.subMenu.overview = Overview
menu.ace.gMap.subMenu.direction = Directions
menu.ace.gMap.subMenu.layer = Layers
menu.ace.gMap.subMenu.marker = Map Markers
menu.ace.gMap.subMenu.options = Map Options
menu.ace.gMap.subMenu.overlay = Overlays
menu.ace.gMap.subMenu.control = Controls
menu.ace.gMap.subMenu.autocomplete = Autocomplete
menu.ace.gMap.subMenu.infowindow = Info Windows
menu.ace.gMap.subMenu.event = Google Events
#Overview
example.ace.gMap.overview.title = ace:gMap Overview
example.ace.gMap.overview.description = An overview of a basic ace:gMap. This includes setting the latitude/longitude points for the map to center on, determining the zoom and map type, and forcing the map to center on a given address.
#Directions
example.ace.gMap.direction.title = Directions in ace:gMap
example.ace.gMap.direction.description = <p>Directions are a subset of the <b>&lt;ace:gMapService&gt;</b> component, allowing for the display of directions using multiple forms of transport over a user-defined set of waypoints. Additionally, a variety of options can be added to better customize directional output for your purpses.</p>
#Layers
example.ace.gMap.layer.title = Map Layers
example.ace.gMap.layer.description = <p><b>&lt;ace:gMapLayer&gt;</b> allows for the introduction of a premade map layer into the gMap element. These layers can vary from showing traffic and highlighting desired paths to complex and specific displays defined by outside KML files.</p>
#Markers
example.ace.gMap.marker.title = Map Markers
example.ace.gMap.marker.description = <p><b>&lt;ace:gMapMarker&gt;</b> allows for the placement of a marker pin on the map of your choice. This pin is highly customizable, and can be used to show a wide variety of information via user made icons and titles</p> 
#Options
example.ace.gMap.options.title = Basic Map Options
example.ace.gMap.options.description = <p>A demo demonstrating the flexibility inherent in a basic <b>&lt;ace:gMap&gt;</b>, using nothing more than the default options attribute.</p>
#Overlays
example.ace.gMap.overlay.title = Map Overlays
example.ace.gMap.overlay.description = <p><b>&lt;ace:gMapOverlay&gt;</b> allows for users to define their own shapes on a gMap.</p>
#Controls
example.ace.gMap.control.title = Map Controls
example.ace.gMap.control.description = <p><b>&lt;ace:gMapControl&gt;</b> gives the user an easier method to access the various control options that are available in Google maps.</p>
#Autocomplete
example.ace.gMap.autocomplete.title = Map Autocomplete
example.ace.gMap.autocomplete.description = <p><b>&lt;ace:gMapAutocomplete&gt;</b> allows for users to tap into the Google Autocomplete database, automatically zooming and recentering when a location is chosen from the dropdown menu created.</p>
#InfoWindow
example.ace.gMap.infowindow.title = Info Windows
example.ace.gMap.infowindow.description = <p><b>&lt;ace:gMapInfowindow&gt;</b> allows for users to create a window in the parent google map to desplay text, html, or other JSF components.</p>
#Event
example.ace.gMap.event.title = Google Events
example.ace.gMap.event.description = <p><b>&lt;ace:gMapEvent&gt;</b> allows for users to tap into Google's event handling capabilities and execute a chosen javascript on a variety of triggers. The variable 'map' can be used to affect the parent map and 'component' can be used to reference the parent component.</p>


################################################################################
# UNUSED messages
################################################################################

### ACE - Logger (INACTIVE)
menu.ace.logger.title = Logger
menu.ace.logger.subMenu.title = Examples
menu.ace.logger.subMenu.main = Overview
# Overview
example.ace.logger.title = Logger Component
example.ace.logger.description = <p>The ACE Logger component is based around the one offered by the YUI toolkit, providing a standardized way of reading and writing log messages. When the tag is present on the page it adds divs containing the log controls to the root of the DOM. In this example, to prevent root placement from breaking page flow, the class .yui-log-container is positioned to fixed values similarly to a popup. The logs will have a record for every Javascript call to YAHOO.log().</p><p>The example below has a button to display the logger and some example controls to generate arbitrary Javascript messages using YAHOO.log().</p>

### ACE - Button
menu.ace.button.title = Buttons
menu.ace.button.subMenu.title = Examples
menu.ace.button.subMenu.main = Overview
# Overview
example.ace.button.title = ACE Button Components
example.ace.button.description = <p>The ACE Button Components provide the functionality of the standard JSF implementations while integrating ICEfaces features such as Single Submit. Buttons can be used for:</p><p>1. Action navigation via the application NavigationController and the "action" attribute.<br/>2. Presenting a clickable UI control for a listener<br/>3. Performing a full form submission when <b>&lt;f:ajax&gt;</b> or singleSubmit is not being used.<br></p><p>Below is a example of each button configured as the control for a simple listener.</p>
################################################################################
# ICE Components (ICE)                                          #
################################################################################

### ICE - Suite Overview
menu.compat.iceSuiteOverview.title = ICE Overview
menu.compat.iceSuiteOverview.subMenu.title = Examples
menu.compat.iceSuiteOverview.subMenu.main = Overview
# Overview
example.compat.iceSuiteOverview.title = ICE Overview
example.compat.iceSuiteOverview.description = <h2>What are the ICE Components?</h2><p>The open source ICE Components (ICEfaces Components) are based on the original ICEfaces Component Suite in ICEfaces 1.x. The components have been updated to support JSF 2 and more recent versions of ICEfaces. The ICE Components are a complete set of mature JSF components that have benefited from thousands of successful project deployments since their inception.</p><br/><p>The ICE components are primarily implemented using traditional JSF server-side rendering techniques with limited JavaScript. When combined with ICEfaces automatic-Ajax technology, the ICE Components exhibit extensive partial-page-rendering, providing a rich, dynamic user-experience, even on older legacy browsers.</p><h2>When should I use the ICE Components?</h2><p>The ICE Components are recommended under the following circumstances:<br><ul><li><b>&#187;</b> Legacy Browser Support. The ICE Components are ideally suited for projects that are required to support older legacy browsers, such as Internet Explorer 6 / 7. These browsers have significantly less efficient JavaScript processing engines, effectively preventing them from supporting most contemporary JavaScript libraries. The ICE Components can provide good performance on older browsers due to their reliance on predominantly server-side rendering and processing techniques.</li><li><b>&#187;</b> Application Migration. The ICE Components are tag-compatible with the ICEfaces 1.x Component Suite. This greatly simplifies the migration of ICEfaces 1.x applications to more recent versions of ICEfaces.<br></li><li><b>&#187;</b> Specialized Applications. Some projects with specific accessibility or security requirements may be required to minimize client-side JavaScript rendering and data-processing. In these cases, the ICE Components may be better suited to meet those requirements.</li></ul></p><h2>Can I use the ICE Components with the ACE Components?</h2><p>Yes! It is possible to mix both ICE and ACE components as needed in the same ICEfaces application, or even in the same page (with some limitations).</p><h2>How are the ICE Components Licensed?</h2><p>The ICE Components are made available under the Apache License Version 2 open source License. All code modifications and component enhancements are free for developers to use, distribute, and modify.</p><h2>How can I find out more about the components?</h2><p>The component samples included in this ICEfaces Showcase application include source code for each sample, located at the bottom of each page. In addition, links to technical documentation and the component TLD documentation are provided on the right-hand side menu on the header bar for each sample.</p><br><p>The complete source code for this sample application is included in the <a href="http://www.icesoft.org/java/downloads/icefaces-downloads.jsf" style="text-decoration: underline;" target="_blank" >ICEfaces release bundle</a>.</p>
### ICE - Columns
menu.compat.columns.title = ice:columns
menu.compat.columns.subMenu.title = Examples
menu.compat.columns.subMenu.main = Overview
menu.compat.columns.subMenu.checker = Checkerboard
# Overview
example.compat.columns.title = ice:columns - Overview
example.compat.columns.description = <p>The columns component is useful for displaying a 2D grid, which is otherwise not easily achievable with a dataTable or other iterator component.</p><p>In the example below:</p><ul><li><b>&#187;</b> Enter a number of rows and columns and click "Apply Changes".</li><li><b>&#187;</b> Observe the resulting layout displayed by the columns component.</li></ul>
# 2D Array
example.compat.columns.checker.title = ice:columns - Checkerboard Example
example.compat.columns.checker.description = <p>Example rendering a checkerboard using the columns component.</p>

### ICE - Data Exporter (Data Table)
menu.compat.exporter.title = ice:dataExporter
menu.compat.exporter.subMenu.title = Examples
menu.compat.exporter.subMenu.main = Overview
menu.compat.exporter.subMenu.type = Type
menu.compat.exporter.subMenu.column = Include Columns
menu.compat.exporter.subMenu.pagination = Ignore Pagination
menu.compat.exporter.subMenu.label = Custom Label
# Overview
example.compat.exporter.title = ice:dataExporter - Overview
example.compat.exporter.description = <p>The exporter component lets users download the contents of a data table as either a CSV or Excel file, which can be useful for saving search results or other information traditionally displayed with a data table. From a developer perspective the exporter is simple to use, as they just include the component in the page to enable the functionality. Labels and other options can be customized as needed.</p><p>Click the "Download as CSV" link to save the data table below as a file full of comma-separated-values.</p>
# Type
example.compat.exporter.type.title = ice:dataExporter - Custom File Type Example
example.compat.exporter.type.description = <p>Select which file type will be used for export below.</p>
# Include Columns
example.compat.exporter.column.title = ice:dataExporter - Custom Columns Example
example.compat.exporter.column.description = <p>Select which which columns to include in the export below.</p>.
# Ignore Pagination
example.compat.exporter.pagination.title = ice:dataExporter - Ignore Pagination Example
example.compat.exporter.pagination.description = <p>Pagination of the table can be ignored or accounted for during data export</p>
# Custom Label
example.compat.exporter.label.title = ice:dataExporter - Custom Label Example
example.compat.exporter.label.description = <p>Render a button, image, or custom text for the label.</p>

### ICE - Data Paginator (Data Table)
menu.compat.paginator.title = ice:dataPaginator
menu.compat.paginator.subMenu.title = Examples
menu.compat.paginator.subMenu.main = Overview
menu.compat.paginator.subMenu.info = Info Paginator
menu.compat.paginator.subMenu.events = Events
menu.compat.paginator.subMenu.max = Max Pages
menu.compat.paginator.subMenu.fast = Fast Step
menu.compat.paginator.subMenu.display = Always Display
menu.compat.paginator.subMenu.vertical = Vertical
# Overview
example.compat.paginator.title = ice:dataPaginator - Overview
example.compat.paginator.description = <p>The paginator component is useful for moving through large sets of data in a data table. The displayed pages, step count, etc. can be customized through the component. A developer can implement lazy loading in their data table so that only the displayed rows are stored in memory, instead of the entire data set. This is extremely useful for large sets of data read from a database.</p> <p>In the example below enter a number of rows to display in the data table at once. If the rows exceed the displayed amount a paginator will show up and can be used to move through the available data</p>
# Info
example.compat.paginator.info.title = ice:dataPaginator - With Additional Information Example
example.compat.paginator.info.description = <p>View an information based paginator, which displays text information about the associated data table.</p>
# Events
example.compat.paginator.events.title = ice:dataPaginator - Events Example
example.compat.paginator.events.description = <p>Paginator events can be fired and listened to.</p>
# Max Pages
example.compat.paginator.max.title = ice:dataPaginator - Max Pages Example
example.compat.paginator.max.description = <p>Number of pages to display at once in the paginator can be customized.</p>
# Fast Step
example.compat.paginator.fast.title = ice:dataPaginator - Fast Step Example
example.compat.paginator.fast.description = <p>Fast step feature of the paginator can be customized.</p>
# Always Display
example.compat.paginator.display.title = ice:dataPaginator - Always Display Example
example.compat.paginator.display.description = <p>Display the paginator only when needed.</p>
# Vertical
example.compat.paginator.vertical.title = ice:dataPaginator - Vertical Layout Example
example.compat.paginator.vertical.description = <p>Render the data paginator vertically instead of horizontally.</p>

### ICE - Data Table (Generic)
menu.compat.dataTable.title = ice:dataTable
menu.compat.dataTable.subMenu.title = Examples
menu.compat.dataTable.subMenu.main = Overview
menu.compat.dataTable.subMenu.rows = Displayed Rows
menu.compat.dataTable.subMenu.group = Column Grouping
menu.compat.dataTable.subMenu.hide = Column Hiding
menu.compat.dataTable.subMenu.resize = Column Resizing
menu.compat.dataTable.subMenu.widths = Column Widths
menu.compat.dataTable.subMenu.client = Client Only Resizing
menu.compat.dataTable.subMenu.sort = Sorting
menu.compat.dataTable.subMenu.scroll = Scrolling
menu.compat.dataTable.subMenu.dynamic = Dynamic
menu.compat.dataTable.subMenu.find = Find
# Overview
example.compat.dataTable.title = ice:dataTable - Overview
example.compat.dataTable.description = <p>The data table component is a powerful improvement on the standard JSF dataTable. Additional functionality like sorting, pagination, resizing, row selection, scrolling, etc. are added. In general a data table is used to display a list of data, such as records generated from a database.</p><p>Example below will allow you to:</p><ul><li><b>&#187;</b> Sort the data table by clicking a header (such as Name) and observing the result.</li><li><b>&#187;</b> Page through the data by using the paginator buttons at the bottom of the data table.</li><li><b>&#187;</b> Resize the columns by clicking and dragging the thick gray bar between each column.</li></ul>
# Rows
example.compat.dataTable.rows.title = ice:dataTable - Displayed Rows Example
example.compat.dataTable.rows.description = <p>Customize how many rows to display at once.</p>
# Grouping
example.compat.dataTable.group.title = ice:dataTable - Column Grouping Example
example.compat.dataTable.group.description = <p>The car data below is sorted and grouped by Chassis. Also note the grouped header for the last four column headers.</p>
# Hiding
example.compat.dataTable.hide.title = ice:dataTable - Column Hiding Example
example.compat.dataTable.hide.description = <p>Hide or display columns inside a data table.</p>
# Resizing
example.compat.dataTable.resize.title = ice:dataTable - Column Resizing Example
example.compat.dataTable.resize.description = <p>Resizable data table.</p>
# Resizing Widths
example.compat.dataTable.widths.title = ice:dataTable - Column Resizing Widths Example
example.compat.dataTable.widths.description = <p>Customize the widths of the resizable columns.</p>
# Client Only Resizing
example.compat.dataTable.client.title = ice:dataTable - Client Only Resizing Example
example.compat.dataTable.client.description = <p>Toggle column resizing to be stored only on the client.</p>
# Sorting
example.compat.dataTable.sort.title = ice:dataTable - Sorting Example
example.compat.dataTable.sort.description = <p>To sort data in the example below click on column headers of the data table.</p>
# Scrolling
example.compat.dataTable.scroll.title = ice:dataTable - Scrolling Example
example.compat.dataTable.scroll.description = <p>Scrollable data table.</p>
# Dynamic
example.compat.dataTable.dynamic.title = ice:dataTable - Dynamic Example
example.compat.dataTable.dynamic.description = <p>Modify the data table by adding, removing, or updating records.</p>
# Find
example.compat.dataTable.find.title = ice:dataTable - Find Example
example.compat.dataTable.find.description = <p>Search for a row in the DataTable and navigate to it.</p>


### ICE - Map
menu.compat.map.title = ice:gMap
menu.compat.map.subMenu.title = Examples
menu.compat.map.subMenu.main = Overview
menu.compat.map.subMenu.address = Address
menu.compat.map.subMenu.controls = Controls
menu.compat.map.subMenu.latlong = Latitude/Longitude
menu.compat.map.subMenu.load = Load XML
menu.compat.map.subMenu.type = Render Type
menu.compat.map.subMenu.zoom = Zoom Level
# Overview
example.compat.map.title = ice:gMap - Overview
example.compat.map.description = <p>The map component wraps the Google Map API and allows ICEfaces developers to easily access mapping functionality in their application. The display controls, size, map type, zoom level, etc. can be customized.</p> <p>In the example below:</p><ul><li><b>&#187;</b> Enter a street address to look up into the input field.</li><li><b>&#187;</b> Click "Perform Lookup" to display the address using the map component below.</li></ul>
# Address
example.compat.map.address.title = ice:gMap - Address Example
example.compat.map.address.description = <p>Lookup a single address or get directions between two locations (including optional text directions).</p>
# Controls
example.compat.map.controls.title = ice:gMap - Controls Example
example.compat.map.controls.description = <p>Show the different map controls available with the component.</p>
# Latitude/Longitude
example.compat.map.latlong.title = ice:gMap - Latitude/Longitude Example
example.compat.map.latlong.description = <p>Locate preset locations with latitude and longitude coordinates.</p>
# Load XML
example.compat.map.load.title = ice:gMap - Load KML Example
example.compat.map.load.description = <p>Load a series of map locations from KML, such as a community provided list of restaurants.</p>
# Type
example.compat.map.type.title = ice:gMap - Type Example
example.compat.map.type.description = <p>Set the rendering type the map will use, such as Satellite.</p>
# Zoom
example.compat.map.zoom.title = ice:gMap - Zoom Example
example.compat.map.zoom.description = <p>Dynamically set the zoom level from the bean level.</p>

### ICE - Rich Text
menu.compat.richtext.title = ice:inputRichText
menu.compat.richtext.subMenu.title = Examples
menu.compat.richtext.subMenu.main = Overview
menu.compat.richtext.subMenu.save = Save on Submit
menu.compat.richtext.subMenu.language = Language
menu.compat.richtext.subMenu.skin = Skins
menu.compat.richtext.subMenu.toolbar = Toolbar
menu.compat.richtext.subMenu.disable = Disable
# Overview
example.compat.richtext.title = ice:inputRichText - Overview
example.compat.richtext.description = <p>The rich text component wraps the CKEditor and allows users to easily format and customize their input. All entered text is stored as plain HTML on the server, so developers can redisplay the text, save it as a document, etc. as needed. The appearance and language of the rich text component can be customized.</p><p>In the example below:</p><ul><li><b>&#187;</b> Use the various features of the rich text editor such as bolding text, inserting links, adding lists, etc.</li><li><b>&#187;</b> Click the "Save" button (icon of a floppy disk) to submit the entered text to the server.</li><li><b>&#187;</b> Entered text will display under the "Saved Text String" field at the bottom.</li></ul>
# Save on Submit
example.compat.richtext.save.title = ice:inputRichText - Save on Submit Example
example.compat.richtext.save.description = <p>Choose whether the Rich Text component should save anytime a submit is done, or only when the Save button is explicilty clicked by the user.</p>
# Language
example.compat.richtext.language.title = ice:inputRichText - Language Example
example.compat.richtext.language.description = <p>Choose from 54 available languages for the Rich Text component.</p>
# Skin
example.compat.richtext.skin.title = ice:inputRichText -  Skins Example
example.compat.richtext.skin.description = <p>Choose from 3 different skin themes for the Rich Text component.</p>
# Toolbar
example.compat.richtext.toolbar.title = ice:inputRichText -  Toolbar Example
example.compat.richtext.toolbar.description = <p>View the basic or feature rich toolbars for the Rich Text component.</p>
# Disable
example.compat.richtext.disable.title = ice:inputRichText -  Disabled State Example
example.compat.richtext.disable.description = <p>View how the disabled state of the Rich Text component appears and functions.</p>

### ICE - Menu Bar
menu.compat.menuBar.title = ice:menuBar
menu.compat.menuBar.subMenu.title = Examples
menu.compat.menuBar.subMenu.main = Overview
menu.compat.menuBar.subMenu.events = Events
menu.compat.menuBar.subMenu.orientation = Orientation
menu.compat.menuBar.subMenu.click = Display on Click
menu.compat.menuBar.subMenu.keyboard = Keyboard Navigation
menu.compat.menuBar.subMenu.icons = Icons
menu.compat.menuBar.subMenu.separator = Separator
menu.compat.menuBar.subMenu.dynamic = Dynamic
# Overview
example.compat.menuBar.title = Overview
example.compat.menuBar.description = <p>The menu bar component is an easy way to add cross-browser Javascript based menus, which are useful for navigation or accessing functionality of a web application. The layout and ordering of the menu is created using a hierarchical series of parent-child menu components.Each component can be customized with text, icons, and style. The items can either link to a page or perform an action on the server.</p><p>In the example below:</p><ul><li><b>&#187;</b> Mouse over each menu option to display their submenu items</li></ul>
# Events
example.compat.menuBar.events.title = ice:menuBar -  Events Example
example.compat.menuBar.events.description = <p>Fire events when different menu items are clicked on.</p>
# Orientation
example.compat.menuBar.orientation.title = ice:menuBar -  Orientation Example
example.compat.menuBar.orientation.description = <p>View the different orientations available with the menu bar component.</p>
# Display on Click
example.compat.menuBar.click.title = ice:menuBar -  Display on Click Example
example.compat.menuBar.click.description = <p>Determine whether hovering will open the menu or if clicking is necessary.</p>
# Keyboard Navigation
example.compat.menuBar.keyboard.title = ice:menuBar -  Keyboard Navigation Example
example.compat.menuBar.keyboard.description = <p>Enable or disable keyboard navigation for the menu bar.</p>
# Icons
example.compat.menuBar.icons.title = ice:menuBar -  Icons Example
example.compat.menuBar.icons.description = <p>Display or hide the image icons associated with some menu items.</p>
# Separator
example.compat.menuBar.separator.title = ice:menuBar -  Separator Example
example.compat.menuBar.separator.description = <p>View the menu item separator component in the context of a menu bar.</p>
# Dynamic
example.compat.menuBar.dynamic.title = ice:menuBar -  Dynamic Example
example.compat.menuBar.dynamic.description = <p>Dynamically generate a list of menu items.</p>

### ICE - Menu Popup
menu.compat.menuPopup.title = ice:menuPopup
menu.compat.menuPopup.subMenu.title = Examples
menu.compat.menuPopup.subMenu.main = Overview
menu.compat.menuPopup.subMenu.events = Events
menu.compat.menuPopup.subMenu.orientation = Orientation
menu.compat.menuPopup.subMenu.hide = Hide On
menu.compat.menuPopup.subMenu.keyboard = Keyboard Navigation
menu.compat.menuPopup.subMenu.icons = Icons
menu.compat.menuPopup.subMenu.separator = Separator
menu.compat.menuPopup.subMenu.dynamic = Dynamic
# Overview
example.compat.menuPopup.title = Overview
example.compat.menuPopup.description = <p>The menu popup is useful for creating a right-click menu in the style of a traditional desktop application. The layout and ordering of the menu is created using a hierarchical series of parent-child menu components. Each component can be customized with text, icons, and style. The items can either link to a page or perform an action on the server.</p><p>In the example below:</p><ul><li><b>&#187;</b> Right-click on any of the words in the sentence below.</li><li><b>&#187;</b> A menu popup will be displayed that allows you to choose a style or color for each word.</li></ul>
# Events
example.compat.menuPopup.events.title = ice:menuPopup -  Events Example
example.compat.menuPopup.events.description = <p>Right-click on the image below to display a menu popup that can be used to fire events.</p>
# Hide On
example.compat.menuPopup.hide.title = ice:menuPopup -  Hide On Example
example.compat.menuPopup.hide.description = <p>Determine how to close the menu popup.</p>
# Keyboard Navigation
example.compat.menuPopup.keyboard.title = ice:menuPopup -  Keyboard Navigation Example
example.compat.menuPopup.keyboard.description = <p>Enable or disable keyboard navigation for the menu popup.</p>
# Icons
example.compat.menuPopup.icons.title = ice:menuPopup -  Icons Example
example.compat.menuPopup.icons.description = <p>Display or hide the image icons associated with some menu items.</p>
# Separator
example.compat.menuPopup.separator.title = ice:menuPopup -  Separator Example
example.compat.menuPopup.separator.description = <p>View the menu item separator component in the context of a menu popup.</p>
# Dynamic
example.compat.menuPopup.dynamic.title = ice:menuPopup -  Dynamic Example
example.compat.menuPopup.dynamic.description = <p>Dynamically generate a list of menu items.</p>

### ICE - Chart
menu.compat.chart.title = ice:outputChart
menu.compat.chart.subMenu.title = Examples
menu.compat.chart.subMenu.main = Overview
menu.compat.chart.subMenu.area = Area
menu.compat.chart.subMenu.bar = Bar
menu.compat.chart.subMenu.areaStacked = Area Stacked
menu.compat.chart.subMenu.barStacked = Bar Stacked
menu.compat.chart.subMenu.barClustered = Bar Clustered
menu.compat.chart.subMenu.line = Line
menu.compat.chart.subMenu.point = Point
menu.compat.chart.subMenu.pie2d = Pie 2D
menu.compat.chart.subMenu.pie3d = Pie 3D
menu.compat.chart.subMenu.custom = Custom
menu.compat.chart.subMenu.options = Basic Options
menu.compat.chart.subMenu.dynamic = Dynamic
# Chart
example.compat.chart.title = Overview
example.compat.chart.description = <p>The chart component (built on top of JCharts) is a versatile and powerful way to render chart data in a variety of formats. Colors, labels and legends, point style, etc. can all be customized which allows a developer to display information in the exact way they want.</p>
# Area Chart
example.compat.chart.area.title = ice:outputChart - Area Example
example.compat.chart.area.description = <p>Area chart</p>
# Area Stacked
example.compat.chart.areaStacked.title = ice:outputChart - Area Stacked Example
example.compat.chart.areaStacked.description = <p>Charts come in various forms.</p>
# Bar Chart
example.compat.chart.bar.title = ice:outputChart - Bar  Example
example.compat.chart.bar.description = <p>Bar chart.</p>
# Bar Stacked
example.compat.chart.barStacked.title = ice:outputChart - Bar Stacked  Example
example.compat.chart.barStacked.description = <p>Stacked bars chart.</p>
# Bar Clustered
example.compat.chart.barClustered.title = ice:outputChart - Bar Clustered  Example
example.compat.chart.barClustered.description = <p>Stacked bars chart.</p>
# Line
example.compat.chart.line.title = ice:outputChart - Line  Example
example.compat.chart.line.description =<p>Line chart</p>
# Point
example.compat.chart.point.title = ice:outputChart - Point  Example
example.compat.chart.point.description = <p>Point chart</p>
# Pie2d
example.compat.chart.pie2d.title = ice:outputChart - Pie2d  Example
example.compat.chart.pie2d.description = <p>Pie2d chart</p>
# Pie3D
example.compat.chart.pie3d.title = ice:outputChart - Pie3D  Example
example.compat.chart.pie3d.description = <p>Pie3d chart</p>
# Custom
example.compat.chart.custom.title = ice:outputChart - Custom  Example
example.compat.chart.custom.description = <p>Custom chart</p>
# Options
example.compat.chart.options.title = ice:outputChart- Basic Options Example
example.compat.chart.options.description = <p>Generic options to customize the chart. Title, height and width, legend placement.</p>
# Dynamic
example.compat.chart.dynamic.title = ice:outputChart - Dynamic Example
example.compat.chart.dynamic.description = <p>Dynamically add or remove data from a chart.</p>

### ICE - Connection Status
menu.compat.connectionStatus.title = ice:outputConnectionStatus
menu.compat.connectionStatus.subMenu.title = Examples
menu.compat.connectionStatus.subMenu.main = Overview
menu.compat.connectionStatus.subMenu.labels = Labels
menu.compat.connectionStatus.subMenu.style = Style
# Overview
example.compat.connectionStatus.title = ice:outputConnectionStatus - Overview
example.compat.connectionStatus.description = <p>The connection status component is used to display information about the health of a user's session with the web application. This can be useful if you have long running tasks and want to show the user that the server is still working. Also warning of poor connectivity or a lost connection can help if the server crashes or the user's browser loses their internet connection.</p><p>In the example below:</p><ul><li><b>&#187;</b>  Click "Long Event" to simulate a long running task on the server. Notice how the connection status component displays the active (or "working") status until the task is complete.</li><li><b>&#187;</b> Click "Disconnect Event" to clear the current session, which will put the connection status component into the disconnected status. <b>After clicking this you will need to refresh your browser. </b></li></ul>
# Labels
example.compat.connectionStatus.labels.title = ice:outputConnectionStatus - Label Example
example.compat.connectionStatus.labels.description = <p>Customize the different labels of the connection status component.</p>
# Style
example.compat.connectionStatus.style.title = ice:outputConnectionStatus - Style Example
example.compat.connectionStatus.style.description = <p>View the different styles of the connection status component.</p>

### ICE - Media
menu.compat.media.title = ice:outputMedia
menu.compat.media.subMenu.title = Examples
menu.compat.media.subMenu.main = Overview
menu.compat.media.subMenu.flash = Flash
menu.compat.media.subMenu.quicktime = Quicktime
menu.compat.media.subMenu.windows = Windows WMV
menu.compat.media.subMenu.real = Real Player
# Overview
example.compat.media.title = Overview
example.compat.media.description = <p>The media component allows rich Flash, Quicktime, WMV, and Real Player files to be easily displayed in the browser. This is a handy and easy to use alternative to manually crafting the HTML required to display these elements. The various controls of the player, as well as size and style can be customized.</p>
# Flash
example.compat.media.flash.title = ice:outputMedia - Flash Example
example.compat.media.flash.description = <p>Render media in the Flash format.</p>
# Quicktime
example.compat.media.quicktime.title = ice:outputMedia - Quicktime Example
example.compat.media.quicktime.description = <p>Render media in the Quicktime format.</p>
# Windows WMV
example.compat.media.windows.title = ice:outputMedia - Windows WMV Example
example.compat.media.windows.description = <p>Render media in the Windows WMV format.</p>
# Real Player
example.compat.media.real.title = ice:outputMedia - Real Player Example
example.compat.media.real.description = <p>Render media in the Real Player format.</p>

### ICE - Progress Bar
menu.compat.progress.title = ice:outputProgress
menu.compat.progress.subMenu.title = Examples
menu.compat.progress.subMenu.main = Overview
menu.compat.progress.subMenu.indeterminate = Indeterminate
menu.compat.progress.subMenu.label = Custom Label
menu.compat.progress.subMenu.multiple = Multiple Instances
menu.compat.progress.subMenu.style = Style
# Overview
example.compat.progress.title = ice:outputProgress - Overview
example.compat.progress.description = <p>The progress bar component is very useful for notifying users of the status of long running tasks on the server. For example filtering search results, saving or uploading a large file, processing a complex algorithm, etc. can all be displayed with the progress bar.</p><p>From a developer perspective they can update the progress bar percentage at any point during their long running task, and use Ajax Push to display the update to the user's browser.</p><p>The size, labels, coloring, etc. of the progress bar can be customized.</p><p>In the example below:</p><ul><li><b>&#187;</b> Click the "Start" button to simulate a long running task on the server that updates the completed status on the page.</li><li><b>&#187;</b> At any point click the "Stop" button to stop the long running task.</li> <li><b>&#187;</b> Click "Reset" to put the progress back to 0%.</li></ul>
# Indeterminate
example.compat.progress.indeterminate.title = ice:outputProgress - Indeterminate Example
example.compat.progress.indeterminate.description = <p>Display a progress bar without a specified percent, which is ideal for an unknown long runnning task.</p>
# Custom Label
example.compat.progress.label.title = ice:outputProgress - Custom Label Example
example.compat.progress.label.description = <p>Customize the position and text of the progress bar label.</p>
# Multiple Instances
example.compat.progress.multiple.title = ice:outputProgress - Multiple Instances Example
example.compat.progress.multiple.description = <p>Multiple progress bars all running at once.</p>
# Style
example.compat.progress.style.title = ice:outputProgress - Style Example
example.compat.progress.style.description = <p>Customize the progress bar style.</p>

### ICE - Output Resource
menu.compat.outputResource.title = ice:outputResource
menu.compat.outputResource.subMenu.title = Examples
menu.compat.outputResource.subMenu.main = Overview
menu.compat.outputResource.subMenu.type = Type
menu.compat.outputResource.subMenu.attachment = Attachment
menu.compat.outputResource.subMenu.filename = Filename
menu.compat.outputResource.subMenu.label = Label
# Overview
example.compat.outputResource.title = ice:outputResource - Overview
example.compat.outputResource.description = <p>Traditionally allowing users access to file resources on the server has sometimes been a challenge. With the output resource component a developer can simply specify a path and the streaming of the resource to the user's browser will be handled automatically.</p><p>In the example below:</p><ul><li><b>&#187;</b> Click the "Download PDF" link to save a PDF file located on the server.</li></ul>
# Type
example.compat.outputResource.type.title =ice:outputResource - Type Example
example.compat.outputResource.type.description = <p>View the different types of rendering available with the output resource component.</p>
# Attachment
example.compat.outputResource.attachment.title = ice:outputResource - Attachment Example
example.compat.outputResource.attachment.description = <p>Choose whether the resource should download as an attachment or attempt to display in the browser.</p>
# Filename
example.compat.outputResource.filename.title = ice:outputResource - Filename Example
example.compat.outputResource.filename.description = <p>Customize the filename of the resource that is to be downloaded.</p>
# Label
example.compat.outputResource.label.title = ice:outputResource - Label Example
example.compat.outputResource.label.description = <p>Modify the labels of the button or link that allows the resource to be downloaded.</p>

### ICE - Border Panel
menu.compat.border.title = ice:panelBorder
menu.compat.border.subMenu.title = Examples
menu.compat.border.subMenu.main = Overview
menu.compat.border.subMenu.layout = Layout
menu.compat.border.subMenu.render = Render
menu.compat.border.subMenu.style = Style
# Overview
example.compat.border.title = ice:panelBorder - Overview
example.compat.border.description = <p>Observe the organization and structure of the page created with the border layout component. The border layout component allows a developer to easily format a page without existing CSS or table knowledge. Simply define content for the different facets on the page and the border layout will create a common looking page. Each facet can be customized or hidden as needed.</p>
# Layout
example.compat.border.layout.title = ice:panelBorder - Layout Options Example
example.compat.border.layout.description = <p>Customize the layout directly via the "layout" attribute.</p>
# Render
example.compat.border.render.title = ice:panelBorder - Layout Render Example
example.compat.border.render.description = <p>Display or hide individual facets of the layout.</p>
# Style
example.compat.border.style.title = ice:panelBorder - Style Example
example.compat.border.style.description = <p>Customize the style of the border facets.</p>

### ICE - Collapsible
menu.compat.collapsible.title = ice:panelCollapsible
menu.compat.collapsible.subMenu.title = Examples
menu.compat.collapsible.subMenu.main = Overview
menu.compat.collapsible.subMenu.toggle = Toggle on Click
menu.compat.collapsible.subMenu.expanded = Expanded
menu.compat.collapsible.subMenu.event = Event
menu.compat.collapsible.subMenu.immediate = Immediate
menu.compat.collapsible.subMenu.multiple = Multiple
# Overview
example.compat.collapsible.title = ice:panelCollapsible - Overview
example.compat.collapsible.description = <p>The collapsible component provides a simple way to implement the common use case of a rendered/unrendered area on the page. Styling of the header can be customized, as can the label and images used.</p><p>In the example below:</p><ul><li><b>&#187;</b> Click to expand/contract the "ICEfaces Ajax Push" collapsible header.</li></ul>
# Toggle on Click
example.compat.collapsible.toggle.title = ice:panelCollapsible - Toggle on Click Example
example.compat.collapsible.toggle.description = <p>View the effect of the toggleOnClick attribute which will allow the entire header to be clicked or not. </p>
# Expanded
example.compat.collapsible.expanded.title = ice:panelCollapsible - Expansion Control Example
example.compat.collapsible.expanded.description = <p>Control the expanded state from the bean.</p>
# Event
example.compat.collapsible.event.title = ice:panelCollapsible - Event Example
example.compat.collapsible.event.description = <p>Acting on the event fired when the collapsible component is used.</p>
# Multiple
example.compat.collapsible.multiple.title = ice:panelCollapsible - Multiple Components Example
example.compat.collapsible.multiple.description = <p>Demonstration of having multiple collapsible components (with different content) on the same page.</p>

### ICE - Confirmation Panel
menu.compat.confirmation.title = ice:panelConfirmation
menu.compat.confirmation.subMenu.title = Examples
menu.compat.confirmation.subMenu.main = Overview
menu.compat.confirmation.subMenu.label = Labels
menu.compat.confirmation.subMenu.button = Button Type
menu.compat.confirmation.subMenu.display = Display Options
menu.compat.confirmation.subMenu.mouse = Display at Mouse
# Overview
example.compat.confirmation.title = Overview
example.compat.confirmation.description = <p>The confirmation component is useful for prompting a user before completing an action, which is similar to the functionality of an offline desktop application. For example a confirmation component could block a deletion until the user confirms their choice. Implementing the component is simple and done through customized attributes on the tag, so developers don't have to worry about layout or styling.</p><p>In the example below:</p><ul><li><b>&#187;</b> Click "Generate a Random Number", which will display a confirmation component.</li><li><b>&#187;</b> Click "New Number!" at the resulting prompt to generate a new random number.</li></ul>
# Labels
example.compat.confirmation.label.title = ice:panelConfirmation - Labels Example
example.compat.confirmation.label.description = <p>Customize the button labels and popup text. </p>
# Button Type
example.compat.confirmation.button.title = ice:panelConfirmation - Button Type Example
example.compat.confirmation.button.description =<p>Choose the different types of buttons to show on the dialog.</p>
# Display Options
example.compat.confirmation.display.title = ice:panelConfirmation - Display Options Example
example.compat.confirmation.display.description = <p>Customize how the dialog will be displayed.</p>
# Display at Mouse
example.compat.confirmation.mouse.title = ice:panelConfirmation - Display at Mouse Example
example.compat.confirmation.mouse.description =<p>Demonstrate the ability to display the dialog right by the mouse pointer.</p>

### ICE - Divider
menu.compat.divider.title = ice:panelDivider
menu.compat.divider.subMenu.title = Examples
menu.compat.divider.subMenu.main = Overview
menu.compat.divider.subMenu.orientation = Orientation
menu.compat.divider.subMenu.position = Position
menu.compat.divider.subMenu.embedded = Embedded
# Overview
example.compat.divider.title = ice:panelDivider - Overview
example.compat.divider.description = <p>The panel divider component is useful for allowing a user to customize how they want to view a chunk of content. This component is very rich and helps a web application feel more like a traditional desktop application. The divider orientation can be customized, and the split percentage can be controlled from the server if needed. The content of each area is populated by filling two facets with the desired components. Note that the divider component can be embedded within itself, so multiple layered dividers are possible.</p><p>In the example below:</p><ul><li><b>&#187;</b> Click and drag the divider bar between the two areas of content to resize the space they use.</li></ul>
# Orientation
example.compat.divider.orientation.title = ice:panelDivider - Orientation Example
example.compat.divider.orientation.description = View the horizontal or vertical orientation the divider supports.
# Position
example.compat.divider.position.title = ice:panelDivider - Position Example
example.compat.divider.position.description = Customize the position of the divider bar from the bean.
# Embedded
example.compat.divider.embedded.title =  ice:panelDivider - Embedded Example
example.compat.divider.embedded.description = Embed one divider component in the pane of another.

### ICE - Drag and Drop
menu.compat.dragdrop.title = ice:panelGroup (drag&drop)
menu.compat.dragdrop.subMenu.title = Examples
menu.compat.dragdrop.subMenu.main = Overview
menu.compat.dragdrop.subMenu.events = Events
menu.compat.dragdrop.subMenu.effect = Effect
# Overview
example.compat.dragdrop.title = ice:panelGroup (drag&drop) - Overview
example.compat.dragdrop.description = <p>Drag and drop functionality is very useful for unique use cases in rich web applications. Instead of traditional web methods of add/remove buttons, drag and drop can be used instead. Implementing drag and drop is simple for a developers as they can customize what happens during the drag and drop by using provided listeners. Coupling drag and drop with the effect component is an elegant way to help users understand what is going on, as shown here with the orange highlight when an item is hovered over the cart.</p><p>In the example below:</p><ul><li><b>&#187;</b> Click and drag an item from the top list into the white shopping cart area below. This will populate the data table of current items, which simulates a user purchasing something from an online store.</li><li><b>&#187;</b> Click the "Return" button on an item to move it back into the "store" stock.</li></ul>
# Events
example.compat.dragdrop.events.title = ice:panelGroup (drag&drop) - Event Example
example.compat.dragdrop.events.description = <p>View and mask events that drag and drop fires.</p>
# Effect
example.compat.dragdrop.effect.title = ice:panelGroup (drag&drop) - Effects Example
example.compat.dragdrop.effect.description = <p>Optional effect when the drag and drop is complete.</p>

### ICE - Effect
menu.compat.effect.title = ice:panelGroup (Effects)
menu.compat.effect.subMenu.title = Examples
menu.compat.effect.subMenu.main = Overview
# Overview
example.compat.effect.title = ice:panelGroup (Effects) - Overview
example.compat.effect.description = <p>Effects are useful for easily leveraging Javascript without having to worry about the underlying code. Developers can simply add an effect attribute to a panel group and set when to fire the effect.Duration of the effect animation, customization of the colors, location, size, etc. of the effect are also possible. Multiple effects can be chained together to meet any developer needs.</p><p>In the example below:</p><ul><li><b>&#187;</b> Choose an effect from the dropdown, which has all available effects provided by this component.</li><li><b>&#187;</b> Click "Fire Effect" to display the effect on the text in the box below.</li></ul>

### ICE - Popup
menu.compat.popup.title = ice:panelPopup
menu.compat.popup.subMenu.title = Examples
menu.compat.popup.subMenu.main = Overview
menu.compat.popup.subMenu.modal = Modal
menu.compat.popup.subMenu.draggable = Draggable
menu.compat.popup.subMenu.center = Auto Center
menu.compat.popup.subMenu.position = Auto Position
menu.compat.popup.subMenu.client = Client Only
# Overview
example.compat.popup.title = ice:panelPopup - Overview
example.compat.popup.description = <p>The popup component allows a developer to display a modal or non-modal popup that can be dragged, automatically centered, etc.</p><p>This is useful for creating a web application that feels like a traditional desktop application. Critical information or error messages could be displayed in a modal popup, or inline editing could be allowed in a draggable popup that appears over a data table.</p><p>In the example below:</p><ul><li><b>&#187;</b> Click "Toggle Popup" to display a modal popup component with some basic information on it.</li><li><b>&#187;</b> Click the "X" button in the header of the displayed popup to close it.</li></ul>
# Modal
example.compat.popup.modal.title = ice:panelPopup - Modal Example
example.compat.popup.modal.description = <p>Display a modal popup which prevents interacting with the page until the popup is dismissed.</p>
# Draggable
example.compat.popup.draggable.title = ice:panelPopup - Draggable Example
example.compat.popup.draggable.description = <p>Display a draggable popup that can be moved around the page.</p>
# Auto Center
example.compat.popup.center.title = ice:panelPopup - Auto Center Example
example.compat.popup.center.description = <p>Automatically center the popup when it is displayed and also when the browser is scrolled.</p>
# Auto Position
example.compat.popup.position.title = ice:panelPopup - Auto Position Example
example.compat.popup.position.description = <p>Automatically position the popup at a set X,Y coordinate and maintain that position through browser scrolling.</p>
# Client Only
example.compat.popup.client.title = ice:panelPopup - Client Only Example
example.compat.popup.client.description = <p>Prevent the draggable popup from sending an event to the server when it is dropped.</p>

### ICE - Positioned Panel
menu.compat.positioned.title = ice:panelPositioned
menu.compat.positioned.subMenu.title = Examples
menu.compat.positioned.subMenu.main = Overview
menu.compat.positioned.subMenu.constraint = Constraint
menu.compat.positioned.subMenu.listener = Listener
menu.compat.positioned.subMenu.dynamic = Dynamic
menu.compat.positioned.subMenu.sort = Sorting
menu.compat.positioned.subMenu.style = Style
# Overview
example.compat.positioned.title = ice:panelPositioned - Overview
example.compat.positioned.description = <p>The panel positioned component allows a list to be displayed and re-ordered on the page. The orientation and constraint of the re-ordering can be customized by the developer. If needed listeners can be used to determine when an item is re-ordered.</p><p>In the example below:</p><ul><li><b>&#187;</b>Click and drag one of the food items below to re-order the item in the panel positioned component. </li></ul>
# Constraint
example.compat.positioned.constraint.title = ice:panelPositioned - Constraint Example
example.compat.positioned.constraint.description = <p>Constrain how the re-ordering is displayed and handled.</p>
# Listener
example.compat.positioned.listener.title = ice:panelPositioned - Listener Example
example.compat.positioned.listener.description = <p>Listen to an event that fires when an item is re-ordered.</p>
# Dynamic
example.compat.positioned.dynamic.title =  ice:panelPositioned - Dynamic Example
example.compat.positioned.dynamic.description = <p>Dynamically add or remove items from the positioned list.</p>
# Sort
example.compat.positioned.sort.title =  ice:panelPositioned - Sorting Example
example.compat.positioned.sort.description = <p>Automatically sort the positioned list items.</p>
# Style
example.compat.positioned.style.title =  ice:panelPositioned - Style Example
example.compat.positioned.style.description = <p>Customize the style of each panel element using varStatus.</p>

### ICE - Series Panel
menu.compat.series.title = ice:panelSeries
menu.compat.series.subMenu.title = Examples
menu.compat.series.subMenu.main = Overview
menu.compat.series.subMenu.dynamic = Dynamic
menu.compat.series.subMenu.rows = Rows
menu.compat.series.subMenu.first = Start From
menu.compat.series.subMenu.content = Custom Content
menu.compat.series.subMenu.style = Style
# Overview
example.compat.series.title = ice:panelSeries - Overview
example.compat.series.description = <p>The panel series component is an iterator that allows a developer to display an arbitrary list of data, similar to a data table (but without requiring an underlying HTML table).</p><p>Data can dynamically be added or removed to the list on the server and the changes will be reflected in the panel series. Also the style, displayed rows, etc. can be customized for the component.</p>
# Dynamic
example.compat.series.dynamic.title = ice:panelSeries - Dynamic Example
example.compat.series.dynamic.description = <p>Add or remove items from the panel series component.</p>
# Rows
example.compat.series.rows.title = ice:panelSeries - Rows Example
example.compat.series.rows.description = <p>Set the number of rows to display at once with the panel series component.</p>
# Start From
example.compat.series.first.title = ice:panelSeries - Start From Example
example.compat.series.first.description = Set what index to start the panel series rendering from with the first attribute.</p>
# Custom Content
example.compat.series.content.title = ice:panelSeries - Custom Content Example
example.compat.series.content.description = <p>Customize the content to be used in the panel series component.</p>
# Style
example.compat.series.style.title = ice:panelSeries - Style Example
example.compat.series.style.description = <p>Style the panel series children via the varStatus attribute.</p><p>In the example below every second Employee will have a red header using inline styling and EL on the varStatus attribute.</p>

### ICE - Stacking Panel
menu.compat.stacking.title = ice:panelStack
menu.compat.stacking.subMenu.title = Examples
menu.compat.stacking.subMenu.main = Overview
# Overview
example.compat.stacking.title = ice:panelStack - Overview
example.compat.stacking.description = <p>The stacking panel component is used to display a single item from a "stack" of available pieces of content. This is similar to tabs, where only a single piece of content is displayed at once.</p><p>In the example below:</p><ul><li><b>&#187;</b> Choose a selected panel from the radio buttons below, and observe the changed image and text description</li></ul>

### ICE - Tab Pane
menu.compat.tab.title = ice:panelTabSet
menu.compat.tab.subMenu.title = Examples
menu.compat.tab.subMenu.main = Overview
menu.compat.tab.subMenu.placement = Placement
menu.compat.tab.subMenu.icon = Icons
menu.compat.tab.subMenu.label = Labels
menu.compat.tab.subMenu.wrapping = Text Wrapping
menu.compat.tab.subMenu.visibility = Visibility
menu.compat.tab.subMenu.control = Backend Control
menu.compat.tab.subMenu.events = Events
menu.compat.tab.subMenu.dynamic = Dynamic
# Overview
example.compat.tab.title = ice:panelTabSet - Overview
example.compat.tab.description = <p>The tab component is commonly used for separating and laying out data. Each tab can have arbitrary content defined by the developer.The label, icon, style, layout, etc. of the tabs can be customized.</p><p>In the example below:</p><ul><li><b>&#187;</b> Click the different tabs (Account, Support, Forum) below to display their associated content.</li></ul>
# Position
example.compat.tab.placement.title = ice:panelTabSet - Tab Placement Example
example.compat.tab.placement.description =<p>Customize where the tabs will display on the container.</p>
# Icons
example.compat.tab.icon.title = ice:panelTabSet - Tab Icons Example
example.compat.tab.icon.description = <p>Add icons to the tab component.</p>
# Labels
example.compat.tab.label.title = ice:panelTabSet - Tab Labels Example
example.compat.tab.label.description = <p>Customize the tab labels and method of rendering.</p>
# Text Wrapping
example.compat.tab.wrapping.title = ice:panelTabSet - Tab Text Wrapping Example
example.compat.tab.wrapping.description = <p>View the effect of label text wrapping.</p>
# Visibility
example.compat.tab.visibility.title = ice:panelTabSet - Tab Visibility Example
example.compat.tab.visibility.description = <p>Hide or display each individual tab.</p>
# Backend Control
example.compat.tab.control.title = ice:panelTabSet - Backend Control Example
example.compat.tab.control.description = <p>Control the selected tab from the backing bean.</p>
# Events
example.compat.tab.events.title = ice:panelTabSet - Events Example
example.compat.tab.events.description = <p>Listener that fires when the tab is changed.</p>
# Dynamic
example.compat.tab.dynamic.title = ice:panelTabSet - Dynamic Tabs Example
example.compat.tab.dynamic.description = <p>Dynamically add and remove tabs.</p>

### ICE - Tooltip
menu.compat.tooltip.title = ice:panelTooltip
menu.compat.tooltip.subMenu.title = Examples
menu.compat.tooltip.subMenu.main = Overview
menu.compat.tooltip.subMenu.display = Display Type
menu.compat.tooltip.subMenu.hide = Hide Type
menu.compat.tooltip.subMenu.draggable = Draggable
menu.compat.tooltip.subMenu.delay = Hover Delay
menu.compat.tooltip.subMenu.move = Move with Mouse
menu.compat.tooltip.subMenu.preview = Website Previews
# Overview
example.compat.tooltip.title = ice:panelTooltip - Overview
example.compat.tooltip.description = <p>The panel tooltip component is useful for displaying rich tooltips that can contain any other component, such as plain text, images, even calendars or data tables. Customizing how the tooltip is displayed (hover, click, etc.) can be done by the developer. A common usage would be website previews when a link is hovered over, or definitions of words in a scientific paper.</p><p>In the example below:</p><ul><li><b>&#187;</b> Mouse over each highlighted word below to see additional information on the topic displayed using a panel tooltip component.</li></ul>
# Display On
example.compat.tooltip.display.title = ice:panelTooltip - Display On Example
example.compat.tooltip.display.description = <p>Simple example demonstrating the different ways the tooltip can be displayed.<p>
# Hide On
example.compat.tooltip.hide.title = ice:panelTooltip - Hide On Example
example.compat.tooltip.hide.description = <p>Simple example demonstrating the different ways the tooltip can be hidden.<p>
# Draggable
example.compat.tooltip.draggable.title = ice:panelTooltip - Draggable Example
example.compat.tooltip.draggable.description = <p>Allow the tooltip to be dragged or not.<p>
# Hover Delay
example.compat.tooltip.delay.title = ice:panelTooltip - Hover Delay Example
example.compat.tooltip.delay.description = <p>Customize the delay before displaying the tooltip on hover.<p>
# Move with Mouse
example.compat.tooltip.move.title = ice:panelTooltip - Move with Mouse Example
example.compat.tooltip.move.description = <p>Toggle the tooltip moving with the mouse or not. Click on a link to display the tooltip, and click again anywhere to close the current tooltip.<p>
# Website Previews
example.compat.tooltip.preview.title = ice:panelTooltip - Website Previews Example
example.compat.tooltip.preview.description = <p>Example of hover previews on links.<p>

### ICE - Data Table (Row Selector)
menu.compat.selector.title = ice:rowSelector
menu.compat.selector.subMenu.title = Examples
menu.compat.selector.subMenu.main = Overview
menu.compat.selector.subMenu.type = Type
menu.compat.selector.subMenu.events = Events
menu.compat.selector.subMenu.toggle = Toggle on Input
menu.compat.selector.subMenu.pre = Pre-Style
# Overview
example.compat.selector.title = ice:rowSelector - Overview
example.compat.selector.description = <p>The data table row selector is used to select individual or multiple rows in a data table. A developer can manage what rows have been selected and act upon them, such as deleting all selected rows, editing an individual row, etc. The color styling can be customized so that mousing over selected or deselected rows will display to the user and clicked rows are easy to see.</p><p>In the example below:</p><ul><li><b>&#187;</b> Click a row in the data table to select it.</li><li><b>&#187;</b> Hold the Shift key and click multiple rows to select more than one row.</li></ul>
# Type
example.compat.selector.type.title = ice:rowSelector - Type Example
example.compat.selector.type.description = <p>Customize the type of row selector.<p>
# Events
example.compat.selector.events.title = ice:rowSelector - Events Example
example.compat.selector.events.description = <p>View the row selector events that can be fired and listened to.<p>
# Toggle on Input
example.compat.selector.toggle.title = ice:rowSelector - Toggle on Input Example
example.compat.selector.toggle.description = <p>Choose whether the selection should toggle when a button or input field in the row is interacted with.<p>
# Pre-Style on Selection
example.compat.selector.pre.title = ice:rowSelector - Pre-Style Example
example.compat.selector.pre.description = <p>Pre-style the CSS for the row selection immediately on the client instead of waiting for the server.<p>

### ICE - Calendar
menu.compat.calendar.title = ice:selectInputDate
menu.compat.calendar.subMenu.title = Examples
menu.compat.calendar.subMenu.main = Overview
menu.compat.calendar.subMenu.popup = Popup
menu.compat.calendar.subMenu.pattern = Converter Pattern
menu.compat.calendar.subMenu.timezone = Timezones
menu.compat.calendar.subMenu.highlight = Date Highlighting
# Overview
example.compat.calendar.title = ice:selectInputDate - Overview
example.compat.calendar.description = <p>The calendar component allows users to easily visualize and select a date, without having to worry about formatting. The display can either be inline or visible only when a button is explicitly clicked. How the month and year are displayed can also be customized. The component supports highlighting individual days or weeks can be useful to display relevant information for those dates.</p><p>In the example below:</p><ul><li><b>&#187;</b> Select a date by clicking on a number in the calendar.</li></ul>
# Popup
example.compat.calendar.popup.title = ice:selectInputDate - Popup Example
example.compat.calendar.popup.description = <p>Configure the calendar popup appearance.</p>
# Pattern
example.compat.calendar.pattern.title = ice:selectInputDate - Converter Pattern Example
example.compat.calendar.pattern.description = <p>Demonstration of custom date patterns and how they apply to the calendar.</p>
# Timezone
example.compat.calendar.timezone.title = ice:selectInputDate - Timezones Example
example.compat.calendar.timezone.description = <p>Choose a different timezone to see how it applies to the calendar.</p>
# Highlight
example.compat.calendar.highlight.title = ice:selectInputDate - Date Highlighting Example
example.compat.calendar.highlight.description = <p>Highlight specific days or weeks with the calendar.</p>

### ICE - Auto Complete
menu.compat.autocomplete.title =  ice:selectInputText
menu.compat.autocomplete.subMenu.title = Examples
menu.compat.autocomplete.subMenu.main = Overview
menu.compat.autocomplete.subMenu.simple = Simple
menu.compat.autocomplete.subMenu.complex = Complex
menu.compat.autocomplete.subMenu.rows = Rows
# Overview
example.compat.autocomplete.title = ice:selectInputText - Overview
example.compat.autocomplete.description = <p>Start typing a City into the provided input field. As you type a list of available city options will be filtered and displayed. Navigation of this menu can be done using the keyboard arrows or the mouse. Selecting a city will automatically submit it to the server, or further typing can be done to reduce the filtered results further.The "Current Results" field displays how many cities match the currently typed text, and will narrow accordingly. If no matches are found the filter will reset to check the first letter only.From a developer perspective the filtering of autocomplete results is done in the backend, which allows greater customization of how to match. The displayed options can be customized to use a richer appearance of any complex components, instead of just plain text.</p>
# Simple
example.compat.autocomplete.simple.title = ice:selectInputText - Basic Example
example.compat.autocomplete.simple.description = <p>Simple example of the Auto Complete component.</p>
# Complex
example.compat.autocomplete.complex.title = ice:selectInputText - Advanced Example
example.compat.autocomplete.complex.description = <p>Complex example showing advanced formatting of the selectable items.</p>
# Rows
example.compat.autocomplete.rows.title = ice:selectInputText - Rows Example
example.compat.autocomplete.rows.description = <p>Customize the appearance of the Auto Complete component by modifying the number of displayed rows.</p>

### ICE - Set Event Phase
menu.compat.eventphase.title = ice:setEventPhase
menu.compat.eventphase.subMenu.title = Examples
menu.compat.eventphase.subMenu.main = Overview
menu.compat.eventphase.subMenu.change = Value Change Event
menu.compat.eventphase.subMenu.action = Action Event
# Overview
example.compat.eventphase.title = ice:setEventPhase - Overview
example.compat.eventphase.description = <p>In the example below:</p><ul><li><b>&#187;</b> Choose a Province and click Submit.</li></ul><p>If setEventPhase is enabled, the capital City of the selected Province will automatically be set through a valueChangeListener that fires later in the JSF lifecycle because of setEventPhase. However if setEventPhase is not enabled, the City will not be updated in the view. This is because the valueChangeListener fires earlier in the JSF lifecycle, and the City it sets is overwritten by the currently selected City on the page. This process will work the same if a City is selected and Submit is clicked, except a matching Province will try to be set.</p>
# Value Change Event
example.compat.eventphase.change.title = ice:setEventPhase - Value Change Event Example
example.compat.eventphase.change.description = <p>This example demonstrates firing a valueChangeListener in a later phase through the setEventPhase. This allows us to modify a bean value without the value being overwritten in a later phase, as normally happens in the early firing of valueChangeListeners.</p> <p>In the example below:</p><ul><li><b>&#187;</b> Check "Choose Random Number" to true. Then press "Submit".</li><li>In the Event Log you can see a number was generated and set through a valueChangeListener. However the number was then overwritten by the rest of the lifecycle where the value in the inputText field was set into the bean.</li><li><b>&#187;</b> Check "Enable Set Event Phase" to true and press "Apply". Uncheck "Choose Random Number" and press "Submit".</li><li>Since setEventPhase has been enabled, we can try the use case again and see the difference.</li><li><b>&#187;</b> Check "Choose Random Number" to true. Then press "Submit".</li><li>In the Event Log you will now see that the normal lifecycle set applying the value in the inputText field to the bean. And then the valueChangeListener fires, since it was moved to a later lifecycle phase thanks to setEventPhase. Now when the new random number is generated and set it isn't overwritten, and appears on the page as expected.</li></ul>
# Action Event
example.compat.eventphase.action.title = ice:setEventPhase - Action Event Example
example.compat.eventphase.action.description = <p>This example demonstrates using setEventPhase to force an actionListener to fire earlier in the lifecycle, before validation occurs. This creates an effect similar to the immediate="true" attribute.</p><p>In the example below:</p><ul><li><b>&#187;</b> Leave the inputText field blank and press the "Normal Action" button.</li><li>You will notice the validation fires as the normal JSF lifecycle is being completed.</li><li><b>&#187;</b> Leave the inputText field blank and press the "Set Event Phase Action" button.</li><li>In the Event Log you will see that the actionListener method was reached in the bean and no validation fired. This is because setEventPhase has moved that actionListener from the end of the lifecycle to the start, before validation fires. It is similar to adding the immediate="true" attribute to a component, but allows greater customization.</li><li><b>&#187;</b> Uncheck "Enable Set Event Phase" and press "Apply".</li><li><b>&#187;</b> Leave the inputText field blank and press the "Set Event Phase Action" button.</li><li>You can see that without setEventPhase the button is the same as "Normal Action" and will fire validation which blocks the actionListener from executing.</li></ul>

### ICE - Tree
menu.compat.tree.title = ice:tree
menu.compat.tree.subMenu.title = Examples
menu.compat.tree.subMenu.main = Overview
menu.compat.tree.subMenu.events = Events
menu.compat.tree.subMenu.icons = Custom Icons
menu.compat.tree.subMenu.navigation = Hide Navigation
menu.compat.tree.subMenu.root = Hide Root Node
menu.compat.tree.subMenu.dynamic = Dynamic
# Overview
example.compat.tree.title = ice:tree - Overview
example.compat.tree.description = <p>The tree component is used for displaying parent-child data in a hierarchical fashion. This style of display is common in businesses as a wide variety of data can be managed while users can still easily understand the layout. The text and icon of each node and leaf can be customized as needed, as can many attributes of the tree itself. This component is built on top of the Swing JTree, so developers familiar with that node approach will see similarities in the tree component.</p><p>In the example below:</p><ul><li><b>&#187;</b> Expand and contract the different nodes in the tree.</li><li><b>&#187;</b> Click the "Regenerate" button to randomly create a new set of data for the tree.</li></ul>
# Events
example.compat.tree.events.title = ice:tree - Events Example
example.compat.tree.events.description = <p>Demonstration of the different events the tree can fire.</p>
# Custom Icons
example.compat.tree.icons.title = ice:tree - Custom Icons Example
example.compat.tree.icons.description = <p>Custom image icons for the tree nodes and leafs.</p><p>In the example below, custom folder and leaf icons to simulate camera images being organized in a tree. They can also be set inline on the page, or directly in the backing bean.</p>
# Hide Navigation
example.compat.tree.navigation.title = ice:tree - Hide Navigation Example
example.compat.tree.navigation.description = <p>Allow the navigation links to be hidden.</p>
# Hide Root Node
example.compat.tree.root.title = ice:tree - Hide Root Note Example
example.compat.tree.root.description = <p>Toggle the visibility of the root node.</p>
# Dynamic
example.compat.tree.dynamic.title = ice:tree - Dynamic Example
example.compat.tree.dynamic.description = <p>Add and remove nodes from the tree component.</p>

### ICE - Graphic Image
menu.compat.graphicimage.title = ice:graphicImage
menu.compat.graphicimage.subMenu.title = Examples
menu.compat.graphicimage.subMenu.main = Overview
# Overview
example.compat.graphicimage.title = ice:graphicImage - Overview
example.compat.graphicimage.description = <p>The ice:graphicImage component allows developers to display dynamic images in their applications, which is useful when an image has to change depending on the state of the application and/or session. The basic h:graphicImage component is extended in ICEfaces to support additional ways to display an image, other than specifying its URL. In this demo, the two images below are loaded by different means. The first one is loaded via a Resource object, and the second one is loaded with the data of a byte array in the backing bean.</p>

### EE - Filler Properties
### EE - Table
menu.ee.table.title = Table Components
### EE - Layout
menu.ee.layout.title = Layout Components
### EE - Selection
menu.ee.selection.title = Selection Components
### EE - Tree
menu.ee.tree.title = Tree Components
### EE - Process
menu.ee.process.title = Process Components
### EE - Status Bar
menu.ee.statusbar.title = Status Bar
### EE - Slideshow
menu.ee.slideshow.title = Slide Show
### EE - Schedule
menu.ee.schedule.title = Schedule

### tableConfig crash
ice.config.id = ID Prop
ice.config.name = Name Prop
ice.config.chassis = Chassis Prop