Source: workspace.js

  1. goog.provide('sync.api.Workspace');
  3. goog.require('goog.events.EventTarget');
  4. goog.require('sync.api.FileBrowsingDialog');
  7. /**
  8.  * Access to the Workspace in which the editor is opened.
  9.  *
  10.  * @constructor
  11.  * @extends {goog.events.EventTarget}
  12.  */
  13. sync.api.Workspace = function() {
  14. };
  15. goog.inherits(sync.api.Workspace, goog.events.EventTarget);
  18. /**
  19.  * Sets the URL chooser used when the user is asked to provide an URL.
  20.  * When there is not chooser set, the user will usually have to enter the
  21.  * URLs in a text field.
  22.  *
  23.  * @param {sync.api.UrlChooser} urlChooser The URL chooser to set.
  24.  */
  25. sync.api.Workspace.prototype.setUrlChooser = function(urlChooser) {
  26. };
  29. /**
  30.  * Creates a dialog that can have custom content and behavior.
  31.  *
  32.  * The advandatage of using this method is that the dialog will have a consistent appearance with the rest of the application
  33.  * and that it will work on all devices supported by the WebApp.
  34.  *
  35.  * @param {string=} opt_id The id that will be given to the dialog box.
  36.  * For example, you can use it for specifying the width of the dialog in CSS.
  37.  *
  38.  * @return {sync.api.Dialog} The dialog.
  39.  */
  40. sync.api.Workspace.prototype.createDialog = function(opt_id) {
  41. };
  43. /**
  44.  * Returns the view manager helper object that can be used to customize Oxygen XML Web Author views.
  45.  *
  46.  * @return  {sync.view.ViewManager} The view manager.
  47.  */
  48. sync.api.Workspace.prototype.getViewManager = function() {
  49. };
  51. /**
  52.  * Returns an object that can be used to display notifications to the user.
  53.  *
  54.  * @return {sync.api.NotificationsManager} the notifications manager.
  55.  */
  56. sync.api.Workspace.prototype.getNotificationManager = function() {
  57. };
  59. /**
  60.  * Web Author prefers to insert the external references as relative URLs. It has a default algorithm to
  61.  * make an URL relative to a given base. However, you for certain URL protocols you can provide your own
  62.  * algorithm.
  63.  *
  64.  * @param {string} protocol The protocol handled by the resolver.
  65.  * @param {function(string, string)} resolver The relative references resolver. The first argument the URL used as a
  66.  * base for relativization and the second one is is the URL to make
  67.  * relative .
  68.  */
  69. sync.api.Workspace.prototype.addRelativeReferencesResolver = function(protocol, resolver) {
  70. };
  72. /**
  73.  * Makes an URL relative to the base.
  74.  *
  75.  * @param {string} base The relativization base, needs to be an absolute URL.
  76.  * @param {string} url The URL to make relative.
  77.  *
  78.  * @return {string} The relative URL.
  79.  */
  80. sync.api.Workspace.prototype.makeRelative = function(base, url) {
  81. };
  84. /**
  85.  * @typedef {Object} sync.api.Workspace.Options The object used to open the editor.
  86.  *
  87.  * @property {string=} 'selected.language' The current language.
  88.  *
  89.  * @property {string=} 'sentinels.display.mode' Controls the sentinels display mode.
  90.  * Possible values:
  91.  * <ul>
  92.  *   <li> no-tags - no tags.
  93.  *   <li> partial-tags - partial tags.
  94.  *   <li> inline-tags - inline tags.
  95.  *   <li> block-tags - block tags.
  96.  *   <li> full-tags - full tags.
  97.  *   <li> full-tags-with-attributes - full tags with attributes.
  98.  * </ul>
  99.  *
  100.  * @property {string=} 'spellcheck.enabled' controls whether the spellchecker is enabled or not. Possible values:
  101.  * <ul>
  102.  *  <li> true - The spellchecker is enabled.
  103.  *  <li> false - The spellchecker is disabled.
  104.  * </ul>
  105.  */
  107. /**
  108.  * Client options getter function.
  109.  *
  110.  * @param {string} optionKey {sync.api.Workspace.Options} property name.
  111.  * @param {string} defaultValue the default value to be returned in case the option is not set.
  112.  *
  113.  * @return {string} the set option. In case the option is not set it returns the defaultValue or null.
  114.  */
  115. sync.api.Workspace.prototype.getOption = function(optionKey, opt_defaultValue) {
  116. };
  118. /**
  119.  * Client options setter function.
  120.  *
  121.  * @param {string} optionKey {sync.api.Workspace.Options} property name.
  122.  * @param {string} newValue the option's new value.
  123.  */
  124. sync.api.Workspace.prototype.setOption = function(optionKey, newValue) {
  125. };
  127. /**
  128.  * Return the editing context manager.
  129.  *
  130.  * @return {sync.api.EditingContextManager} The editing context manager.
  131.  */
  132. sync.api.Workspace.prototype.getEditingContextManager = function() {
  133. };
  135. /**
  136.  * Returns the file servers manager helper object that can be used to register a descriptor that provides
  137.  * rendering information and file browsing functionality for a specific file server.
  138.  *
  139.  * @since 20.1.1
  140.  *
  141.  * @return {sync.api.FileServersManager} The file servers manager.
  142.  */
  143. sync.api.Workspace.prototype.getFileServersManager = function () {
  144. };
  146. /**
  147.  * Returns the editing support manager that can be used to create a specific {@link sync.api.EditingSupport} to the current
  148.  * editor.
  149.  *
  150.  * @since 21.1.1
  151.  *
  152.  * @return {sync.api.EditingSupportManager} The editing support manager.
  153.  */
  154. sync.api.Workspace.prototype.getEditingSupportManager = function () {
  155. };
  157. /**
  158.  * The types of the Workspace events.
  159.  *
  160.  * @enum {string}
  161.  */
  162. sync.api.Workspace.EventType = {
  163.   /**
  164.    * Triggered before the editor content was loaded.
  165.    *
  166.    * Note that frameworks code cannot use this event since the framework is detected while the document is loaded.
  167.    * <br/>
  168.    * See {@link sync.api.Workspace.BeforeEditorOpenedEvent} for more details.
  169.    */
  170.   BEFORE_EDITOR_LOADED: 'before_editor_loaded',
  171.   /**
  172.    * Triggered after the editor was loaded.
  173.    * <br/>
  174.    * See {@link sync.api.Workspace.EditorLifecycleEvent} for more details.
  175.    */
  176.   EDITOR_LOADED: 'editor_loaded',
  178.   /**
  179.    * Triggered after the editor was loaded.
  180.    * <br/>
  181.    * See {@link sync.api.Workspace.EditorLifecycleEvent} for more details.
  182.    */
  183.   EDITOR_LOADING_FAILED: 'editor_loading_failed',
  185.   /**
  186.    * Triggered when the editor was disposed.
  187.    * <br/>
  188.    * See {@link sync.api.Workspace.EditorLifecycleEvent} for more details.
  189.    */
  190.   EDITOR_DISPOSED: 'editor_disposed',
  192.   /**
  193.    * Triggered before the editor will be disposed.
  194.    * <br/>
  195.    * See {@link sync.api.Workspace.EditorLifecycleEvent} for more details.
  196.    */
  197.   BEFORE_EDITOR_DISPOSED: 'before_editor_disposed',
  199.   /**
  200.    * Triggered before the dashboard is loaded.
  201.    * <br/>
  202.    * See {@link sync.api.Workspace.DashboardLifecycleEvent} for more details.
  203.    */
  204.   BEFORE_DASHBOARD_LOADED: 'before_dashboard_loaded',
  205.   /**
  206.    * Triggered after the dashboard was loaded.
  207.    * <br/>
  208.    * See {@link sync.api.Workspace.DashboardLifecycleEvent} for more details.
  209.    */
  210.   DASHBOARD_LOADED: 'dashboard_loaded'
  211. };
  214. /**
  215.  * Event generated when an editor is loaded.
  216.  *
  217.  * <hr/>
  218.  * <p>
  219.  * Examples of listening for this event:
  220.  * </p>
  221.  * <pre>
  222.  * goog.events.listen(workspace, sync.api.Workspace.EventType.EDITOR_LOADED, function(e) {
  223.  *   // e is of type sync.api.Workspace.EditorLifecycleEvent
  224.  * });
  225.  * </pre>
  226.  * <pre>
  227.  * goog.events.listen(workspace, sync.api.Workspace.EventType.EDITOR_DISPOSED, function(e) {
  228.  *   // e is of type sync.api.Workspace.EditorLifecycleEvent
  229.  * });
  230.  * </pre>
  231.  * <pre>
  232.  * goog.events.listen(workspace, sync.api.Workspace.EventType.BEFORE_EDITOR_DISPOSED, function(e) {
  233.  *   // e is of type sync.api.Workspace.EditorLifecycleEvent
  234.  * });
  235.  * </pre>
  236.  *
  237.  * @param {string} type The type of the event.
  238.  * @param {sync.api.Editor} editor The editor that was changed.
  239.  *
  240.  * @constructor
  241.  */
  242. sync.api.Workspace.EditorLifecycleEvent = function(type, editor) {
  243.   this.type = type;
  245.   /**
  246.    * The editor which has been loaded.
  247.    * @type {sync.api.Editor}
  248.    */
  249.   this.editor = editor;
  250. };
  252. /**
  253.  * A function callback used to enhance the name of elements, as shown in the UI (breadcrumbs and tags), depending on their attributes.
  254.  * @callback ElementNameEnhancer
  255.  *
  256.  * @param {string} elementName The name of the XML element.
  257.  * @param {{}} elementAttrs The attributes stored in an object with the attribute names as keys and with a descriptor object as value.
  258.  * <pre>
  259.  * The descriptor contains:
  260.  *  - the value of the object (attributeValue).
  261.  *  - whether it's value comes from DTD or not (isDefaultValue).
  262.  *  - whether the attribute is hidden (isHidden).
  263.  * </pre>
  264.  *
  265.  * @return {string} A new name for the given XML element.
  266.  */
  268. /**
  269.  * @typedef {Object} sync.api.Workspace.LoadingOptions The object used to open the editor.
  270.  * @property {string} url The URL of the document.
  271.  * @property {string=} title The title of the document. If not specified, it is inferred from URL.
  272.  * @property {string=} userName The name of the user which will edit the document.
  273.  * Used as the author for comments and displayed in the top-right corner.
  274.  * If not specified, it is inferred from the <i>userName</i> URL variable.
  275.  * @property {string=} content The content of the document. If not specified, the server will load the content
  276.  * from the given URL.
  277.  * @property {string=} modes The available editing modes, comma-separated. If multiple values are passed
  278.  * in, the first one will be active and the user can switch to another one using the GUI. Possible values:
  279.  * <ul>
  280.  *  <li>review - only the review actions are enabled
  281.  *  <li>edit - full editing support is enabled
  282.  * </ul>
  283.  * @property {string=} trackChanges Flag that controls whether the editor should track changes or not. Possible values:
  284.  * <ul>
  285.  *  <li>default - The status of change tracking is determined by server's global options.
  286.  *  <li>enabled - Change tracking is enabled but the user can disable it using a toolbar action.
  287.  *  <li>forced - Change tracking is enabled and the user cannot disable it, not can she accept or reject any changes.
  288.  * </ul>
  289.  * If you use other option than 'default', the server change tracking status (as configured in the Administration Page)
  290.  * should not be "Stored in the document".
  291.  * @property {number=} autoSaveInterval the interval of time (in seconds) to wait until an auto-save is performed.
  292.  * If <= 0 or falsy, auto-save is disabled.
  293.  * @property {string=} contentType The content type of the edited document, "text/xml" for XML documents. The content encoding can be passed 'text/xml: charset=utf-8'.
  294.  * @property {boolean=} 'show.caret.position.info' Flag that controls whether to show caret tooltip or not.
  295.  * Have precedence over the server option. Default value is true.
  296.  * @property {string=} 'validate.as.you.type' Whether automatic validation should be enabled. Defaults to true.
  297.  * @property {string=} 'ccOnEnter'  Flag that controls whether the content completion list is presented when the user press 'Enter'. Has precedence over the
  298.  * value of "Show content completion list on Enter" server option (controlled from "General" option page).
  299.  * @property {ElementNameEnhancer} [elementNameEnhancer] A function which can enhance the name of elements depending on their attributes.
  300.  * @property {string|Array<string>} 'stylesheet-titles' A list of titles of CSS groups (defined in the framework) that will
  301.  * be used to render the document. The list can be passed either as a JS array or concatenated as a comma-separated string.
  302.  * @property {boolean=} expandTopicRefs If set to true, when a DITA map is opened in Oxygen XML Web Author, the content of all topics referenced in the map will be presented.
  303.  * @property {string=} KeyscopeStack (DITA-specific Parameter) Used for resolving keys when DITA 1.3 key scopes are defined in the DITA map.
  304.  * The value looks like this:  `a b c,d e f` for a DITA map that has the key scope defined like this: <topicref keyscope="a b c"><topicref keyscope="d e f"/></topicref>
  305.  * @property {number=} backupTimeout The time to wait, after an edit, before making a backup.
  306.  * @property {boolean=} 'compactTagsMode' Flag that controls whether the consecutive block tags are displayed on the same line
  307.  * (when the value is true) or on separate lines (when the value is false). Default value is true.
  308.  * @property {boolean=} 'quickUpDownNavigation' This option is false by default and this means that when the user navigates using
  309.  * the up and down arrow keys, the cursor is placed within each of the underlying XML elements between two blocks of text
  310.  * (the cursor changes to a horizontal line when it is between blocks of text). This allows to easily insert elements
  311.  * and manage the structure of the XML content. However, if this option is true, the cursor ignores the XML structure and
  312.  * jumps from one line of text to another, similar to how the cursor behaves in a word processor.
  313.  * @property {boolean=} 'textModeReadOnly' Flag that controls whether the text mode will be read-only. Defaults to false.
  314.  * @property {string=} 'schematron.imposed.phase' Used to impose a phase with that name in any Schematron file used for validation.
  315.  * @property {string=} 'schematronUrl' (Markdown only) Used to specify a Schematron file to validate the Markdown file with.
  316.  * It will only work for Markdown files, if the Markdown editing plugin is installed.
  317.  */
  319. /**
  320.  * Event generated before the editor is loaded. Its usage include:
  321.  * <ul>
  322.  *   <li> adding new actions to the editor's action manager.
  323.  *   <li> changing the startup options of the editor.
  324.  * </ul>
  325.  *
  326.  * If the options can only be computed asynchronously, one can cancel the editor loading
  327.  * with preventDefault and call
  328.  *
  329.  * <pre><code>editor.load(options);</code></pre>
  330.  *
  331.  * later to load the editor with the new options.
  332.  *
  333.  * <hr/>
  334.  * <p>
  335.  * Example of listening for this event:
  336.  * </p>
  337.  * <pre>
  338.  * goog.events.listen(workspace, sync.api.Workspace.EventType.BEFORE_EDITOR_LOADED, function(e) {
  339.  *   // e is of type sync.api.Workspace.BeforeEditorOpenedEvent
  340.  * });
  341.  * </pre>
  342.  *
  343.  * @param {string} type The type of the event.
  344.  * @param {sync.api.Editor} editor The editor that was loaded.
  345.  * @param {sync.api.Workspace.LoadingOptions} options The options used to open the editor.
  346.  *
  347.  * @constructor
  348.  */
  349. sync.api.Workspace.BeforeEditorOpenedEvent = function(type, editor, options) {
  350.   sync.api.Workspace.EditorLifecycleEvent.call(this, type, editor);
  351.   /**
  352.    * The options used to load the editor.
  353.    *
  354.    * If these options are changed during the {@link sync.api.Workspace.EventType.BEFORE_EDITOR_LOADED},
  355.    * they will be taken into account during the editor loading.
  356.    *
  357.    * @type {sync.api.Workspace.LoadingOptions}
  358.    */
  359.   this.options = options;
  360. };
  361. goog.inherits(sync.api.Workspace.BeforeEditorOpenedEvent, sync.api.Workspace.EditorLifecycleEvent);
  364. /**
  365.  * @typedef {Object} sync.api.Workspace.DashboardLoadingOptions The options used to open the dashboard.
  366.  * @property {string} folderUrl The URL of the folder to be opened on the dashboard.
  367.  */
  369. /**
  370.  * Event generated before and after the Dashboard is loaded.
  371.  *
  372.  * <hr/>
  373.  * <p>
  374.  * Example of listening for this event:
  375.  * </p>
  376.  * <pre>
  377.  * goog.events.listen(workspace, sync.api.Workspace.EventType.BEFORE_DASHBOARD_LOADED, function(e) {
  378.  * });
  379.  * goog.events.listen(workspace, sync.api.Workspace.EventType.DASHBOARD_LOADED, function(e) {
  380.  * });
  381.  * </pre>
  382.  *
  383.  *
  384.  * @param {string} type The type of the event.
  385.  * @param {sync.api.Workspace.DashboardLoadingOptions} options The options used to open the dashboard.
  386.  *
  387.  * @constructor
  388.  */
  389. sync.api.Workspace.DashboardLifecycleEvent = function(type, options) {
  390.   this.type = type;
  391.   this.options = options;
  392. };