biso24-editor 1.3.0

package/CKEditor4/plugins/justify/plugin.js

@@ -0,0 +1,266 @@
+/**
+ * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+
+/**
+ * @fileOverview Justify commands.
+ */
+
+(function () {
+	function getAlignment(element, useComputedState) {
+		var align;
+		if (useComputedState) align = element.getComputedStyle('text-align');
+		else {
+			while (!element.hasAttribute || !(element.hasAttribute('align') || element.getStyle('text-align'))) {
+				var parent = element.getParent();
+				if (!parent) break;
+				element = parent;
+			}
+			align = element.getStyle('text-align') || element.getAttribute('align') || '';
+		}
+
+		// Sometimes computed values doesn't tell.
+		align && (align = align.replace(/(?:-(?:moz|webkit)-)?(?:start|auto)/i, ''));
+
+		!align && useComputedState && (align = element.getComputedStyle('direction') == 'rtl' ? 'right' : 'left');
+
+		return align;
+	}
+
+	function justifyCommand(editor, name, value) {
+		this.editor = editor;
+		this.name = name;
+		this.value = value;
+		this.context = 'p';
+		var classes = editor.config.justifyClasses,
+			blockTag = editor.config.enterMode == CKEDITOR.ENTER_P ? 'p' : 'div';
+
+		if (classes) {
+			switch (value) {
+				case 'left':
+					this.cssClassName = classes[0];
+					break;
+				case 'center':
+					this.cssClassName = classes[1];
+					break;
+				case 'right':
+					this.cssClassName = classes[2];
+					break;
+				case 'justify':
+					this.cssClassName = classes[3];
+					break;
+			}
+
+			this.cssClassRegex = new RegExp('(?:^|\\s+)(?:' + classes.join('|') + ')(?=$|\\s)');
+			this.requiredContent = blockTag + '(' + this.cssClassName + ')';
+		} else {
+			this.requiredContent = blockTag + '{text-align}';
+		}
+
+		this.allowedContent = {
+			'caption div h1 h2 h3 h4 h5 h6 p pre td th li': {
+				// Do not add elements, but only text-align style if element is validated by other rule.
+				propertiesOnly: true,
+				styles: this.cssClassName ? null : 'text-align',
+				classes: this.cssClassName || null,
+			},
+		};
+
+		// In enter mode BR we need to allow here for div, because when non other
+		// feature allows div justify is the only plugin that uses it.
+		if (editor.config.enterMode == CKEDITOR.ENTER_BR) this.allowedContent.div = true;
+	}
+
+	function onDirChanged(e) {
+		var editor = e.editor;
+
+		var range = editor.createRange();
+		range.setStartBefore(e.data.node);
+		range.setEndAfter(e.data.node);
+
+		var walker = new CKEDITOR.dom.walker(range),
+			node;
+
+		while ((node = walker.next())) {
+			if (node.type == CKEDITOR.NODE_ELEMENT) {
+				// A child with the defined dir is to be ignored.
+				if (!node.equals(e.data.node) && node.getDirection()) {
+					range.setStartAfter(node);
+					walker = new CKEDITOR.dom.walker(range);
+					continue;
+				}
+
+				// Switch the alignment.
+				var classes = editor.config.justifyClasses;
+				if (classes) {
+					// The left align class.
+					if (node.hasClass(classes[0])) {
+						node.removeClass(classes[0]);
+						node.addClass(classes[2]);
+					}
+					// The right align class.
+					else if (node.hasClass(classes[2])) {
+						node.removeClass(classes[2]);
+						node.addClass(classes[0]);
+					}
+				}
+
+				// Always switch CSS margins.
+				var style = 'text-align';
+				var align = node.getStyle(style);
+
+				if (align == 'left') node.setStyle(style, 'right');
+				else if (align == 'right') node.setStyle(style, 'left');
+			}
+		}
+	}
+
+	justifyCommand.prototype = {
+		exec: function (editor) {
+			var selection = editor.getSelection(),
+				enterMode = editor.config.enterMode;
+
+			if (!selection) return;
+
+			var bookmarks = selection.createBookmarks(),
+				ranges = selection.getRanges();
+
+			var cssClassName = this.cssClassName,
+				iterator,
+				block;
+
+			var useComputedState = editor.config.useComputedState;
+
+			for (var i = ranges.length - 1; i >= 0; i--) {
+				iterator = ranges[i].createIterator();
+				iterator.enlargeBr = enterMode != CKEDITOR.ENTER_BR;
+
+				while ((block = iterator.getNextParagraph(enterMode == CKEDITOR.ENTER_P ? 'p' : 'div'))) {
+					if (block.isReadOnly()) continue;
+
+					// Check if style or class might be applied to currently processed element (#455).
+					var tag = block.getName(),
+						isAllowedTextAlign,
+						isAllowedCssClass;
+
+					isAllowedTextAlign = editor.activeFilter.check(tag + '{text-align}');
+					isAllowedCssClass = editor.activeFilter.check(tag + '(' + cssClassName + ')');
+
+					if (!isAllowedCssClass && !isAllowedTextAlign) {
+						continue;
+					}
+
+					block.removeAttribute('align');
+					block.removeStyle('text-align');
+
+					// Remove any of the alignment classes from the className.
+					var className =
+						cssClassName &&
+						(block.$.className = CKEDITOR.tools.ltrim(block.$.className.replace(this.cssClassRegex, '')));
+
+					var apply =
+						this.state == CKEDITOR.TRISTATE_OFF && (!useComputedState || getAlignment(block, true) != this.value);
+
+					if (cssClassName && isAllowedCssClass) {
+						// Append the desired class name.
+						if (apply) block.addClass(cssClassName);
+						else if (!className) block.removeAttribute('class');
+					} else if (apply && isAllowedTextAlign) {
+						block.setStyle('text-align', this.value);
+					}
+				}
+			}
+
+			editor.focus();
+			editor.forceNextSelectionCheck();
+			selection.selectBookmarks(bookmarks);
+		},
+
+		refresh: function (editor, path) {
+			var firstBlock = path.block || path.blockLimit,
+				name = firstBlock.getName(),
+				isEditable = firstBlock.equals(editor.editable()),
+				isStylable = this.cssClassName
+					? editor.activeFilter.check(name + '(' + this.cssClassName + ')')
+					: editor.activeFilter.check(name + '{text-align}');
+
+			// #455
+			// 1. Check if we are directly in editbale. Justification should be always allowed, and not highlighted.
+			//    Checking situation `body > ul` where ul is selected and path.blockLimit returns editable.
+			// 2. Check if current element can have applied specific class.
+			// 3. Check if current element can have applied text-align style.
+			if (isEditable && !CKEDITOR.dtd.$list[path.lastElement.getName()]) {
+				this.setState(CKEDITOR.TRISTATE_OFF);
+			} else if (!isEditable && isStylable) {
+				// 2 & 3 in one condition.
+				this.setState(
+					getAlignment(firstBlock, this.editor.config.useComputedState) == this.value
+						? CKEDITOR.TRISTATE_ON
+						: CKEDITOR.TRISTATE_OFF,
+				);
+			} else {
+				this.setState(CKEDITOR.TRISTATE_DISABLED);
+			}
+		},
+	};
+
+	CKEDITOR.plugins.add('justify', {
+		icons: 'justifyblock,justifycenter,justifyleft,justifyright', // %REMOVE_LINE_CORE%
+		hidpi: true, // %REMOVE_LINE_CORE%
+		init: function (editor) {
+			if (editor.blockless) return;
+
+			var left = new justifyCommand(editor, 'justifyleft', 'left'),
+				center = new justifyCommand(editor, 'justifycenter', 'center'),
+				right = new justifyCommand(editor, 'justifyright', 'right'),
+				justify = new justifyCommand(editor, 'justifyblock', 'justify');
+
+			editor.addCommand('justifyleft', left);
+			editor.addCommand('justifycenter', center);
+			editor.addCommand('justifyright', right);
+			editor.addCommand('justifyblock', justify);
+
+			if (editor.ui.addButton) {
+				editor.ui.addButton('JustifyLeft', {
+					isToggle: true,
+					label: editor.lang.common.alignLeft,
+					command: 'justifyleft',
+					toolbar: 'justifyleft',
+				});
+				editor.ui.addButton('JustifyCenter', {
+					isToggle: true,
+					label: editor.lang.common.center,
+					command: 'justifycenter',
+					toolbar: 'justifycenter',
+				});
+				editor.ui.addButton('JustifyRight', {
+					isToggle: true,
+					label: editor.lang.common.alignRight,
+					command: 'justifyright',
+					toolbar: 'justifyright',
+				});
+				editor.ui.addButton('JustifyBlock', {
+					isToggle: true,
+					label: editor.lang.common.justify,
+					command: 'justifyblock',
+					toolbar: 'justifyblock',
+				});
+			}
+			editor.on('dirChanged', onDirChanged);
+		},
+	});
+})();
+
+/**
+ * List of classes to use for aligning the contents. If it's `null`, no classes will be used
+ * and instead the corresponding CSS values will be used.
+ *
+ * The array should contain 4 members, in the following order: left, center, right, justify.
+ *
+ *		// Use the classes 'AlignLeft', 'AlignCenter', 'AlignRight', 'AlignJustify'
+ *		config.justifyClasses = [ 'AlignLeft', 'AlignCenter', 'AlignRight', 'AlignJustify' ];
+ *
+ * @cfg {Array} [justifyClasses=null]
+ * @member CKEDITOR.config
+ */

package/CKEditor4/plugins/justify_group/plugin.js

@@ -0,0 +1,64 @@
+/**
+ * A plugin to enable placeholder tokens to be inserted into the CKEditor message. Use on its own or with teh placeholder plugin.
+ * The default format is compatible with the placeholders syntex
+ *
+ * @version 0.1
+ * @Author Troy Lutton
+ * @license MIT
+ *
+ * This is a pure modification for the placeholders plugin. All credit goes to Stuart Sillitoe for creating the original (stuartsillitoe.co.uk)
+ *
+ */
+
+CKEDITOR.plugins.add('justify_group', {
+	icons: 'justifycenter',
+	hidpi: true,
+	init: function (editor) {
+		const items = {
+			justifyleft: {
+				label: editor.lang.common.alignLeft,
+				command: 'justifyleft',
+				group: 'alignment',
+				icon: 'justifyleft',
+				order: 1,
+			},
+			justifyright: {
+				label: editor.lang.common.alignRight,
+				command: 'justifyright',
+				group: 'alignment',
+				icon: 'justifyright',
+				order: 2,
+			},
+			justifycenter: {
+				label: editor.lang.common.alignCenter,
+				command: 'justifycenter',
+				group: 'alignment',
+				icon: 'justifycenter',
+				order: 3,
+			},
+			justify: {
+				label: editor.lang.common.justify,
+				command: 'justifyblock',
+				group: 'alignment',
+				icon: 'justifyblock',
+				order: 4,
+			},
+		};
+		editor.addMenuGroup('alignment');
+		editor.addMenuItems(items);
+
+		editor.ui.add('justify-dropdown', window.CKEDITOR.UI_MENUBUTTON, {
+			label: 'Căn lề văn bản',
+			toolbar: 'alignment',
+			icon: 'justifycenter',
+			onMenu: () => {
+				const active = {};
+
+				for (const p in items) {
+					active[p] = window.CKEDITOR.TRISTATE_OFF;
+				}
+				return active;
+			},
+		});
+	},
+});

package/CKEditor4/plugins/lineheight/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Kamlesh Kushwaha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/CKEditor4/plugins/lineheight/README.md

@@ -0,0 +1,2 @@
+# lineheight
+Ckeditor lineheight plugin repository

package/CKEditor4/plugins/lineheight/lang/vi.js

@@ -0,0 +1,3 @@
+CKEDITOR.plugins.setLang('lineheight', 'vi', {
+	title: 'T↕',
+});

package/CKEditor4/plugins/lineheight/plugin.js

@@ -0,0 +1,99 @@
+(function () {
+	function addCombo(editor, comboName, styleType, lang, entries, defaultLabel, styleDefinition, order) {
+		var config = editor.config,
+			style = new CKEDITOR.style(styleDefinition);
+		var names = entries.split(';'),
+			values = [];
+		var styles = {};
+		for (var i = 0; i < names.length; i++) {
+			var parts = names[i];
+			if (parts) {
+				parts = parts.split('/');
+				var vars = {},
+					name = (names[i] = parts[0]);
+				vars[styleType] = values[i] = parts[1] || name;
+				styles[name] = new CKEDITOR.style(styleDefinition, vars);
+				styles[name]._.definition.name = name;
+			} else names.splice(i--, 1);
+		}
+		editor.ui.addRichCombo(comboName, {
+			label: editor.lang.lineheight.title,
+			title: editor.lang.lineheight.title,
+			toolbar: 'styles,' + order,
+			allowedContent: style,
+			requiredContent: style,
+			panel: {
+				css: [CKEDITOR.skin.getPath('editor')].concat(config.contentsCss),
+				multiSelect: false,
+				attributes: { 'aria-label': editor.lang.lineheight.title },
+			},
+			init: function () {
+				this.startGroup(editor.lang.lineheight.title);
+				for (var i = 0; i < names.length; i++) {
+					var name = names[i];
+					this.add(name, styles[name].buildPreview(), name);
+				}
+			},
+			onClick: function (value) {
+				editor.focus();
+				editor.fire('saveSnapshot');
+				var style = styles[value];
+				editor[this.getValue() == value ? 'removeStyle' : 'applyStyle'](style);
+				editor.fire('saveSnapshot');
+			},
+			onRender: function () {
+				editor.on(
+					'selectionChange',
+					function (ev) {
+						var currentValue = this.getValue();
+						var elementPath = ev.data.path,
+							elements = elementPath.elements;
+						for (var i = 0, element; i < elements.length; i++) {
+							element = elements[i];
+							for (var value in styles) {
+								if (styles[value].checkElementMatch(element, true, editor)) {
+									if (value != currentValue) this.setValue(value);
+									return;
+								}
+							}
+						}
+						this.setValue('', defaultLabel);
+					},
+					this,
+				);
+			},
+			refresh: function () {
+				if (!editor.activeFilter.check(style)) this.setState(CKEDITOR.TRISTATE_DISABLED);
+			},
+		});
+	}
+	CKEDITOR.plugins.add('lineheight', {
+		requires: 'richcombo',
+		lang: 'vi,en',
+		init: function (editor) {
+			var config = editor.config;
+			var defaultText = '(' + editor.lang.common.optionDefault + ')';
+			addCombo(
+				editor,
+				'lineheight',
+				'size',
+				editor.lang.lineheight.title,
+				config.line_height,
+				editor.lang.lineheight.title,
+				config.lineHeight_style,
+				40,
+			);
+		},
+	});
+})();
+CKEDITOR.config.line_height = '1;1.1;1.25;1.5;1.75;2;2.5;3';
+CKEDITOR.config.lineHeight_style = {
+	element: 'span',
+	styles: { 'line-height': '#(size)' },
+	overrides: [
+		{
+			element: 'line-height',
+			attributes: { size: null },
+		},
+	],
+};

package/CKEditor4/plugins/lineheight/readme.txt

@@ -0,0 +1,30 @@
+lineheight
+==========
+
+CKEDITOR Line-height plugin documentation
+----------------------------------------------
+
+Installation Notes:
+
+    Adding plugin into the toolbar:
+    Using CKBuilder is a recommended solution, however, if you have plugins developed by yourself or by third parties, you can add plugins to your local installation manually by following the steps described below:
+    Extract the plugin .zip archive.
+    Copy the plugin files to the plugins folder of your CKEditor installation. Each plugin must be placed in a sub-folder that matches its "technical" name.
+    
+    For example, the lineheight plugin would be installed into this folder: <CKEditor folder>/plugins/lineheight.
+    Check and resolve plugin dependencies. If a plugin needs others to work, you will need to add these manually as well.
+    Enable the plugin. Use the extraPlugins setting to add the plugin to your confiuration:
+
+          config.extraPlugins = 'lineheight';
+          
+Refer this link for configuring the toolbar: http://docs.ckeditor.com/#!/guide/dev_toolbar
+
+
+Customizing the lineheight values in the dropdown
+-------------------------------------------------------
+In order to have custom values of line-height instead of the default, you can add following line in the config.js file:
+        
+        config.line_height="1em;1.1em;1.2em;1.3em;1.4em;1.5em";
+        
+        Here, "em" is the unit of line-height which you can change to "px","%" or any other allowed unit for line-height. 
+        You can also change the numbers based on your requirements. You can have more range or low range , it all depends on your requirements.

package/CKEditor4/plugins/link/dialogs/anchor.js

@@ -0,0 +1,82 @@
+/*
+ Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
+ For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+*/
+CKEDITOR.dialog.add('anchor', function (c) {
+	function f(b, a) {
+		return b.createFakeElement(b.document.createElement('a', { attributes: a }), 'cke_anchor', 'anchor');
+	}
+	return {
+		title: c.lang.link.anchor.title,
+		minWidth: 300,
+		minHeight: 60,
+		getModel: function (b) {
+			var a = b.getSelection();
+			b = a.getRanges()[0];
+			a = a.getSelectedElement();
+			b.shrink(CKEDITOR.SHRINK_ELEMENT);
+			(a = b.getEnclosedNode()) && a.type === CKEDITOR.NODE_TEXT && (a = a.getParent());
+			a && !a.is('a') && (a = a.getAscendant('a') || a);
+			b =
+				a && a.type === CKEDITOR.NODE_ELEMENT && ('anchor' === a.data('cke-real-element-type') || a.is('a'))
+					? a
+					: void 0;
+			return b || null;
+		},
+		onOk: function () {
+			var b = CKEDITOR.tools.trim(this.getValueOf('info', 'txtName')),
+				b = { id: b, name: b, 'data-cke-saved-name': b },
+				a = this.getModel(c);
+			if (a)
+				a.data('cke-realelement')
+					? ((b = f(c, b)), b.replace(a), CKEDITOR.env.ie && c.getSelection().selectElement(b))
+					: a.setAttributes(b);
+			else if (((a = (a = c.getSelection()) && a.getRanges()[0]), a.collapsed)) (b = f(c, b)), a.insertNode(b);
+			else {
+				CKEDITOR.env.ie && 9 > CKEDITOR.env.version && (b['class'] = 'cke_anchor');
+				var d = a.clone();
+				d.enlarge(CKEDITOR.ENLARGE_ELEMENT);
+				for (
+					var e = new CKEDITOR.dom.walker(d), d = d.collapsed ? d.startContainer : e.next(), g = a.createBookmark();
+					d;
+
+				)
+					d.type === CKEDITOR.NODE_ELEMENT && d.getAttribute('data-cke-saved-name') && (d.remove(!0), e.reset()),
+						(d = e.next());
+				a.moveToBookmark(g);
+				b = new CKEDITOR.style({ element: 'a', attributes: b });
+				b.type = CKEDITOR.STYLE_INLINE;
+				b.applyToRange(a);
+			}
+		},
+		onShow: function () {
+			var b = c.getSelection(),
+				a = this.getModel(c),
+				d = a && a.data('cke-realelement');
+			if ((a = d ? CKEDITOR.plugins.link.tryRestoreFakeAnchor(c, a) : CKEDITOR.plugins.link.getSelectedLink(c))) {
+				var e = a.data('cke-saved-name');
+				this.setValueOf('info', 'txtName', e || '');
+				!d && b.selectElement(a);
+			}
+			this.getContentElement('info', 'txtName').focus();
+		},
+		contents: [
+			{
+				id: 'info',
+				label: c.lang.link.anchor.title,
+				accessKey: 'I',
+				elements: [
+					{
+						type: 'text',
+						id: 'txtName',
+						label: c.lang.link.anchor.name,
+						required: !0,
+						validate: function () {
+							return this.getValue() ? !0 : (alert(c.lang.link.anchor.errorName), !1);
+						},
+					},
+				],
+			},
+		],
+	};
+});