Posted on {{ post.date | date: "%-d %B %Y" }}
-- {{ post.abstract }} -
- {% if post.photoname %} -Posted on {{ post.date | date: "%-d %B %Y" }}
-- {{ post.abstract }} -
- {% if post.photoname %} -Loading search results...
-A CSV or Excel file failed to be created in Viz.exportCrosstabAsync().
-A CSV file failed to be created in Viz.exportDataAsync().
-Property or Function is not supported within the Tableau API.
-An error occurred within the Tableau API. Contact Tableau Support.
-An invalid aggregation was specified for the filter, such as setting a range filter to "SUM(Sales)" instead of - "Sales".
-A filter operation was attempted on a field that does not exist in the data source.
-A filter operation was attempted using a value that is the wrong data type or format.
-A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message field.
-An invalid date value was specified in a Sheet.selectMarksAsync() call for a date field.
-A field was specified in a Sheet.selectMarksAsync() call that does not exist in the data source.
-A parameter did not include a valid sheet selection for exporting.
-An invalid value was specified in a Sheet.selectMarksAsync() call.
-An operation was attempted on a sheet that is not active or embedded within the active dashboard.
-A PDF file failed to be created in Viz.exportPDFAsync().
-A PowerPoint file failed to be created in Viz.exportPowerPointAsync().
-A general-purpose server error occurred. Details are contained in the Error object.
-Can occur when an api call times out.
-Enum that represents the changes that occur to a dashboard object.
-A dashboard object was added
-Navigate to another dashboard
-A dashboard object is deselected
-A dashboard object's floating state changed
-A dashboard object's visibility changed
-A dashboard object was renamed
-A dashboard object's position changed
-A dashboard object was removed
-A dashboard object is selected
-A dashboard object's size changed
-What the object represents in a dashboard.
-All error codes used by the Extensions API.
-Thrown when caller attempts to execute command before initialization has completed.
-Only one dialog can be opened at time with the UI namespace functionality.
-The open dialog was closed by the user.
-An error occurred within the Tableau Extensions API. Contact Tableau Support.
-A dialog must start on the same domain as the parent extenion.
-A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message field.
-Can occur if the extension interacts with a filter that has been removed from the worksheet.
-Can occur if the extension interacts with a parameter that has been removed from the worksheet.
-Internal Server Error
-Developer cannot save settings while another save is still in progress.
-An unknown event name was specified in the call to addEventListener or removeEventListener.
A method was used for a type of data source that doesn't support that method (see getActiveTablesAsync for an example)
-Thrown when caller attempts to execute command while extension is not visible.
-Type of aggregation on a field.
-The domain type for a filter
-list of all possible domain values from database
-The domain values that are relevant to the specified filter - i.e. the domain is restricted by a previous filter
-The option for specifying which values to include for filtering - Indicates what to do with null values for a given filter or mark selection call.
-An enumeration of the valid types of filters that can be applied.
-Enum that represents the selection state of a level in a hierarchical filter
-Enum that serves as a filter on the DataValues returned from getSummaryDataReaderAsync,
- getUnderlyingTableDataReaderAsync and getLogicalTableDataReaderAsync.
- This is an optimization of returned data values only. Tableau versions prior to 2021.2
- will pass the data across and populate the DataValue properties.
- Please note that all properties not requested will be undefined in the DataValue results.
DataValues will include all properties.
-DataValues will only include formattedValue properties.
-DataValues will only include value and nativeValue properties.
-Type of mark for a given marks card in a viz.
-Enum that represents the replay speed of an animation.
-Used for setting the replay speed of an animation to 2.0x.
-Used for setting the replay speed of an animation to 1.0x.
-Used for setting the replay speed of an animation to 0.5x.
-Enum for specifying the select option for the extensions.Worksheet.selectTuplesAsync method.
Clears existing selection before selecting the tuples specified
-Adds specified tuples to the existing selection
-Represents the type of event that can be listened for.
-Raised when any filter has changed state. You can use this event type with Worksheet objects.
-The selected marks on a visualization has changed. - You can use this event type with Worksheet objects.
-A parameter has had its value modified. You can use this event type with Parameter objects.
-Settings have been changed for this extension. You can use this event type with Settings objects.
-The summary data backing a worksheet has changed - You can use this event type with Worksheet objects.
-The dashboard layout has changed
-The workbook formatting has changed
-Enum that represents the data type of encodings for createVizImageAsync.
-Enum that represents the sort direction for createVizImageAsync.
-Categorical values for selection.
-Callback function which will be invoked when an event notification is emitted.
-Function which can be invoked to remove an event handler registration. This will be - returned when registering an event and makes unregistering simpler.
-Map object that is used for the DashboardLayoutChangedEvent.
-Array object that can be passed into moveAndResizeDashboardObjects.
-Map object that can be passed into setDashboardObjectVisibilityAsync.
-Map object that can be passed into setZoneVisibilityAsync.
-The Tableau Extensions API is a JavaScript library that is organized into namespaces that contain - the classes and methods for communicating with Tableau components. The Tableau Extensions API - library supports both dashboard extensions and viz extensions (only available in beta), although not - all interfaces and methods apply to both extensions. For an overview of how the API is organized, - see Tableau Extensions API Basics.
-| Namespace | -Description | -
|---|---|
| Tableau | -The top-level or global namespace is the tableau namespace, which has no constructs, but contains the extensions namespace. You use the tableau namespace to access the extensions. For example, you call tableau.extensions.initializeAsync() to initialize the API. |
-
| Extensions | -The extensions namespace is the namespace for Tableau extensions. A dashboard extension is one type of extension. A dashboard extension has access to the dashboardContent namespace, and all of the objects and classes of the dashboard. Some namespaces, like the settings, environment, and ui are available to all extensions. |
-
| DashboardContent | -(Available to dashboard extensions only) The dashboardContent provides access to the dashboard object. When you have the dashboard object, you have access to all elements in the dashboard, including the worksheets, marks, filters, parameters, and data sources. For example, to access the worksheets in a dashboard (after initialization), you might have a line of code that looks like the following: const worksheets = tableau.extensions.dashboardContent.dashboard.worksheets |
-
| WorksheetContent | -(Available to viz extensions beta only) The worksheetContent provides access to the worksheet object. When you have the worksheet object, you have access to all elements in the worksheet, including the worksheets, marks, filters, parameters, and data sources. For example, to access the worksheet in a workbook (after initialization), you might have a line of code that looks like the following: const worksheet = tableau.extensions.worksheetContent |
-
| Settings | -The settings namespace provides methods to get and set values which will be persisted in a workbook. You can use the settings to configure an extension. |
-
| Environment | -The environment namespace provides methods to programmatically gather information about the environment in which the extension is running. |
-
| UI | -The ui namespace provides methods for an extension to display a popup dialog window. |
-
The following diagram shows the relationship between the extensions namespace and the worksheets in - the dashboard. For more information, see Tableau Extensions API Basics.
-
The following diagram shows the relationship between the extensions namespace and the worksheets in - the workbook. For more information, see Tableau Extensions API Basics.
-
Represents an annotation in a worksheet.
-A Categorical Filter
-the list of worksheet names that have the filter applied.
-a promise containing the categorical domain for the filter. Note if a filter contains - multiple fields (such as a filter action with multiple fields), the values array in the returned - CategoricalDomain (CategoricalDomain.values) will be empty. If there are multiple fields - in the filter, the results need to be represented by a table, which is not currently supported.
-a promise containing the field for the filter.
-Applies the filter to the specified list of worksheets. - If the worksheet(s) do not exist or do not contain the field in their data sources, an exception is thrown.
-list of worksheets to apply the filter on
-the list of worksheet names that have the filter applied
-Represents a connection within a datasource (ex: A SQL Server connection). - A data source can be composed of one or more connections.
-The Dashboard interface inherits from the Sheet interface.
This is a helper method and is equivalent to looping
- through all of the objects in a dashboard and collecting all of the objects
- whose type is worksheet. You can use this property to iterate
- through all of the worksheets in the dashboard.
Adds a new event listener to the object. If this object does not support the specified eventType,
- the method throws an exception.
- The following table shows the event types supported by objects.
| object | -eventType | -
|---|---|
| Worksheet | -FilterChanged , MarkSelectionChanged, SummaryDataChanged |
-
| Parameter | -ParameterChanged |
-
| Settings | -SettingsChanged |
-
| Dashboard | -DashboardLayoutChanged, WorkbookFormattingChanged |
-
The type of event to register for. The type of event is a TableauEventType enumeration.
The function which will be called when an event happens.
-A helper function which can be called to remove this registration.
-The following example sets up a listener in a worksheet for a mark selection event (MarkSelectionChanged).
- When the event occurs, the data is reloaded. The addEventListener method returns a function that un-registers
- the event handler. Call that function, in this case, unregisterEventHandlerFunction() to remove the registration.
// Add an event listener for the selection changed event on this sheet.
-// Assigning the event to a variable just to make the example fit on the page here.
-const markSelection = tableau.TableauEventType.MarkSelectionChanged;
-//
-unregisterEventHandlerFunction = worksheet.addEventListener(markSelection, function (selectionEvent) {
-// When the selection changes, reload the data
-loadSelectedMarks(worksheetName);
-});
-
-// remove the event listener when done
- unregisterEventHandlerFunction();
-Applies a simple categorical filter (non-date) to the dashboard. - This method is similar to the method used for worksheets, but applies the filter to all the worksheets in the dashboard that have that same field. - Note that the filter is ignored by a worksheet if the worksheet doesn't have the relevant field in its data source.
-The name of the field to filter on.
-The list of values to filter on.
-The update type of this filter (add, all, remove, replace).
-Advanced filter options (isExcludeMode).
-The field name that the filter is applied on.
-Searches for a parameter with the given name.
-The name of the parameter to find.
-The parameter with the given name, or undefined if it does not exist.
-Gets the specified dashboard object by its id. If a dashboard object is not found this method returns undefined.
-The id of an object on the dashboard.
-The dashboard object with that id. Returns undefined if the dashboard object is not found.
-The collection of filters used on the dashboard
-A collection of all the Tableau parameters that are used in this workbook.
-Sets the position and size of one or more floating dashboard objects. - Throws an error if the dashboard object is invalid
-Empty promise that resolves when the position and size of the dashboard objects have been changed.
-Removes an event listener if a matching one is found. If no matching listener exists, the method does nothing.
- The handler function must the handler function specified in the call to the addEventListener method. Alternatively, use the function
- returned from the call to addEventListener to unregister the event listener.
- For more information, see Events and Event Handling.
Whether or not an event listener was removed.
-Replays an animation for the active sheet - Throws an error if the replay speed is invalid
-Empty promise that resolves when the animation has been replayed.
-Sets the visibility of one or more dashboard objects. - Throws an error if the dashboard object is invalid
-A map of dashboard object ids to its desired state of visibility.
-Empty promise that resolves when the visibility has been changed.
-Sets the visibility of one or more floating dashboard zones. - Throws an error if the zone is invalid
-A map of zone ids to the desired state of visibility for that zone.
-Empty promise that resolves when the visibility has been changed.
-The DashboardContent namespace is the namespace associated with Dashboard Extensions.
- The DashboardContent namespace contains the Dashboard interface. Use the Dashboard Interface to
- access dashboard objects, worksheets, and parameters, and to add or remove event listeners.
An event which is raised when the dashboard objects are modified.
- Should be listened for directly from the tableau.extensions.dashboardContent.dashboard object.
An object of a dashboard.
-An object to specify a dashboard object and its new position and size in a dashboard.
-Represents the data source used by a Worksheet.
-An array of table summary objects that are currently used in the data source.
-An array of descriptions of the connections within this data source.
-Gets the underlying data table for the given logical table id.
-Collection of options to change the behavior of the call.
-A data table containing the underlying data of the data source.
-Gets the underlying logical tables used in the data source.
-An array of logical tables that are currently used in the data source.
-The following example uses the getLogicalTablesAsync method to print the names of the
- the logical tables to the console.
dataSource.getLogicalTablesAsync().then(function (logicalTables) {
- // Loop through each table that was used in creating this data source
- logicalTables.forEach(function (table) {
- console.log(table.caption);
- });
-});Collection of options to change the behavior of the call.
-Returns a promise containing a page of data from the underlying data of the data source.
-The following example shows use of the getUnderlyingDataAsync() method to get the underlying data from a specific data source.
- The example uses the JavaScript find() method to select the workbook and data source.
const dataSources = await worksheet.getDataSourcesAsync();
-const dataSource = dataSources.find(datasource => datasource.name === "Sample - Superstore");
-const dataTable = await dataSource.getUnderlyingDataAsync();
-let field = dataTable.columns.find(column => column.fieldName === "Sub-Category");
-let list = [];
-for (let row of dataTable.data) {
- list.push(row[field.index].value);
-}
-let values = list.filter((el, i, arr) => arr.indexOf(el) === i);
-console.log(values);
-This call has the same functionality as clicking the Refresh option on a data source in - Tableau. This does not refresh an extract.
-Note: The refreshAsync() method is intended to be used in scenarios where manual
- interaction causes a need to refresh the data in the Tableau visualization. The method is not,
- as currently designed, meant to support or emulate streaming or live visualizations.
- Extensions that use the method to refresh aggressively or automatically
- can cause issues on Tableau Server and Tableau Online and are subject to being blocked
- by the Tableau Online administrator.
This call does not currently support refreshing live Google Sheet data sources.
-Promise that resolves when the data source has finished refreshing.
-Configuration object for fetching data from an data source object.
-The columns to return specified by field name, returns all by default.
-The columns to return specified by field id, returns all by default. - Since 1.5.0, fieldId is a property of the Column object.
-Do not use aliases specified in the data source in Tableau. Default is false.
-Specify which properties to return in DataValues. The default is IncludeDataValuesOption.AllValues.
- All properties not requested will be undefined in the DataValue results.
- This is a performance optimization only, and will be ignored in Tableau versions prior to 2021.2.
The maximum number of rows to return. 10,000 by default
-A DataTableReader allows iteration over summary or underlying data by pages. - The page size is established when the DataTableReader is created. - (See getLogicalTableDataReaderAsync, getSummaryDataReaderAsync, or getUnderlyingTableDataReaderAsync.) - The normal sequence of operations would be to
-Notes for usage of a DataTableReader:
-Get all the pages of data into a single DataTable. - Calls to getAllPagesAsync() after releaseAsync() will throw an exception. - To protect against possible browser failure, getAllPagesAsync will cap the data at a maximum of 400 pages. - With a default pageRowCount of 10,000 this will give you a maximum of 4,000,000 rows of data.
-If sizes are larger than this, please process your data in page size chunks.
-Limits the request to maxRows. If maxRows === 0, requests all rows.
-A DataTable containing all the data available to the DataTableReader with the maximum page count above.
-// To simplify the example, we assume we have less than 4m rows of data
-// Since we are fetching all of the data, use the default page size in getSummaryDataReaderAsync
-const dataTableReader = await worksheet.getSummaryDataReaderAsync();
-const dataTable = await dataTableReader.getAllPagesAsync();
-await dataTableReader.releaseAsync();
-// ... process the data table ...Get a page of data. The page is returned as a DataTable. - Calls to getPageAsync() after releaseAsync() will throw an exception.
-The page number (zero-indexed) to fetch. The page number should be treated - like an array index with range: 0 <= pageNumber < pageCount.
-A DataTable containing the requested page. The number of rows returned - can be less than the page size at the end of the data.
-const pageRowCount = 200;
-const dataTableReader = await worksheet.getSummaryDataReaderAsync(pageRowCount, options);
-for (let currentPage = 0; currentPage < dataTableReader.pageCount; currentPage++) {
- const currentPageDataTable = await dataTableReader.getPageAsync(currentPage);
- // ... process current page ...
-}
-await dataTableReader.releaseAsync();Release all resources held by the DataTableReader. - Calling this when done with the DataTableReader is required practice as it frees up resources. - Calls to getPageAsync() after releaseAsync() will throw an exception.
-Specifies the style for the popup dialog.
-Specifies the suggested height (in pixels) of the popup dialog. Not guaranteed to be exactly that height.
-Specifies the suggested width (in pixels) of dialog to display. Not guaranteed to be exactly that width.
-The environment namespace provides a way to programmatically gather - information about the environment in which the Extensions is running.
-Interface for handling registering and unregistering event listeners. Different objects will implement - this interface to manage their event handling.
-Adds a new event listener to the object. If this object does not support the specified eventType,
- the method throws an exception.
- The following table shows the event types supported by objects.
| object | -eventType | -
|---|---|
| Worksheet | -FilterChanged , MarkSelectionChanged, SummaryDataChanged |
-
| Parameter | -ParameterChanged |
-
| Settings | -SettingsChanged |
-
| Dashboard | -DashboardLayoutChanged, WorkbookFormattingChanged |
-
The type of event to register for. The type of event is a TableauEventType enumeration.
The function which will be called when an event happens.
-A helper function which can be called to remove this registration.
-The following example sets up a listener in a worksheet for a mark selection event (MarkSelectionChanged).
- When the event occurs, the data is reloaded. The addEventListener method returns a function that un-registers
- the event handler. Call that function, in this case, unregisterEventHandlerFunction() to remove the registration.
// Add an event listener for the selection changed event on this sheet.
-// Assigning the event to a variable just to make the example fit on the page here.
-const markSelection = tableau.TableauEventType.MarkSelectionChanged;
-//
-unregisterEventHandlerFunction = worksheet.addEventListener(markSelection, function (selectionEvent) {
-// When the selection changes, reload the data
-loadSelectedMarks(worksheetName);
-});
-
-// remove the event listener when done
- unregisterEventHandlerFunction();
-Removes an event listener if a matching one is found. If no matching listener exists, the method does nothing.
- The handler function must the handler function specified in the call to the addEventListener method. Alternatively, use the function
- returned from the call to addEventListener to unregister the event listener.
- For more information, see Events and Event Handling.
Whether or not an event listener was removed.
-The extension namespace contains all functionality available to - Extensions in Tableau.
-The environment namespace provides methods to programmatically gather information about the environment
- in which the extension is running. To access the objects in this name space, specify
- tableau.extensions.environment.
The settings namespace provides methods to get and set values which will be persisted in a workbook.
- You can use the settings to configure an extension. To access the objects in this name space, specify
- tableau.extensions.settings.
The ui namespace provides methods for an extension to display a popup dialog window.
- To access the objects in this name space, specify tableau.extensions.ui.
The currently opened workbook.
-The dashboardContent namespace provides access to the dashboard object when the extension is a dashboard extension.
- When you have the dashboard object, you have access to all elements in the dashboard
- including the worksheets, marks,
- filters, parameters, and data sources.
- To access the objects in this name space, specify tableau.extensions.dashboardContent.
The dashboard object id for the extension that is running.
-The worksheetContent namespace provides access to the worksheet when the extension is a worksheet extension.
- When you have the worksheet object, you have access to all elements in the worksheet
- To access the objects in this name space, specify tableau.extensions.worksheetContent.
the object containing the embedded data and visual spec details
- tableau.extensions.createVizImageAsync(myInputSpec));The following is an example of an input spec object.
-var myInputSpec = {
- description: 'A simple bar chart with embedded data.',
- data: {
- values: [
- { Category: 'A', Measure: 28, Weather: 10 },
- { Category: 'B', Measure: 55, Weather: 9 },
- { Category: 'C', Measure: 43, Weather: 8 },
- ]
- },
- mark: tableau.MarkType.Bar,
- encoding: {
- columns: { field: 'Category', type: tableau.VizImageEncodingType.Discrete },
- rows: { field: 'Measure', type: tableau.VizImageEncodingType.Continuous },
- sort: { field: 'Category', 'sortby': 'Weather', direction: tableau.VizImageSortDirectionType.Ascending }
- }
- };A promise that when resolved, returns the viz as an svg.
-Supports sorting by field.
-This is the entry point for an Extension. This function must first be called - in order to interact with any of the other Extension APIs.
-This optional object maps the ids of context menu items to the function
- to be triggered when that context menu item is selected. The keys listed
- must matched the keys registered in the context-menu element of the manifest.
- Currently, only a single context menu item is available ('configure')
- that creates the Configure... menu item), so this object will only contain a single entry.
- In this example, the 'configure' key is mapped to a function of the same name,
- which you would define in your JavaScript code.
$(document).ready(function () {
- tableau.extensions.initializeAsync({'configure': configure}).then(function() {
- // When the user clicks the Configure... context menu item,
- // the configure function specified as the argument here
- // is executed.
- //
- });
- });A promise that when resolved, the other Extension APIs will be available to use.
-The initializeDialogAsync function is the entry point for an extension that runs inside a dialog box (or popup window)
- created by the UI namespace. A call to tableau.extensions.ui.displayDialogAsync(payload) creates the dialog box.
- When the extension running in the dialog box loads, the extension must first call the initializeDialogAsync function
- to use the rest of the Extension API. The initializeDialogAsync function should only be called by extensions
- that are displayed in a dialog box. You use the initializeAsync function
- to initialize the main extension, that is, the parent of the extension in the dialog box.
A promise that when resolved the other Extension APIs will be available to use.
- Contains a string that is the initial payload for the dialog as sent by the
- parent extension via tableau.extensions.ui.displayDialogAsync(payload).
- See displayDialogAsync for more information.
This method allows for clicks to pass through the extension window on Tableau Server.
-A boolean which represents if clicks should pass through the extension window
-A promise that resolves when the click through property has been set.
-The following example shows a call made to setClickThroughAsync.
- // disabling pointer events on the extension window
- tableau.extensions.setClickThroughAsync(true).then(() => {
- console.log('Successfully enabled extension window click through');
- }).catch((error) => {
- // Can throw an error if called from a dialog or on Tableau Desktop
- console.error(error.message);
- });A field contains information about what data source it belongs to, - its role, and the ability to fetch the domain values.
-An abstract base class for all of the filter types.
-the list of worksheet names that have the filter applied.
-a promise containing the field for the filter.
-Applies the filter to the specified list of worksheets. - If the worksheet(s) do not exist or do not contain the field in their data sources, an exception is thrown.
-list of worksheets to apply the filter on
-the list of worksheet names that have the filter applied
-The Filter object associated with the event.
-Passed into the applyFilter methods to control advanced filtering options.
-Determines whether the filter will apply in exclude mode or include mode. - The default is include, which means that you use the fields as part of a filter. - Exclude mode means that you include everything else except the specified fields.
-Options argument for the Worksheet.GetSummaryDataAsync API
-The columns to return specified by field id, returns all by default. - Since 1.5.0, fieldId is a property of the Column object.
-Do not use aliases specified in the data source in Tableau. Default is false.
-Only return data for the currently selected marks. Default is false.
-Specify which properties to return in DataValues. The default is IncludeDataValuesOption.AllValues.
- All properties not requested will be undefined in the DataValue results.
- This is a performance optimization only, and will be ignored in Tableau versions prior to 2021.2.
The number of rows of data that you want to return. A value of 0 will attempt to return all rows.
- 0 is the default if maxRows is not specified.
- getUnderlyingTableDataAsync - maximum number of rows returned is capped at 10,000 regardless of maxRows.
- getSummaryDataAsync - maximum number of rows returned is not capped, but performance may suffer with large row counts.
Options argument for the Worksheet.getUnderlyingTableDataAsync API.
-The columns to return specified by field id, returns all by default. - Since 1.5.0, fieldId is a property of the Column object.
-Do not use aliases specified in the data source in Tableau. Default is false.
-Only return data for the currently selected marks. Default is false.
-Return all the columns for the data source. Default is false.
-Specify which properties to return in DataValues. The default is IncludeDataValuesOption.AllValues.
- All properties not requested will be undefined in the DataValue results.
- This is a performance optimization only, and will be ignored in Tableau versions prior to 2021.2.
The number of rows of data that you want to return. A value of 0 will attempt to return all rows.
- 0 is the default if maxRows is not specified.
- getUnderlyingTableDataAsync - maximum number of rows returned is capped at 10,000 regardless of maxRows.
- getSummaryDataAsync - maximum number of rows returned is not capped, but performance may suffer with large row counts.
A Hierarchical Filter - Hierarchical Filters are used when a hierarchical field is used as a filter on a cube database. - As an example, assume a hierarchical field in Product, named ByCategory. - ByCategory has the following five levels: Family, Category, Subcategory, Brand, Sku.
-the list of worksheet names that have the filter applied.
-a promise containing the field for the filter.
-Applies the filter to the specified list of worksheets. - If the worksheet(s) do not exist or do not contain the field in their data sources, an exception is thrown.
-list of worksheets to apply the filter on
-the list of worksheet names that have the filter applied
-A selected value in a hierarchical filter
-Details about each level in a hierarchical filter
-Levels to apply to a hierarchical filter
-Represents a collection of marks on a viz. This collection could be - marks that are either selected or highlighted.
-An event which is raised when marks are selected on a worksheet.
-The collection of Marks that were selected.
-Represents a parameter in Tableau and provides ways to introspect the parameter and change its values.
-Adds a new event listener to the object. If this object does not support the specified eventType,
- the method throws an exception.
- The following table shows the event types supported by objects.
| object | -eventType | -
|---|---|
| Worksheet | -FilterChanged , MarkSelectionChanged, SummaryDataChanged |
-
| Parameter | -ParameterChanged |
-
| Settings | -SettingsChanged |
-
| Dashboard | -DashboardLayoutChanged, WorkbookFormattingChanged |
-
The type of event to register for. The type of event is a TableauEventType enumeration.
The function which will be called when an event happens.
-A helper function which can be called to remove this registration.
-The following example sets up a listener in a worksheet for a mark selection event (MarkSelectionChanged).
- When the event occurs, the data is reloaded. The addEventListener method returns a function that un-registers
- the event handler. Call that function, in this case, unregisterEventHandlerFunction() to remove the registration.
// Add an event listener for the selection changed event on this sheet.
-// Assigning the event to a variable just to make the example fit on the page here.
-const markSelection = tableau.TableauEventType.MarkSelectionChanged;
-//
-unregisterEventHandlerFunction = worksheet.addEventListener(markSelection, function (selectionEvent) {
-// When the selection changes, reload the data
-loadSelectedMarks(worksheetName);
-});
-
-// remove the event listener when done
- unregisterEventHandlerFunction();
-Modifies this parameter and assigns it a new value. The new value must fall within
- the domain restrictions defined by allowableValues. If the domain restriction is ParameterValueType.Range,
- be sure to check the allowableValues before assigning a new value. If the new value is out of range, the
- updated value will be set to either the minValue or the maxValue of the allowable range. If a step size is also specified
- and the new value does not fall on the step intervals, the updated value will be set to the closest, lower step,
- or closest, earlier date. If the domain restriction is type ParameterValueType.List, and there are aliases defined for the list,
- the aliased value should be passed to the method.
The new value to assign to this parameter.
- Note: For changing Date parameters, UTC Date objects are expected.
The updated DataValue. The promise is rejected if newValue is invalid. However, if the domain restriction
- is type AllowableValuesType.Range, and the newValue is out of the range bounds, the parameter gets set to the minValue
- or the maxValue of the range (whichever is closer). If the range has a stepSize or dateStepPeriod, the parameter gets set
- to the closest, lower step, or the closest, earlier date.
Removes an event listener if a matching one is found. If no matching listener exists, the method does nothing.
- The handler function must the handler function specified in the call to the addEventListener method. Alternatively, use the function
- returned from the call to addEventListener to unregister the event listener.
- For more information, see Events and Event Handling.
Whether or not an event listener was removed.
-An event which is raised when the value of a parameter changes.
-The parameter that was changed.
-Represents the allowable set of values which a parameter can be set to.
-A Range Filter
-the list of worksheet names that have the filter applied.
-the domain type, defaults to relevant
-a promise containing the domain for the range filter
-a promise containing the field for the filter.
-Applies the filter to the specified list of worksheets. - If the worksheet(s) do not exist or do not contain the field in their data sources, an exception is thrown.
-list of worksheets to apply the filter on
-the list of worksheet names that have the filter applied
-Options for Range Filter
-RangeValue interface to provide selection value for range based selections.
- The associated field should be a quantitative field.
- For Date Values, UTC Date objects are expected. (i.e., var min = new Date(Date.UTC(1999, 0, 1))).
- While date string inputs work, UTC date inputs are officially supproted going forward for RangeValue.
max range value for the range based selection
-min range value for the range based selection
-Including nulloptions parameter.
-the list of worksheet names that have the filter applied.
-a promise containing the field for the filter.
-Applies the filter to the specified list of worksheets. - If the worksheet(s) do not exist or do not contain the field in their data sources, an exception is thrown.
-list of worksheets to apply the filter on
-the list of worksheet names that have the filter applied
-Options for Relative Date Filter
-SelectionCriteria interface is used to specify to the fieldName to values for Hierarchical, Categorical and Range based selections.
-Fieldname of the mark that is intended to be selected. - Hierarchical fields follow the convention of "[{parentField}].[{selectingField}]"
-Value that is intended to be selected. This can be specified as the list of values or a single value. - Range-based selections need to provide the value in the format of RangeValue interface.
-The settings namespace is used to get and set settings - values. You can use the settings to configure your extension. - The setting values are be persisted in a workbook.
-Indicates whether or not the settings have been - modified since the last call to saveAsync.
-Adds a new event listener to the object. If this object does not support the specified eventType,
- the method throws an exception.
- The following table shows the event types supported by objects.
| object | -eventType | -
|---|---|
| Worksheet | -FilterChanged , MarkSelectionChanged, SummaryDataChanged |
-
| Parameter | -ParameterChanged |
-
| Settings | -SettingsChanged |
-
| Dashboard | -DashboardLayoutChanged, WorkbookFormattingChanged |
-
The type of event to register for. The type of event is a TableauEventType enumeration.
The function which will be called when an event happens.
-A helper function which can be called to remove this registration.
-The following example sets up a listener in a worksheet for a mark selection event (MarkSelectionChanged).
- When the event occurs, the data is reloaded. The addEventListener method returns a function that un-registers
- the event handler. Call that function, in this case, unregisterEventHandlerFunction() to remove the registration.
// Add an event listener for the selection changed event on this sheet.
-// Assigning the event to a variable just to make the example fit on the page here.
-const markSelection = tableau.TableauEventType.MarkSelectionChanged;
-//
-unregisterEventHandlerFunction = worksheet.addEventListener(markSelection, function (selectionEvent) {
-// When the selection changes, reload the data
-loadSelectedMarks(worksheetName);
-});
-
-// remove the event listener when done
- unregisterEventHandlerFunction();
-Erases a settings key / value pair. If key isn't found, nothing happens.
-The key of the pair to erase.
-Gets a settings value or undefined if the value does not exist.
-The key to retrieve.
-The value or undefined if it does not exist.
-Returns a copy of all the saved settings keys and values. - Modifying this value will have no effect on the class.
-All the saved settings keys and values in a dictionary.
-Removes an event listener if a matching one is found. If no matching listener exists, the method does nothing.
- The handler function must the handler function specified in the call to the addEventListener method. Alternatively, use the function
- returned from the call to addEventListener to unregister the event listener.
- For more information, see Events and Event Handling.
Whether or not an event listener was removed.
-Attempts to persist any currently modified settings key-value pairs. The saveAsync() method
- should only be called in authoring mode.
Promise containing the newly saved settings values.
-tableau.extensions.settings.saveAsync().then(result => {
- console.log('Settings saved.');
- // ... process results
-}).catch((error) => {
- // ...
- // ... code for error handling
-});
-Adds or updates a settings key / value pair.
-The key to save.
-The value to save.
-An event which is raised when the settings of an extension are updated.
- Should be listened for directly from the tableau.extensions.settings object.
Adds a new event listener to the object. If this object does not support the specified eventType,
- the method throws an exception.
- The following table shows the event types supported by objects.
| object | -eventType | -
|---|---|
| Worksheet | -FilterChanged , MarkSelectionChanged, SummaryDataChanged |
-
| Parameter | -ParameterChanged |
-
| Settings | -SettingsChanged |
-
| Dashboard | -DashboardLayoutChanged, WorkbookFormattingChanged |
-
The type of event to register for. The type of event is a TableauEventType enumeration.
The function which will be called when an event happens.
-A helper function which can be called to remove this registration.
-The following example sets up a listener in a worksheet for a mark selection event (MarkSelectionChanged).
- When the event occurs, the data is reloaded. The addEventListener method returns a function that un-registers
- the event handler. Call that function, in this case, unregisterEventHandlerFunction() to remove the registration.
// Add an event listener for the selection changed event on this sheet.
-// Assigning the event to a variable just to make the example fit on the page here.
-const markSelection = tableau.TableauEventType.MarkSelectionChanged;
-//
-unregisterEventHandlerFunction = worksheet.addEventListener(markSelection, function (selectionEvent) {
-// When the selection changes, reload the data
-loadSelectedMarks(worksheetName);
-});
-
-// remove the event listener when done
- unregisterEventHandlerFunction();
-Searches for a parameter with the given name.
-The name of the parameter to find.
-The parameter with the given name, or undefined if it does not exist.
-A collection of all the Tableau parameters that are used in this workbook.
-Removes an event listener if a matching one is found. If no matching listener exists, the method does nothing.
- The handler function must the handler function specified in the call to the addEventListener method. Alternatively, use the function
- returned from the call to addEventListener to unregister the event listener.
- For more information, see Events and Event Handling.
Whether or not an event listener was removed.
-An event which is raised when summary data is changed for a worksheet or when a worksheet's data source is refreshed
-Custom error class that extends the default JavaScript Error object.
-An event object represents a notification that some sort of state has changed. - This is the base event interface. All events will inherit this type.
-An event which is related to a particular Sheet (worksheet, dashboard, story) in the workbook.
-An event which is related to a particular Worksheet in the workbook.
-Represents a table of data in a data source.
-Provides the necessary information for how to display a Tableau tooltip.
-Indicates where the tooltip should be displayed relative to the top left of the visualization.
-The UI namespace contains methods that allow an extension to display a popup
- dialog window. A modal dialog can be useful in authentication or configuration scenarios,
- or when extra situational UI space is needed. Only one dialog can be displayed at a time per extension.
- Inside the popup dialog window, another extension can be loaded and run. This dialog extension will have full access
- to the functions provided by the Extensions API. One difference between the extension running in the popup dialog window
- and an extension running in the dashboard is that the popup dialog window must call
- the initializeDialogAsync() method instead of initializeAsync() to initialize the extension.
Note If you want to use a popup dialog window on Tableau Server, you need to let users know that their browser must be - configured to allow popups.
-The closeDialog method must be called from extension running in the popup dialog window.
The payload is optional, and if specified, it is made available to parent extension when
- this popup dialog closes. If the extension running in the popup dialog window does not return
- a payload, you must still provide an empty string " " as a return value.
tableau.extensions.ui.closeDialog('myPayload string');
-The following example shows a call to the closeDialog method when the dialog extension does not return a payload.
- // specify an empty string if no payload is returned
- tableau.extensions.ui.closeDialog('');The url of the 'dialog extension' to navigate to in the dialog. The url must - belong to the same domain as the parent extension.
-The payload is optional, and is used to provide data to the popup dialog window
- at startup. The payload will be returned to the dialog extension as the return
- value of the call to the tableau.extensions.ui.initializeDialogAsync function.
- If no payload is provided, you must indicate this with an empty string " ".
Specifies the options for the popup dialog window.
- The dialogOptions has properties for width and height (in pixels) and a property for the dialog's style.
- The dialog style can be a window, a modal dialog, or a modeless dialog. If style is not specified, window will be used.
- You pass these properties to the displayDialogAsync function, as follows:
- {width: number, height: number, dialogStyle: DialogStyle}
A promise that resolves when the dialog has been closed. It will contain a - payload as a string provided by the dialog extension. The promise is rejected if - the user manually closes the dialog window (for example, by clicking the 'X' in window). - It is good practice to handle this error condition with a catch block, as in the following example.
- tableau.extensions.ui.displayDialogAsync(popupUrl, defaultPayload, { width: 500, height: 500 }).then((closePayload) => {
- //
- // The promise is resolved when the dialog has been closed as expected, meaning that
- // the popup extension has called tableau.extensions.ui.closeDialog() method.
- // The close payload (closePayload) is returned from the popup extension
- // via the closeDialog() method.
- //
- }).catch((error) => {
- // One expected error condition is when the popup is closed by the user (meaning the user
- // clicks the 'X' in the top right of the dialog). This can be checked for like so:
- switch(error.errorCode) {
- case tableau.ErrorCodes.DialogClosedByUser:
- console.log("Dialog was closed by user");
- break;
- default:
- console.error(error.message);
- }
- });The Workbook represents the currently open workbook.
Gets the data sources for this workbook. Note that calling this method might negatively impact performance - and responsiveness of the viz that your extension is added to. The method is not entirely - asynchronous and includes some serial operations.
-All data sources used in this workbook.
-The Workbook formatting contains an array of Formatting sheets. - Each of these sheets can be identified by the ClassNameKey and - contains the CSS properties needed to mimic the formatting on your workbook.
-An event which is related to a worksheet's formatting (worksheet, dashboard, story) in the workbook.
-Adds a new event listener to the object. If this object does not support the specified eventType,
- the method throws an exception.
- The following table shows the event types supported by objects.
| object | -eventType | -
|---|---|
| Worksheet | -FilterChanged , MarkSelectionChanged, SummaryDataChanged |
-
| Parameter | -ParameterChanged |
-
| Settings | -SettingsChanged |
-
| Dashboard | -DashboardLayoutChanged, WorkbookFormattingChanged |
-
The type of event to register for. The type of event is a TableauEventType enumeration.
The function which will be called when an event happens.
-A helper function which can be called to remove this registration.
-The following example sets up a listener in a worksheet for a mark selection event (MarkSelectionChanged).
- When the event occurs, the data is reloaded. The addEventListener method returns a function that un-registers
- the event handler. Call that function, in this case, unregisterEventHandlerFunction() to remove the registration.
// Add an event listener for the selection changed event on this sheet.
-// Assigning the event to a variable just to make the example fit on the page here.
-const markSelection = tableau.TableauEventType.MarkSelectionChanged;
-//
-unregisterEventHandlerFunction = worksheet.addEventListener(markSelection, function (selectionEvent) {
-// When the selection changes, reload the data
-loadSelectedMarks(worksheetName);
-});
-
-// remove the event listener when done
- unregisterEventHandlerFunction();
-Add an annotation to the specified mark. - This is intended to be passed a MarkInfo object received from a DataTable. - MarkInfo can be found in the DataTable returned from getSelectedMarksAsync or getHighlightedMarksAsync.
-The mark to annotate.
-The text to display in the annotation.
-Empty promise that resolves when the annotation is complete.
-Applies the list of provided categorical filter values.
-The name of the field to filter on.
-The list of values to filter on.
-The update type of this filter (add, all, remove, replace).
-Advanced filter options (isExcludeMode).
-The field name that the filter is applied on.
-Applies the list of provided hierarchial filter values.
-The name of the field to filter on.
-The list of values or levels to filter on.
-The update type of this filter (add, all, remove, replace).
-The field name that the filter is applied on.
-Applies a range filter to a quantitative or date field.
-The name of the field to filter on
-Filter Options: min, max, nullOption. At least one of of min and max is required.
- For applying date filters, UTC Date objects are expected (that is, var min = new Date(Date.UTC(1999, 0, 1))).
The field name that the filter is applied on.
-Applies a relative date filter.
-The name of the field to filter on.
-The relative date filter options (anchorDate, periodType, rangeType, rangeN). When the rangeType is LASTN or NEXTN, the rangeN is required.
-The field name that the filter is applied on.
-Resets existing filters on the given field. - Categorical filters are reset to "All," and range filters are reset to the full range - Relative date filters can not be reset, consider using the applyRelativeDateFilterAsync API.
-The name of the field to clear filter on.
-The field to clear filter on.
-Clears selected marks in the current worksheet.
-Empty promise that resolves when the selection has been cleared.
-The following example assumes that you have some marks already selected in the worksheet. After it has run, - you should have no marks selected, and you should see the console message.
- worksheet.clearSelectedMarksAsync().then(function () {
- console.log('Your marks selection has been cleared!');
- })Searches for a parameter with the given name.
-The name of the parameter to find.
-The parameter with the given name, or undefined if it does not exist.
-Retrieves a list of the annotations in the worksheet.
-A list annotations in the worksheet.
-Gets the data sources for this worksheet. Note that calling this method might negatively impact performance - and responsiveness of the viz that your extension is added to. The method is not entirely - asynchronous and includes some serial operations.
-The primary data source and all of the secondary data sources for this worksheet. - By convention the first data source in the array is the primary.
-The following example shows how you might find a specific data source of a worksheet,
- using the getDataSourcesAsync() method. The example then chains the data source returned in the promise
- to a call to the getUnderlyingDataAsync() method to access the data table.
worksheet.getDataSourcesAsync().then(datasources => {
- dataSource = datasources.find(datasource => datasource.name === "Sample - Superstore");
- return dataSource.getUnderlyingDataAsync();
-}).then(dataTable => {
-// process the dataTable...
-});
-Gets the list of filters on a worksheet. Hierarchical filters are not yet supported
-A promise that resolves to the collection of filters used in this worksheet.
-Gets the data for the marks which are currently highlighted on the worksheet. - If there are no marks currently highlighted, an empty model is returned.
-The marks which are selected.
-A collection of all the Tableau parameters that are used in this workbook.
-Gets the data for the marks which are currently selected on the worksheet. - If there are no marks currently selected, an empty model is returned.
-The marks that are selected.
-// Call to get the selected marks for the worksheet
-worksheet.getSelectedMarksAsync().then(function (marks) {
- // Get the first DataTable for our selected marks (usually there is just one)
- const worksheetData = marks.data[0];
-
- // Map the data into a format for display, etc.
-
-});Gets the columns that are returned with getSummaryDataAsync.
The array of columns that describe the data in the worksheet.
-Gets the summary data table for this worksheet. - Warning: getSummaryDataAsync can fail with a worksheet with many rows of data and is now deprecated.
-Collection of options to change the behavior of the call.
-A data table containing the summary data for the worksheet.
-Gets a summary data table reader for this worksheet. - Only one active DataTableReader for summary data is supported.
-Note: The getSummaryDataAsync and getSummaryDataReaderAsync methods return the data that is currently
- in the viz, with parameters, calculated fields, and sorting applied. To access full data, that is
- the underlying data without the additional fields and processing you have added in Tableau, use
- the Worksheet.getUnderlyingTableDataAsync and Worksheet.getUnderlyingTableDataReaderAsync methods.
The number of rows per page. The default and maximum is 10,000 rows.
-Collection of options to change the behavior of the reader.
-A data table reader to access the summary data for the worksheet.
-The following example shows the methods to get and use the summary data reader for all rows in a worksheet.
-const dataTableReader = await worksheet.getSummaryDataReaderAsync();
-for (let currentPage = 0; currentPage < dataTableReader.pageCount; currentPage++) {
- let dataTablePage = await dataTableReader.getPageAsync(currentPage);
- // ... process current page ....
-}
-await dataTableReader.releaseAsync();Gets the underlying data table for this worksheet.
-Collection of options to change the behavior of the call.
-A data table containing the underlying data for the worksheet.
-Gets the underlying data table for the given logical table id.
- Use the getUnderlyingTablesAsync method to identify the logical tables.
logical table id.
-Collection of options to change the behavior of the call.
-A data table containing the underlying data for the given logical table id
-Gets a underlying data table reader for the given logical table id.
- Use the getUnderlyingTablesAsync method to identify the logical tables.
- Only one active DataTableReader per logical table id is supported.
Note: Use the getUnderlyingTableDataReaderAsync method to access the full data, that is
- the underlying data without the parameters, calculated fields, and processing you might
- have added in Tableau. To access just the data that is currently in the viz, with parameters,
- calculated fields, and sorting applied use the Worksheet.getSummaryDataAsync and
- Worksheet.getSummaryDataReaderAsync methods.
The getUnderlyingTableDataReaderAsync method attempts to prepare all the rows of the underlying table to be read as pages.
- However, there is a limit to the number of rows that can be prepared. The default limit is 1 million rows of data.
- You can change the default limit with the Tableau Server (Cloud) or Tableau Desktop option: ExtensionsAndEmbeddingReaderRowLimit.
- If the underlying table has many columns, getUnderlyingTableDataReaderAsync can be sped up by only requesting
- native data values in the GetUnderlyingDataOptions.
logical table id.
-The number of rows per page. The default and maximum is 10,000 rows.
-Collection of options to change the behavior of the reader.
-A data table reader to access the underlying data for the given logical table id.
-The following example shows getting the first page of underlying data.
-// Call to get the underlying logical tables used by the worksheet
-const underlyingTablesData = await worksheet.getUnderlyingTablesAsync();
-const logicalTableId = underlyingTablesData[0].id;
-// Use the above logicalTableId to get the underlying data reader on the active sheet
-const dataTableReader = await worksheet.getUnderlyingTableDataReaderAsync(logicalTableId);
-const page = await dataTableReader.getPageAsync(0);
-// ... process first page of data table ...
-await dataTableReader.releaseAsync();Gets the underlying logical tables used by the worksheet. The resulting logical tables are determined by the measures in the worksheet. - If a worksheet's data source contains multiple logical tables and the worksheet contains only measures from one logical table, this API - will return one logical table.
-An array of logical tables corresponding to the measures referenced by the worksheet.
-// Call to get the underlying logical tables used by the worksheet
-worksheet.getUnderlyingTablesAsync().then(function (logicalTables) {
- // Get the first logical table's id
- const logicalTableId = logicalTables[0].id;
-
- // Use the above logicalTableId to then get worksheet's underlying data
- // by calling worksheet.getUnderlyingTableDataAsync(logicalTableId)
-
-});Returns the visual specification for the worksheet, which can be used to get - the mappings from fields to encodings backing the visual within the worksheet
-Promise containing the VisualSpecification
-Removes the corresponding annotation from the worksheet it belongs to. - This is intended to be passed a Annotation object received from getAnnotationsAsync.
-The annotation to remove.
-Empty promise that resolves when the annotation is removed.
-Removes an event listener if a matching one is found. If no matching listener exists, the method does nothing.
- The handler function must the handler function specified in the call to the addEventListener method. Alternatively, use the function
- returned from the call to addEventListener to unregister the event listener.
- For more information, see Events and Event Handling.
Whether or not an event listener was removed.
-Selects the marks specified by value using the SelectionCriteria interface. - This is intended for manual construction of the desired selections.
-A list of criteria for which marks to select.
-The type of selection to make: add, remove, or replace.
-Empty promise that resolves when the selection is complete.
-Method to get the text of the tooltip that would be displayed for a given tuple id. Currently supported for web only.
-You can find the tuple id for a row of data by subtracting the index of the row from the total number of rows. - For example, if you have 10 rows, and want to know the tuple id associated with the third row, it will be 7 (10 - 3 = 7). The last row of data will always have the tuple id of 1.
-Passing in an invalid tuple id will not throw.
-
let navigatedTuple = -1;
-let updateScreenReaderElement = (screenReadertext) => {
- // updates an element to be read out by screen readers
-};
-
-let updateNavigatedTuple = (keyboardEvent) => {
- switch (keyboardEvent.key) {
- case 'ArrowLeft':
- navigatedTuple = navigatedTuple - 1;
- break;
- case 'ArrowRight':
- navigatedTuple = navigatedTuple + 1;
- break;
- default:
- break;
- }
- // do any work to show visual indication of a mark being navigated to
-};
-
-svg.on('keydown', (keyboardEvent) => {
- updateNavigatedTuple(keyboardEvent);
- tableau.extensions.worksheetContent.worksheet
- .getTooltipTextAsync(navigatedTuple)
- .then((response) => {
- console.log(response.result);
- updateScreenReaderElement(response.result);
- })
- .catch((error) => console.log('Failed to get tooltip text because of: ', error));
-});Returns promise that resolves to a string describing the tooltip text for a given tuple id and rejects on error
-Method to execute hover actions and render tooltip for a given tuple representing a mark in the visualization. - If the tooltip parameter is included it will show the tooltip when the mark is hovered over. - If null or no tooltip parameter is passed, no tooltip is shown. - Hover actions are run by default, but passing false for the allowHoverActions parameter will prevent their execution.
-The hoveredTuple parameter is a tuple id. You can find the tuple id for a row of data by subtracting the index of the row from the total number of rows.
- For example, if you have 10 rows, and want to know the tuple id associated with the third row, it will be 7 (10 - 3 = 7). The last row of data will always have the tuple id of 1.
Passing in an invalid tuple id will not throw and will clear the tooltip.
-
svg.on('mousemove', (mouseEvent) => {
- const myHoveredTuple = 10;
- tableau.extensions.worksheetContent.worksheet.hoverTupleAsync(myHoveredTuple, { tooltipAnchorPoint: { x: mouseEvent.pageX, y: mouseEvent.pageY } })
- .then(() => console.log('Done'))
- .catch((error) => console.log('Failed to hover because of: ', error));
- });Returns empty promise that resolves when the extension host has successfully been informed of the request and rejects on error
-Notifies the scene of a desire to leave mark-level keyboard navigation and return to scene-level keyboard navigation.
- Used when implementing keyboard navigation within a visualization, an integral part of building accessibility into a visualization.
- Currently supported for the web only.
-
svg.on('keyup', (keyboardEvent) => {
- if (keyboardEvent.key == "Escape") {
- tableau.extensions.worksheetContent.worksheet
- .leaveMarkNavigationAsync()
- .then(() => console.log('Done'))
- .catch((error) => console.log('Failed to leave mark-level keyboard navigation because of: ', error));
- }
-});Returns empty promise that resolves when the extension host has successfully been informed of the request and rejects on error
-Method to modify selection, execute select actions, and render tooltip for a given list of tuples representing a mark or marks in the visualization. - If the tooltip parameter is included it will show the tooltip when the mark or marks are selected. If not, no tooltip is shown.
-The selectedTuples parameter is an array of tuple ids. You can find the tuple id for a row of data by subtracting the index of the row from the total number of rows.
- For example, if you have 10 rows, and want to know the tuple id associated with the third row, it will be 7 (10 - 3 = 7). The last row of data will always have the tuple id of 1.
Passing in an invalid tuple id will not throw and will clear the tooltip.
-
svg.on('click', (mouseEvent) => {
-const myClickedTuples = [10];
-const ctrlKeyPressed = !!mouseEvent.ctrlKey;
-const selectOption = ctrlKeyPressed ? tableau.SelectOptions.Toggle : tableau.SelectOptions.Simple;
-
-tableau.extensions.worksheetContent.worksheet.selectTuplesAsync(myClickedTuples, selectOption, { tooltipAnchorPoint: { x: mouseEvent.pageX, y: mouseEvent.pageY } })
- .then(() => console.log('Done'))
- .catch((error) => console.log('Failed to select because of: ', error));
-});Returns empty promise that resolves when the extension host has successfully been informed of the request and rejects on error
-The WorksheetContent namespace is the namespace associated with Viz Extensions.
- The WorksheetContent namespace contains the Worksheet interface. Use the Worksheet Interface to
- access worksheet objects and to add or remove event listeners.
The tableau namespace exists for organization and to avoid polluting - the global namespace. It contains no constructs other than sub-namespaces and the Tableau enumerations.
-ZoneVisibilityType
-Not Initialized
- -Note Tableau 2020.2 introduced a new data model. To support that model, the Extensions API provides new methods and data structures starting with version 1.4 of the Extensions API library. In the new data model, a data source could have multiple logical tables, and logical tables can contain one or more physical tables. If you have an existing extension that uses one of the deprecated methods to get underlying data, the method call could fail if the data source contains more than one logical table. You should update your extensions to use these new methods. The new methods are backward compatible with previous versions of Tableau. - -For information about the data model, see The Tableau Data Model.
-Note If you are looking for information about how to add an extension to a dashboard in Tableau, see Use Dashboard Extensions. If you are looking for extensions that you can use, see the Tableau Exchange.
-| Name of element | -Description | -
|---|---|
manifest |
-The root element that contains the manifest options. | -
manifest-version |
-The version of the manifest. The version currently supported is 0.1. | -
dashboard-extension |
-The root element that contains the options for the extension. The dashboard-extension includes the id attribute, which follows the reverse domain name pattern (com.example.extension), and extension-version number attribute. These attributes are required. |
-
extension-version |
-The version of the extension. For example, extension-version="0.1.0" |
-
default-locale |
-Specifies the default locale to use for localized text. Here both the locale format (en_US) and language code (en) are accepted. The default locale specified here is converted to one of the supported languages in the Tableau UI. If the language is unsupported or invalid, English is set as default. | -
name |
-The name of the extension as it appears under Extensions on a dashboard sheet. To provide localized text, specify the name of the resource-id and provide the text strings in the resources element of the manifest (see the manifest example). You can provide localized strings for name and description. | -
description |
-A short description of the extension. | -
author |
-Specifies metadata about the author of the extension, including name, email address, organization, and website. The name and website attributes are required. The website URL must use HTTPS. The website URL is the target of the Get Support link that users see in the About dialog box for your extension. The URL should take users to a page where they can learn about your extension and can get help on using it. |
-
source-location |
-Contains the url of the server that hosts the web page you create that interacts with Tableau. |
-
url |
-Specifies the scheme (HTTPS, HTTTP), the name of the server, the port (optional) and the path to extension (optional). The url must use HTTPS. For example: https://example.com/extension.
-The exception is for localhost. In this case, HTTP is allowed. For example: http://localhost:8080. |
-
icon |
-If specified, the icon is what appears in the About dialog box. The icon must be a 70x70 pixel PNG file that is Base64 encoded. If you need an encoder, see https://www.base64-image.de/ | -
permissions |
-Declares the types of permissions that this extension requires. The only option is full data. If your extension can access the underlying data or information about the data sources, you must declare full data permission in the manifest. Full data permissions are required if you use any one of the following APIs: Worksheet.getUnderlyingDataAsync(), Datasource.getUnderlyingDataAsync(), Datasource.getActiveTablesAsync(), Datasource.getConnectionSummariesAsync(). If your extension does not use one of these APIs, you do not need include permissions element. |
-
context-menu |
-Adds a context menu item in the extension zone. This is a configuration feature that allows you to register a custom JavaScript callback function and associate it with a context menu item. The only allowed element in <context-menu> is <configure-context-menu-item />. The menu item and your configuration callback function are mapped together in the initializeAsync() function. When the extension is initialized, the menu item Configure... appears in the drop-down menu of the dashboard extension. When the user clicks the menu item, your callback function is executed. |
-
resources |
-Specifies the resources that can be localized. | -
min-api-version |
-Specifies the minimum API version required to run the extension. | -
selectMarksByValueAsync method has been corrected. If you are calling the method, be sure to specify the complete namespace for the `SelectionUpdateType` enum that is passed to the method as the `updateType` parameter. For example, use `tableau.SelectionUpdateType.Replace`, to replace the currently selected marks with the values you specify in the method call.
-
-----
-
-
-### Tableau 2019.1
-*February 2019*
-
-* Tableau Extensions API library: `tableau-extensions-1.1.0.js`
Can occur when two incompatible calls are triggered together.
-