upgrade

main/inc/lib/javascript/wodotexteditor/Tools.js

@@ -0,0 +1,317 @@
+/**
+ * Copyright (C) 2013 KO GmbH <copyright@kogmbh.com>
+ *
+ * @licstart
+ * This file is part of WebODF.
+ *
+ * WebODF is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License (GNU AGPL)
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * WebODF is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with WebODF.  If not, see <http://www.gnu.org/licenses/>.
+ * @licend
+ *
+ * @source: http://www.webodf.org/
+ * @source: https://github.com/kogmbh/WebODF/
+ */
+
+/*global window, define, require, document, dijit, dojo, runtime, ops*/
+
+define("webodf/editor/Tools", [
+    "dojo/ready",
+    "dijit/MenuItem",
+    "dijit/DropDownMenu",
+    "dijit/form/Button",
+    "dijit/form/DropDownButton",
+    "dijit/Toolbar",
+    "webodf/editor/widgets/paragraphAlignment",
+    "webodf/editor/widgets/simpleStyles",
+    "webodf/editor/widgets/undoRedoMenu",
+    "webodf/editor/widgets/toolbarWidgets/currentStyle",
+    "webodf/editor/widgets/annotation",
+    "webodf/editor/widgets/editHyperlinks",
+    "webodf/editor/widgets/imageInserter",
+    "webodf/editor/widgets/paragraphStylesDialog",
+    "webodf/editor/widgets/zoomSlider",
+    "webodf/editor/widgets/aboutDialog",
+    "webodf/editor/EditorSession"],
+    function (ready, MenuItem, DropDownMenu, Button, DropDownButton, Toolbar, ParagraphAlignment, SimpleStyles, UndoRedoMenu, CurrentStyle, AnnotationControl, EditHyperlinks, ImageInserter, ParagraphStylesDialog, ZoomSlider, AboutDialog, EditorSession) {
+        "use strict";
+
+        return function Tools(toolbarElementId, args) {
+            var tr = runtime.tr,
+                onToolDone = args.onToolDone,
+                loadOdtFile = args.loadOdtFile,
+                saveOdtFile = args.saveOdtFile,
+                saveAsOdtFile = args.saveAsOdtFile,
+                downloadOdtFile = args.downloadOdtFile,
+                close = args.close,
+                toolbar,
+                loadButton, saveButton, closeButton, aboutButton,
+                saveAsButton, downloadButton,
+                formatDropDownMenu, formatMenuButton,
+                paragraphStylesMenuItem, paragraphStylesDialog,
+                editorSession,
+                aboutDialog,
+                sessionSubscribers = [];
+
+            function placeAndStartUpWidget(widget) {
+                widget.placeAt(toolbar);
+                widget.startup();
+            }
+
+            /**
+             * Creates a tool and installs it, if the enabled flag is set to true.
+             * Only supports tool classes whose constructor has a single argument which
+             * is a callback to pass the created widget object to.
+             * @param {!function(new:Object, function(!Object):undefined)} Tool  constructor method of the tool
+             * @param {!boolean} enabled
+             * @param {!Object|undefined=} config
+             * @return {?Object}
+             */
+            function createTool(Tool, enabled, config) {
+                var tool = null;
+
+                if (enabled) {
+                    if (config) {
+                        tool = new Tool(config, placeAndStartUpWidget);
+                    } else {
+                        tool = new Tool(placeAndStartUpWidget);
+                    }
+                    sessionSubscribers.push(tool);
+                    tool.onToolDone = onToolDone;
+                    tool.setEditorSession(editorSession);
+                }
+
+                return tool;
+            }
+
+            function handleCursorMoved(cursor) {
+                var disabled = cursor.getSelectionType() === ops.OdtCursor.RegionSelection;
+                if (formatMenuButton) {
+                    formatMenuButton.setAttribute('disabled', disabled);
+                }
+            }
+
+            function setEditorSession(session) {
+                if (editorSession) {
+                    editorSession.unsubscribe(EditorSession.signalCursorMoved, handleCursorMoved);
+                }
+
+                editorSession = session;
+                if (editorSession) {
+                    editorSession.subscribe(EditorSession.signalCursorMoved, handleCursorMoved);
+                }
+
+                sessionSubscribers.forEach(function (subscriber) {
+                    subscriber.setEditorSession(editorSession);
+                });
+
+                [saveButton, saveAsButton, downloadButton, closeButton, formatMenuButton].forEach(function (button) {
+                    if (button) {
+                        button.setAttribute('disabled', !editorSession);
+                    }
+                });
+            }
+
+            this.setEditorSession = setEditorSession;
+
+            /**
+             * @param {!function(!Error=)} callback, passing an error object in case of error
+             * @return {undefined}
+             */
+            this.destroy = function (callback) {
+                // TODO:
+                // 1. We don't want to use `document`
+                // 2. We would like to avoid deleting all widgets
+                // under document.body because this might interfere with
+                // other apps that use the editor not-in-an-iframe,
+                // but dojo always puts its dialogs below the body,
+                // so this works for now. Perhaps will be obsoleted
+                // once we move to a better widget toolkit
+                var widgets = dijit.findWidgets(document.body);
+                dojo.forEach(widgets, function(w) {
+                    w.destroyRecursive(false);
+                });
+                callback();
+            };
+
+            // init
+            ready(function () {
+                toolbar = new Toolbar({}, toolbarElementId);
+
+                // About
+                if (args.aboutEnabled) {
+                    aboutButton = new Button({
+                        label: tr('About WebODF Text Editor'),
+                        showLabel: false,
+                        iconClass: 'webodfeditor-dijitWebODFIcon'
+                    });
+                    aboutDialog = new AboutDialog(function (dialog) {
+                        aboutButton.onClick = function () {
+                            dialog.startup();
+                            dialog.show();
+                        };
+                    });
+                    aboutDialog.onToolDone = onToolDone;
+                    aboutButton.placeAt(toolbar);
+                }
+
+                // Load
+                if (loadOdtFile) {
+                    loadButton = new Button({
+                        label: tr('Open'),
+                        showLabel: false,
+                        iconClass: 'dijitIcon dijitIconFolderOpen',
+                        onClick: function () {
+                            loadOdtFile();
+                        }
+                    });
+                    loadButton.placeAt(toolbar);
+                }
+
+                // Save
+                if (saveOdtFile) {
+                    saveButton = new Button({
+                        label: tr('Save'),
+                        showLabel: false,
+                        disabled: true,
+                        iconClass: 'dijitEditorIcon dijitEditorIconSave',
+                        onClick: function () {
+                            saveOdtFile();
+                            onToolDone();
+                        }
+                    });
+                    saveButton.placeAt(toolbar);
+                }
+
+                // SaveAs
+                if (saveAsOdtFile) {
+                    saveAsButton = new Button({
+                        label: tr('Save as...'),
+                        showLabel: false,
+                        disabled: true,
+                        iconClass: 'webodfeditor-dijitSaveAsIcon',
+                        onClick: function () {
+                            saveAsOdtFile();
+                            onToolDone();
+                        }
+                    });
+                    saveAsButton.placeAt(toolbar);
+                }
+
+                // Download
+                if (downloadOdtFile) {
+                    downloadButton = new Button({
+                        label: tr('Download'),
+                        showLabel: true,
+                        disabled: true,
+                        style: {
+                            float: 'right'
+                        },
+                        onClick: function () {
+                            downloadOdtFile();
+                            onToolDone();
+                        }
+                    });
+                    downloadButton.placeAt(toolbar);
+                }
+
+                // Format menu
+                if (args.paragraphStyleEditingEnabled) {
+                    formatDropDownMenu = new DropDownMenu({});
+                    paragraphStylesMenuItem = new MenuItem({
+                        label: tr("Paragraph...")
+                    });
+                    formatDropDownMenu.addChild(paragraphStylesMenuItem);
+
+                    paragraphStylesDialog = new ParagraphStylesDialog(function (dialog) {
+                        paragraphStylesMenuItem.onClick = function () {
+                            if (editorSession) {
+                                dialog.startup();
+                                dialog.show();
+                            }
+                        };
+                    });
+                    sessionSubscribers.push(paragraphStylesDialog);
+                    paragraphStylesDialog.onToolDone = onToolDone;
+
+                    formatMenuButton = new DropDownButton({
+                        dropDown: formatDropDownMenu,
+                        disabled: true,
+                        label: tr('Format'),
+                        iconClass: "dijitIconEditTask"
+                    });
+                    formatMenuButton.placeAt(toolbar);
+                }
+
+                // Undo/Redo
+                createTool(UndoRedoMenu, args.undoRedoEnabled);
+
+                // Add annotation
+                createTool(AnnotationControl, args.annotationsEnabled);
+
+                // Simple Style Selector [B, I, U, S]
+                createTool(SimpleStyles, args.directTextStylingEnabled);
+
+                // Paragraph direct alignment buttons
+                createTool(ParagraphAlignment, args.directParagraphStylingEnabled);
+
+                // Paragraph Style Selector
+                createTool(CurrentStyle, args.paragraphStyleSelectingEnabled);
+
+                // Zoom Level Selector
+                createTool(ZoomSlider, args.zoomingEnabled);
+
+                // hyper links
+                createTool(EditHyperlinks, args.hyperlinkEditingEnabled);
+
+                // image insertion
+                createTool(ImageInserter, args.imageInsertingEnabled);
+
+                // close button
+                if (close) {
+                    closeButton = new Button({
+                        label: tr('Close'),
+                        showLabel: false,
+                        disabled: true,
+                        iconClass: 'dijitEditorIcon dijitEditorIconCancel',
+                        style: {
+                            float: 'right'
+                        },
+                        onClick: function () {
+                            close();
+                        }
+                    });
+                    closeButton.placeAt(toolbar);
+                }
+
+                // This is an internal hook for debugging/testing.
+                // Yes, you discovered something interesting. But:
+                // Do NOT rely on it, it will not be supported and can and will change in any version.
+                // It is not officially documented for a reason. A real plugin system is only on the wishlist
+                // so far, please file your suggestions/needs at the official WebODF issue system.
+                // You have been warned.
+                if (window.wodo_plugins) {
+                    window.wodo_plugins.forEach(function (plugin) {
+                        runtime.log("Creating plugin: "+plugin.id);
+                        require([plugin.id], function (Plugin) {
+                            runtime.log("Creating as tool now: "+plugin.id);
+                            createTool(Plugin, true, plugin.config);
+                        });
+                    });
+
+                }
+
+                setEditorSession(editorSession);
+            });
+        };
+
+    });