Items

Items are the building blocks of WebViewer Modular UI. They are components that are placed inside containers. They include buttons and prebuilt components such as the page controls and zoom controls. All items inherit properties from the same base class and can be modified in similar ways. They can also be placed in different containers to make them easier to manage and reuse.

There are many different items in the default UI which include Toggle Buttons, Tool Buttons, Ribbon Items, View Controls, Zoom Controls, and Page Controls among others.

Items are also highly customizable. For example, a button can have a label or an icon or even both depending on the properties set.

Custom buttons, also referred to as Action Buttons, allow you to specify the icon, title, and onClick behaviour. These can include any kind of function call, such as posting data to a server.

1const testButton = new instance.UI.Components.CustomButton({
2  dataElement: 'customButton',
3  label: 'test',
4  title: 'this is a test button',
5  onClick: () => console.log('button clicked!'),
6  img: 'icon-save',
7});
8
9// This can now be added to a modular header
10const defaultHeader = instance.UI.getModularHeader('default-top-header')
11defaultHeader.setItems([...defaultHeader.items, testButton]);

The code above creates a custom button which will look like this:

Stateful buttons are buttons that can have state within them. These are generally used for tools or viewing modes, where we want to change the style of the button depending on the state (e.g. active tool vs not active).

1const statefulButton = new instance.UI.Components.StatefulButton({
2  initialState: 'SinglePage',
3  states: {
4    SinglePage: {
5      img: 'icon-header-page-manipulation-page-layout-single-page-line',
6      onClick: (update) => {
7        update('DoublePage');
8      },
9      title: 'Single Page',
10    },
11    DoublePage: {
12      img: 'icon-header-page-manipulation-page-layout-double-page-line',
13      onClick: (update) => {
14        update('SinglePage');
15      },
16      title: 'Double Page',
17    },
18  },
19  // Mount is a function that gets called when the button is mounted
20  // use it to set the initial state or do other setup
21  mount: () => {},
22  // Unmount is a function that gets called when the button is unmounted
23  // use it to clean up any resources
24  unmount: () => {},
25});
26
27// This can now be added to a modular header
28const defaultHeader = instance.UI.getModularHeader('default-top-header')
29defaultHeader.setItems([statefulButton]);

The code above creates a stateful button which toggles between Single Page and Double Page states and will look like this:

Toggle Element Buttons, also known as Toggle Buttons, are buttons that can be used toggle specified elements on and off in the UI. These are generally used for opening panels, such as the Notes Panel or the Thumbnails Panel, or for activating special modes such as Form Field Editing Mode or Content Editing Mode.

1const toggleButton = new instance.UI.Components.ToggleElementButton({
2  label: 'Toggle',
3  title: 'Toggle the visibility of the element',
4  toggleElement: 'dataElementToToggle',
5});
6
7// This can now be added to a modular header
8const defaultHeader = instance.UI.getModularHeader('default-top-header')
9defaultHeader.setItems([toggleButton]);

One of the most common use cases for this type of button is to toggle the visibility of the Style Panel like so:

Tool Buttons are buttons that are used to activate a specific tool.

In the Modular UI they are abstractions that can be used to easily add a tool button anywhere in the UI as shown in the example below:

1const { Tools } = instance.Core;
2const rectangleToolButton = new instance.UI.Components.ToolButton({
3  dataElement: 'rectangleToolButton',
4  toolName: Tools.ToolNames.RECTANGLE,
5});
6
7// This can now be added to a modular header
8const defaultHeader = instance.UI.getModularHeader('default-top-header')
9defaultHeader.setItems([rectangleToolButton]);

Tool buttons can also be customized by passing in a custom img, label, or title.

See api guide for list of available tool names that can be used with Tool Buttons.

Ribbon Items are a special type of item that are used within a Ribbon Group to create a ribbon. They are used to set which Grouped Items should appear in the secondary header in the default UI.

For a full code samples of adding ribbon items to the UI, see the Ribbon Group documentation.

The Modular UI features a variety of prebuilt items designed to streamline the integration of commonly used viewer functionalities. These components allow for easy placement anywhere within the viewer, eliminating the need to recreate their internal logic. Among these are the Preset Items, which are buttons engineered to handle frequent actions such as downloading documents and initiating print options. Additionally, the prebuilt items include Page Controls, Zoom Controls, and View Controls. These render components that manage the viewer's state, enabling settings adjustments for the current page, zoom level, and page orientation.

Preset buttons are buttons that are already defined in the default UI. These include buttons such as the Save Button, Print Button, and Download Button. These buttons are generally used to perform actions on the document or toggle different modes like Content Edit Mode or Form Field Creation Mode.

You can find a full list of the available preset buttons in the PresetButton class documentation.

The following code creates a new Preset Save Button:

1const saveAsButton = new instance.UI.Components.PresetButton({
2  buttonType: 'saveAsButton',
3  dataElement: 'presetButton-save'
4});
5
6// This can now be added to a modular header
7const defaultHeader = instance.UI.getModularHeader('default-top-header')
8defaultHeader.setItems([saveAsButton]);

Page Controls are used to navigate through the pages of a document. They include a page number input which shows the current page along with the total pages and buttons to move to the previous page and the next page in the document.

Page controls can be placed inside of containers and can be customized to fit the needs of your application.

The following code creates a new Page Controls item:

1const pageControls = new instance.UI.Components.PageControls();
2
3// This can now be added to a modular header
4const defaultHeader = instance.UI.getModularHeader('default-top-header')
5defaultHeader.setItems([pageControls]);

View Controls in WebViewer let you adjust the display settings of a document. These settings include options to change how you navigate through the document (like scrolling continuously or flipping page by page), rotate the document, choose the document layout (such as viewing one page at a time or two pages side-by-side), and a button to view the document in full screen.

This component gets added to the UI as a toggle button which can be used to show or hide the View Controls Flyout Menu.

The following code creates a new View Controls item:

1const viewControls = new instance.UI.Components.ViewControls();
2
3// This can now be added to a modular header
4const defaultHeader = instance.UI.getModularHeader('default-top-header')
5defaultHeader.setItems([viewControls]);

The Zoom component is used to change the zoom level of the document. It includes buttons to zoom in and zoom out, and an input field to manually change the zoom level. There is also a dropdown button which opens a Zoom Flyout Menu which contains a list of preset zoom levels as well as Fit To Width and Fit To Page buttons and a button to activate marquee zooming (changing the zoom level by clicking or cmd/ctrl+clicking).

The following code creates a new Zoom item:

1const zoom = new instance.UI.Components.Zoom();
2
3// This can now be added to a modular header
4const defaultHeader = instance.UI.getModularHeader('default-top-header')
5defaultHeader.setItems([zoom]);