Buttons

Xeditor contains pre-defined buttons that may be used by calling its alias (see Internal toolbar).

Note

For pre-defined DITA buttons please see DITA Buttons.

The following is a reference to all the pre-configured buttons used by Xeditor.

Core buttons

Ext.ux.xeditor.Config.addConfigGenerator(function (editor) {
    return {
        'button:button': {
            // icon: undefined,
            // contextSensitive: undefined,
            // tooltip: undefined,
            // text: undefined,
            // data: undefined,
            // listeners: undefined,
            textMode: 'menu'

        },
        'button:xeditor.save': {
            extend: 'button:button',
            icon: 'fa-floppy-o',
            contextSensitive: true,
            tooltip: global_phrases['global.save'],
            data: {
                toolbarType: 'save',
                localStorageSave: true,
                downloadDocument: true
            },
            listeners: {
                click: editor.eventManager.onSaveButtonClickBound
            }
        },
        'button:xeditor.copy': {
            extend: 'button:button',
            icon: 'fa-copy',
            contextSensitive: true,
            tooltip: global_phrases['global.copy'],
            data: {
                toolbarType: 'copy'
            },
            listeners: {
                click: editor.clipboardManager.onCopyButtonClickBound
            }
        },
        'button:xeditor.cut': {
            extend: 'button:button',
            icon: 'fa-scissors',
            contextSensitive: true,
            tooltip: global_phrases['xeditor.cut'],
            data: {
                toolbarType: 'cut'
            },
            listeners: {
                click: editor.clipboardManager.onCutButtonClickBound
            }
        },
        'button:xeditor.paste': {
            extend: 'button:button',
            icon: 'fa-clipboard',
            contextSensitive: true,
            tooltip: global_phrases['global.paste'],
            textMode: 'menu',
            data: {
                toolbarType: 'paste'
            },
            listeners: {
                click: editor.clipboardManager.onPasteButtonClickBound
            }
        },
        'button:xeditor.pasteexternal': {
            extend: 'button:button',
            icon: 'fa-clipboard',
            contextSensitive: true,
            tooltip: global_phrases['xeditor.pasteexternal'],
            text: global_phrases['xeditor.pasteexternal.text'],
            textMode: 'always',
            data: {
                toolbarType: 'pasteexternal'
            },
            listeners: {
                click: editor.clipboardManager.onPasteExternalButtonClickBound
            }
        },
        'button:xeditor.pasteoffice': {
            extend: 'button:button',
            icon: 'fa-file-word-o',
            contextSensitive: true,
            tooltip: global_phrases['xeditor.pasteoffice'],
            textMode: 'menu',
            data: {
                toolbarType: 'pasteoffice'
            },
            listeners: {
                click: editor.clipboardManager.onPasteOfficeButtonClickBound
            }
        },
        'button:xeditor.undo': {
            extend: 'button:button',
            icon: 'fa-undo',
            contextSensitive: true,
            data: {
                toolbarType: 'historyUndo'
            },
            tooltip: global_phrases['xeditor.undo'],
            listeners: {
                click: editor.historyManager.onUndoButtonClickBound
            }
        },
        'button:xeditor.redo': {
            extend: 'button:button',
            icon: 'fa-repeat',
            contextSensitive: true,
            data: {
                toolbarType: 'historyRedo'
            },
            tooltip: global_phrases['xeditor.redo'],
            listeners: {
                click: editor.historyManager.onRedoButtonClickBound
            }
        },
        'button:xeditor.find': {
            extend: 'button:button',
            icon: 'fa-search',
            contextSensitive: false,
            tooltip: global_phrases['xeditor.find'],
            listeners: {
                click: editor.eventManager.onFindReplaceButtonClickBound
            }
        },
        'button:xeditor.insert': {
            extend: 'button:button',
            contextSensitive: true,
            tooltip: global_phrases['xeditor.insert'],
            data: {
                toolbarType: 'insert',
                elementType: null
            },
            listeners: {
                click: editor.eventManager.onInsertButtonClickBound
            }
        },
        'button:xeditor.insertOrEdit': {
            extend: 'button:button',
            contextSensitive: true,
            tooltip: global_phrases['xeditor.tags.insertoredit'],
            data: {
                toolbarType: 'insertOrEdit'
            },
            listeners: {
                click: editor.eventManager.onInsertOrEditButtonClickBound
            }
        }
    }
});

Changel Element Level Button

Ext.ux.xeditor.Config.addConfigGenerator(function (editor) {
    // get plugin
    var plugins = editor.getPluginsByType('uxxeditorchangeelementlevel');

    // check that changeelementlevel plugin exists
    if (!plugins || !plugins.length) {
        return {};
    }

    // return config
    return {
        'button:xeditor.indent': {
            icon: 'fa-indent',
            contextSensitive: true,
            tooltip:  global_phrases['xeditor.indent'],
            text:  global_phrases['xeditor.indent'],
            textMode: 'menu',
            data: {
                toolbarType: 'moveItemIn',
                pluginManagerId: true,
                pluginId: false,
                moveType: 'in'
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onMoveItemClickBound')
            }
        },
        'button:xeditor.outdent': {
            icon: 'fa-outdent',
            contextSensitive: true,
            tooltip:  global_phrases['xeditor.outdent'],
            text:  global_phrases['xeditor.outdent'],
            textMode: 'menu',
            data: {
                toolbarType: 'moveItemOut',
                pluginManagerId: true,
                pluginId: false,
                moveType: 'out'
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onMoveItemClickBound')
            }
        }
    }
});

Change Tracker Button

Ext.ux.xeditor.Config.addConfigGenerator(function (editor) {
    // get plugin
    var plugins = editor.getPluginsByType('uxxeditorchangetracker');

    // check that changetracker plugin exists
    if (!plugins || !plugins.length) {
        return {};
    }

    // return config
    return {
        'button:xeditor.changetracker': {
            icon: 'fa-eye',
            contextSensitive: true,
            text: global_phrases['xeditor.changetracker.trackchanges'],
            textMode: 'menu',
            checked: true,
            data: {
                toolbarType: 'changeTrackerEnableToggle',
                pluginId: false
            },
            listeners: {
                toggle: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onEnableButtonToggleBound')
            }
        },
        'button:xeditor.changetracker.previous': {
            icon: 'fa-arrow-left',
            contextSensitive: true,
            text: global_phrases['xeditor.changetracker.previous'],
            textMode: 'menu',
            data: {
                toolbarType: 'changeTrackerSelectPrevious',
                pluginId: false,
                forward: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onSelectChangeButtonClickBound')
            }
        },
        'button:xeditor.changetracker.next': {
            icon: 'fa-arrow-right',
            contextSensitive: true,
            text: global_phrases['xeditor.changetracker.next'],
            data: {
                toolbarType: 'changeTrackerSelectNext',
                pluginId: false,
                forward: true
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onSelectChangeButtonClickBound')
            }
        },
        'button:xeditor.changetracker.commit': {
            icon: 'fa-check',
            contextSensitive: true,
            text: global_phrases['xeditor.changetracker.commitselected'],
            textMode: 'menu',
            data: {
                toolbarType: 'changeTrackerCommitSelected',
                pluginId: false,
                all: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onCommitChangesButtonClickBound')
            }
        },
        'button:xeditor.changetracker.revert': {
            icon: 'fa-undo',
            contextSensitive: true,
            text: global_phrases['xeditor.changetracker.revertselected'],
            textMode: 'menu',
            data: {
                toolbarType: 'changeTrackerRevertSelected',
                pluginId: false,
                all: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onRevertChangesButtonClickBound')
            }
        }
    }
});

Character Picker Buttons

Ext.ux.xeditor.Config.addConfigGenerator(function (editor) {
    // get plugin
    var plugins = editor.getPluginsByType('uxxeditorcharacterpicker');

    // check that characterpicker plugin exists
    if (!plugins || !plugins.length) {
        return {};
    }

    // return config
    return {
        'button:xeditor.characterpicker': {
            icon: 'fa-eur',
            contextSensitive: true,
            tooltip: global_phrases['xeditor.characterpicker.symbol'],
            text: global_phrases['xeditor.characterpicker.symbol'],
            textMode: 'menu',
            data: {
                toolbarType: 'characterPicker',
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onCharacterPickerButtonClickBound')
            }
        }
    }
});

Comment Buttons

Ext.ux.xeditor.Config.addConfigGenerator(function (editor) {
    // get plugin
    var plugins = editor.getPluginsByType('uxxeditorcomment');

    // check that comment plugin exists
    if (!plugins || !plugins.length) {
        return {};
    }

    // return config
    return {
        'button:xeditor.comment': {
            icon: 'fa-comment',
            contextSensitive: true,
            tooltip: global_phrases['xeditor.comment.comment'],
            text: global_phrases['xeditor.comment.comment'],
            textMode: 'menu',
            data: {
                toolbarType: 'commentCreate',
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onCommentButtonClickBound')
            }
        },

        'button:xeditor.comment.previous': {
            icon: 'fa-arrow-left',
            contextSensitive: true,
            tooltip: global_phrases['xeditor.comment.previous'],
            text: global_phrases['xeditor.comment.previous'],
            textMode: 'menu',
            data: {
                toolbarType: 'commentSelectPrevious',
                pluginId: false,
                forward: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onSelectCommentButtonClickBound')
            }
        },

        'button:xeditor.comment.next': {
            icon: 'fa-arrow-right',
            contextSensitive: true,
            tooltip: global_phrases['xeditor.comment.next'],
            text: global_phrases['xeditor.comment.next'],
            textMode: 'menu',
            data: {
                toolbarType: 'commentSelectNext',
                pluginId: false,
                forward: true
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onSelectCommentButtonClickBound')
            }
        }
    }
});

HTML Table Buttons

Ext.ux.xeditor.Config.addConfigGenerator(function (editor) {
    // get plugin
    var plugins = editor.getPluginsByType('uxxeditorhtmltable');

    // check that comment plugin exists
    if (!plugins || !plugins.length) {
        return {};
    }

    // return config
    return {
        'button:xeditor.table.insertrowbefore': {
            contextSensitive: true,
            text: global_phrases['xeditor.table.insertrowbefore'],
            textMode: 'always',
            data: {
                toolbarType: 'htmlTableInsertRowBefore',
                before: true,
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onInsertRowButtonClickBound')
            }
        },
        'button:xeditor.table.insertrowafter': {
            contextSensitive: true,
            text: global_phrases['xeditor.table.insertrowafter'],
            textMode: 'always',
            data: {
                toolbarType: 'htmlTableInsertRowAfter',
                before: false,
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onInsertRowButtonClickBound')
            }
        },
        'button:xeditor.table.deleterow': {
            contextSensitive: true,
            text: global_phrases['xeditor.table.deleterow'],
            textMode: 'always',
            data: {
                toolbarType: 'htmlTableRemoveRow',
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onDeleteRowButtonClickBound')
            }
        },
        'button:xeditor.table.moverowup': {
            contextSensitive: true,
            text: global_phrases['xeditor.table.moverowup'],
            textMode: 'always',
            data: {
                toolbarType: 'htmlTableMoveRowBefore',
                before: true,
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onMoveRowButtonClickBound')
            }
        },
        'button:xeditor.table.moverowdown': {
            contextSensitive: true,
            text: global_phrases['xeditor.table.moverowdown'],
            textMode: 'always',
            data: {
                toolbarType: 'htmlTableMoveRowAfter',
                before: false,
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onMoveRowButtonClickBound')
            }
        },
        'button:xeditor.table.insertcolumnbefore': {
            contextSensitive: true,
            text: global_phrases['xeditor.table.insertcolumnbefore'],
            textMode: 'always',
            data: {
                toolbarType: 'htmlTableInsertColumnBefore',
                before: true,
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onInsertColumnButtonClickBound')
            }
        },
        'button:xeditor.table.insertcolumnafter': {
            contextSensitive: true,
            text: global_phrases['xeditor.table.insertcolumnafter'],
            textMode: 'always',
            data: {
                toolbarType: 'htmlTableInsertColumnAfter',
                before: false,
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onInsertColumnButtonClickBound')
            }
        },
        'button:xeditor.table.deletecolumn': {
            contextSensitive: true,
            text: global_phrases['xeditor.table.deletecolumn'],
            textMode: 'always',
            data: {
                toolbarType: 'htmlTableRemoveColumn',
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onDeleteColumnButtonClickBound')
            }
        },
        'button:xeditor.table.movecolumnleft': {
            contextSensitive: true,
            text: global_phrases['xeditor.table.movecolumnleft'],
            textMode: 'always',
            data: {
                toolbarType: 'htmlTableMoveColumnBefore',
                before: true,
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onMoveColumnButtonClickBound')
            }
        },
        'button:xeditor.table.movecolumnright': {
            contextSensitive: true,
            text: global_phrases['xeditor.table.movecolumnright'],
            textMode: 'always',
            data: {
                toolbarType: 'htmlTableMoveColumnAfter',
                before: false,
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onMoveColumnButtonClickBound')
            }
        },
        'button:xeditor.table.mergeright': {
            contextSensitive: true,
            text: global_phrases['xeditor.table.mergeright'],
            textMode: 'always',
            data: {
                toolbarType: 'htmlTableMergeCellRight',
                before: false,
                horizontal: true,
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onMergeButtonClickBound')
            }
        },
        'button:xeditor.table.mergeleft': {
            contextSensitive: true,
            text: global_phrases['xeditor.table.mergeleft'],
            textMode: 'always',
            data: {
                toolbarType: 'htmlTableMergeCellLeft',
                before: true,
                horizontal: true,
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onMergeButtonClickBound')
            }
        },
        'button:xeditor.table.mergeup': {
            contextSensitive: true,
            text: global_phrases['xeditor.table.mergeup'],
            textMode: 'always',
            data: {
                toolbarType: 'htmlTableMergeCellTop',
                before: true,
                horizontal: false,
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onMergeButtonClickBound')
            }
        },
        'button:xeditor.table.mergedown': {
            contextSensitive: true,
            text: global_phrases['xeditor.table.mergedown'],
            textMode: 'always',
            data: {
                toolbarType: 'htmlTableMergeCellBottom',
                before: false,
                horizontal: false,
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onMergeButtonClickBound')
            }
        },
        'button:xeditor.table.splitcolumn': {
            contextSensitive: true,
            text: global_phrases['xeditor.table.splitcolumn'],
            textMode: 'always',
            data: {
                toolbarType: 'htmlTableSplitCellHorizontal',
                horizontal: true,
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onSplitButtonClickBound')
            }
        },
        'button:xeditor.table.splitrow': {
            contextSensitive: true,
            text: global_phrases['xeditor.table.splitrow'],
            textMode: 'always',
            data: {
                toolbarType: 'htmlTableSplitCellVertical',
                horizontal: false,
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onSplitButtonClickBound')
            }
        }
    }
});

Inline Format Buttons

Ext.ux.xeditor.Config.addConfigGenerator(function (editor) {
    // get plugin
    var plugins = editor.getPluginsByType('uxxeditorinlineformat');

    // check that comment plugin exists
    if (!plugins || !plugins.length) {
        return {};
    }

    // return config
    return {
        'button:xeditor.inlineformat': {
            contextSensitive: true,
            textMode: 'menu',
            checked: false,
            data: {
                toolbarType: 'inlineFormat',
                pluginId: false
            },
            listeners: {
                toggle: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onInlineFormatButtonToggleBound')
            }
        }
    }
});

List Features Button

Ext.ux.xeditor.Config.addConfigGenerator(function (editor) {
    // get plugin
    var plugins = editor.getPluginsByType('uxxeditorlistfeatures');

    // check that the plugin exists
    if (!plugins || !plugins.length) {
        return {};
    }

    // return config
    return {
        'button:xeditor.indent': {
            icon: 'fa-indent',
            contextSensitive: true,
            tooltip:  global_phrases['xeditor.indent'],
            text:  global_phrases['xeditor.indent'],
            textMode: 'menu',
            data: {
                toolbarType: 'moveItemIn',
                pluginManagerId: true,
                pluginId: false,
                moveType: 'in'
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onMoveItemClickBound')
            }
        },
        'button:xeditor.outdent': {
            icon: 'fa-outdent',
            contextSensitive: true,
            tooltip:  global_phrases['xeditor.outdent'],
            text:  global_phrases['xeditor.outdent'],
            textMode: 'menu',
            data: {
                toolbarType: 'moveItemOut',
                pluginManagerId: true,
                pluginId: false,
                moveType: 'out'
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onMoveItemClickBound')
            }
        }
    }
});

Raw Editor Buttons

Ext.ux.xeditor.Config.addConfigGenerator(function (editor) {
    // get plugin
    var plugins = editor.getPluginsByType('uxxeditorraweditor');

    // check that comment plugin exists
    if (!plugins || !plugins.length) {
        return {};
    }

    // return config
    return {
        'button:xeditor.raweditor': {
            icon: 'fa-pencil',
            text: global_phrases['xeditor.raweditor'],
            textMode: 'always',
            data: {
                formatXml: true,
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onRawEditorButtonClickBound')
            }
        }
    }
});

Spellchecker Buttons

Ext.ux.xeditor.Config.addConfigGenerator(function (editor) {
    // get plugin
    var plugins = editor.getPluginsByType('uxxeditorspellchecker');

    // check that comment plugin exists
    if (!plugins || !plugins.length) {
        return {};
    }

    // return config
    return {
        'button:xeditor.spellchecker.spellcheck': {
            icon: 'fa-file-text-o',
            contextSensitive: false,
            text: global_phrases['xeditor.spellchecker.spellcheck'],
            textMode: 'menu',
            data: {
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onCheckTextButtonClickBound')
            }
        },

        'button:xeditor.spellchecker.configure': {
            icon: 'fa-check',
            contextSensitive: false,
            text: global_phrases['xeditor.spellchecker.config'],
            textMode: 'menu',
            data: {
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onConfigDialogButtonClickBound')
            }
        },

        'button:xeditor.spellchecker.remove': {
            icon: 'fa-close',
            contextSensitive: false,
            text: global_phrases['xeditor.spellchecker.remove'],
            textMode: 'menu',
            data: {
                pluginId: false
            },
            listeners: {
                click: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onRemoveAllButtonClickBound')
            }
        }
    }
});

Tag Visualizer Buttons

Ext.ux.xeditor.Config.addConfigGenerator(function (editor) {
    // get plugin
    var plugins = editor.getPluginsByType('uxxeditortagvisualizer');

    // check that changetracker plugin exists
    if (!plugins || !plugins.length) {
        return {};
    }

    // return config
    return {
        'button:xeditor.tagvisualizer': {
            icon: 'fa-code',
            contextSensitive: false,
            text: global_phrases['xeditor.tagvisualizer.showtags'],
            textMode: 'menu',
            checked: false,
            data: {
                pluginId: false
            },
            listeners: {
                toggle: Ext.ux.xeditor.Util.generatePluginButtonListener(editor, plugins, 'onTagVisualizerButtonToggleBound')
            }
        }
    }
});

Demo Schema Buttons

Ext.ux.xeditor.Config.addConfigGenerator(function(editor) {
    return {
        "button:xeditor.demo.chapter": {
            extend: 'xeditor.insert',
            icon: 'fa-bookmark',
            tooltip: global_phrases['xeditor.tags.chapter'],
            contextSensitive: true,
            data: {
                toolbarType: 'insert',
                elementType: 'chapter'
            }
        },
        "button:xeditor.demo.subheading": {
            extend: 'xeditor.insert',
            icon: 'fa-header',
            tooltip: global_phrases['xeditor.tags.subheading'],
            contextSensitive: true,
            data: {
                toolbarType: 'insert',
                elementType: 'subheading'
            }
        },
        "button:xeditor.demo.bold": {
            extend: 'xeditor.inlineformat',
            icon: 'fa-bold',
            tooltip: global_phrases['xeditor.tags.bold'],
            contextSensitive: true,
            data: {
                toolbarType: 'inlineFormat',
                elementType: 'bold'
            }
        },
        "button:xeditor.demo.italic": {
            extend: 'xeditor.inlineformat',
            icon: 'fa-italic',
            tooltip: global_phrases['xeditor.tags.italic'],
            contextSensitive: true,
            data: {
                toolbarType: 'inlineFormat',
                elementType: 'italic'
            }
        },
        "button:xeditor.demo.underline": {
            extend: 'xeditor.inlineformat',
            icon: 'fa-underline',
            tooltip: global_phrases['xeditor.tags.underline'],
            contextSensitive: true,
            data: {
                toolbarType: 'inlineFormat',
                elementType: 'underline'
            }
        },
        "button:xeditor.demo.subscript": {
            extend: 'xeditor.inlineformat',
            icon: 'fa-subscript',
            tooltip: global_phrases['xeditor.tags.subscript'],
            contextSensitive: true,
            data: {
                toolbarType: 'inlineFormat',
                elementType: 'subscript'
            }
        },
        "button:xeditor.demo.superscript": {
            extend: 'xeditor.inlineformat',
            icon: 'fa-superscript',
            tooltip: global_phrases['xeditor.tags.superscript'],
            contextSensitive: true,
            data: {
                toolbarType: 'inlineFormat',
                elementType: 'superscript'
            }
        },
        "button:xeditor.demo.link": {
            extend: 'xeditor.insertOrEdit',
            icon: 'fa-link',
            tooltip: global_phrases['xeditor.tags.link'],
            contextSensitive: true,
            data: {
                toolbarType: 'insert',
                elementType: 'link'
            }
        },
        "button:xeditor.demo.list_ordered": {
            extend: 'xeditor.insert',
            icon: 'fa-list-ol',
            tooltip: global_phrases['xeditor.tags.list_ordered'],
            contextSensitive: true,
            data: {
                toolbarType: 'insert',
                elementType: 'list_ordered'
            }
        },
        "button:xeditor.demo.list_unordered": {
            extend: 'xeditor.insert',
            icon: 'fa-list-ul',
            tooltip: global_phrases['xeditor.tags.list_unordered'],
            contextSensitive: true,
            data: {
                toolbarType: 'insert',
                elementType: 'list_unordered'
            }
        },
        "button:xeditor.demo.tab_table": {
            icon: 'fa-table',
            tooltip: global_phrases['xeditor.tags.tab_table'],
            contextSensitive: true,
            data: {
                toolbarType: 'insert',
                elementType: 'tab_table'
            },
            listeners: {
                scope: editor,
                click: function(button, e, eOpts) {
                    this.configObj.configData.showInsertTableDialog(editor);
                }
            }
        },
        "button:xeditor.demo.box": {
            extend: 'xeditor.insert',
            icon: 'fa-square-o',
            tooltip: global_phrases['xeditor.tags.box'],
            contextSensitive: true,
            data: {
                toolbarType: 'insert',
                elementType: 'box'
            }
        },
        "button:xeditor.demo.footnote": {
            extend: 'xeditor.insert',
            icon: 'fa-paw',
            tooltip: global_phrases['xeditor.tags.footnote'],
            contextSensitive: true,
            data: {
                toolbarType: 'insert',
                elementType: 'footnote'
            }
        },
        "button:xeditor.demo.med_image": {
            extend: 'xeditor.insertOrEdit',
            icon: 'fa-picture-o',
            tooltip: global_phrases['xeditor.tags.med_image'],
            contextSensitive: true,
            data: {
                toolbarType: 'insertOrEdit',
                elementType: 'med_image'
            }
        },
        "button:xeditor.demo.med_video": {
            extend: 'xeditor.insertOrEdit',
            icon: 'fa-film',
            tooltip: global_phrases['xeditor.tags.med_video'],
            contextSensitive: true,
            data: {
                toolbarType: 'insertOrEdit',
                elementType: 'med_video'
            }
        },
        "button:xeditor.demo.formula": {
            icon: 'fa-flask',
            tooltip: global_phrases['xeditor.tags.formula'],
            menu: [
                {
                    extend: 'xeditor.insertOrEdit',
                    text: global_phrases['xeditor.tags._mathmlcontainer'],
                    data: {
                        elementType: '_mathmlcontainer'
                    }
                },
                {
                    extend: 'xeditor.insertOrEdit',
                    text: global_phrases['xeditor.tags._texcontainer'],
                    data: {
                        elementType: '_texcontainer'
                    }
                }
            ]
        }
    };
});