/*
* Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
* For licensing, see LICENSE.html or http://ckeditor.com/license
*/
using System;
using System.Collections.Generic;
using System.Text;
namespace CKEditor.NET
{
#region Enum
public enum contentsLangDirections
{
///
/// 'ui' - which indicate content direction will be the same with the user interface language direction;
///
Ui,
///
/// 'ltr' - for Left-To-Right language (like English);
///
Ltr,
///
/// 'rtl' - for Right-To-Left languages (like Arabic).
///
Rtl
}
public enum DialogButtonsOrder
{
///
/// the buttons will be displayed in the default order of the user's OS
///
OS,
///
/// for Left-To-Right order
///
Ltr,
///
/// for Right-To-Left order
///
Rtl
}
public enum EnterMode
{
///
/// new
paragraphs are created
///
P = 1,
///
/// lines are broken with elements
///
BR = 2,
///
/// new
blocks are created
///
DIV = 3
}
public enum StartupMode
{
Wysiwyg,
Source
}
public enum ResizeDir
{
Both,
Vertical,
Horizontal
}
public enum ToolbarLocation
{
Top,
Bottom
}
[Flags]
public enum ScaytContextCommands
{
///
/// disables all options
///
Off = 0,
///
/// enables all options
///
All = 1,
///
/// enables the "Ignore" option
///
Ignore = 2,
///
/// enables the "Ignore All" option
///
Ignoreall = 4,
///
/// enables the "Add Word" option
///
Add = 8
}
[Flags]
public enum ScaytContextMenuItemsOrder
{
///
/// main suggestion word list
///
Suggest = 1,
///
/// moresuggest
///
Moresuggest = 2,
///
/// SCAYT commands, such as 'Ignore' and 'Add Word'
///
Control = 4
}
public enum ScaytMoreSuggestions
{
On,
Off
}
#endregion
#region CKSerializable
[System.AttributeUsage(System.AttributeTargets.Property)]
public class CKSerializable : System.Attribute
{
public string Name = string.Empty;
public bool RemoveEnters = false;
public bool ForceAddToJSON = false;
public bool IsObject = false;
}
public class JSONSerializer
{
public static string ToJavaScriptObjectNotation(object obj)
{
bool hasCommaAtEnd = false;
System.Text.StringBuilder sbJSON = new System.Text.StringBuilder("{");
Type objType = obj.GetType();
System.Text.StringBuilder oc = new StringBuilder();
#region Reflect Properties
System.Reflection.PropertyInfo[] staticPropertyInfo = CKEditorConfig.GlobalConfig.GetType().GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
Dictionary staticPropertyInfoDictionary = new Dictionary();
foreach (System.Reflection.PropertyInfo propertyInfo in staticPropertyInfo)
staticPropertyInfoDictionary.Add(propertyInfo.Name, propertyInfo.GetValue(CKEditorConfig.GlobalConfig, new object[0]));
foreach (System.Reflection.PropertyInfo propertyInfo in
objType.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance))
{
bool canSerializable = false;
string customName = string.Empty;
bool removeEnters = false;
bool forceAddToJSON = false;
bool isObject = false;
object[] attrs = propertyInfo.GetCustomAttributes(false);
foreach (object attr in attrs)
if (attr is CKSerializable)
{
canSerializable = true;
removeEnters = ((CKSerializable)attr).RemoveEnters;
forceAddToJSON = ((CKSerializable)attr).ForceAddToJSON;
isObject = ((CKSerializable)attr).IsObject;
if (!string.IsNullOrEmpty(((CKSerializable)attr).Name))
customName = ((CKSerializable)attr).Name;
break;
}
if (!canSerializable)
continue;
if (!propertyInfo.CanRead)
continue;
if (customName == "ExtraOptions")
foreach (object[] item in (object[])propertyInfo.GetValue(obj, new object[0]))
oc.Append(", ").Append("\"" + item[0].ToString() + "\" : ").Append(item[1].ToString());
else if (customName == "stylesSet" && ((string[])propertyInfo.GetValue(obj, new object[0])).Length == 1 && !((string[])propertyInfo.GetValue(obj, new object[0]))[0].StartsWith("{"))
{
object staticValueToCompare = staticPropertyInfoDictionary[propertyInfo.Name];
if (!campareArray(((string[]) propertyInfo.GetValue(obj, new object[0])), (string[]) staticValueToCompare))
{
string[] valueToJSON = (string[]) propertyInfo.GetValue(obj, new object[0]);
sbJSON.Append("\"" + (string.IsNullOrEmpty(customName) ? propertyInfo.Name : customName) + "\" : ");
if ((valueToJSON[0].StartsWith("[") || valueToJSON[0].StartsWith("{")) &&
(valueToJSON[0].EndsWith("]") || valueToJSON[0].EndsWith("}")))
sbJSON.Append(EscapeStringForJavaScript(valueToJSON[0]).TrimStart(new char[] { '\'' }).TrimEnd(new char[] { '\'' }));
else
sbJSON.Append("\"" + EscapeStringForJavaScript(valueToJSON[0]).TrimStart(new char[] {'\''}).TrimEnd(new char[] {'\''}) + "\"");
sbJSON.Append(", ");
}
continue;
}
else if (customName == "on" && ((object[])propertyInfo.GetValue(obj, new object[0])).Length > 0)
{
object[] objArray = (object[])((object[])propertyInfo.GetValue(obj, new object[0]))[0];
oc.Append(", \"on\" : {").Append(((object[])objArray)[0]).Append(" : ").Append(((object[])objArray)[1]).Append(" } ");
}
else if (propertyInfo.Name == "stylesheetParser_skipSelectors" || propertyInfo.Name == "stylesheetParser_validSelectors")
{
string valueToJSON = (string)propertyInfo.GetValue(obj, new object[0]);
string staticValueToCompare = (string)staticPropertyInfoDictionary[propertyInfo.Name];
if (valueToJSON != staticValueToCompare)
oc.Append(", " + propertyInfo.Name + ": " + valueToJSON);
}
else if (propertyInfo.Name == "entities_processNumerical")
{
string valueToJSON = (string)propertyInfo.GetValue(obj, new object[0]);
string staticValueToCompare = (string)staticPropertyInfoDictionary[propertyInfo.Name];
if (valueToJSON != staticValueToCompare)
{
if (valueToJSON.ToLower() == false.ToString().ToLower() || valueToJSON.ToLower() == true.ToString().ToLower())
oc.Append(", " + propertyInfo.Name + ": " + bool.Parse(valueToJSON));
else
oc.Append(", " + propertyInfo.Name + ": " + valueToJSON);
}
}
else
{
object valueToJSON = propertyInfo.GetValue(obj, new object[0]);
object staticValueToCompare = staticPropertyInfoDictionary[propertyInfo.Name];
if (valueToJSON == null && staticValueToCompare == null)
continue;
else if (valueToJSON.GetType().IsArray && staticValueToCompare == null) { }
else if (!forceAddToJSON && !valueToJSON.GetType().IsArray && !staticValueToCompare.GetType().IsArray && staticValueToCompare.ToString() == valueToJSON.ToString())
continue;
else if (!forceAddToJSON && valueToJSON.GetType().IsArray && staticValueToCompare.GetType().IsArray)
{
if (valueToJSON.GetType() == typeof(int[]) && campareArray((int[])valueToJSON, (int[])staticValueToCompare))
continue;
else if (valueToJSON.GetType() == typeof(string[]) && campareArray((string[])valueToJSON, (string[])staticValueToCompare))
continue;
else if (valueToJSON.GetType() == typeof(object[][]) && campareArray((object[][])valueToJSON, (object[][])staticValueToCompare))
continue;
else if (valueToJSON.GetType() == typeof(object[]) && campareArray((object[])valueToJSON, (object[])staticValueToCompare))
continue;
}
sbJSON.Append("\"" + (string.IsNullOrEmpty(customName) ? propertyInfo.Name : customName) + "\" : ");
if (propertyInfo.Name == "toolbar" || propertyInfo.Name == "toolbar_Basic" || propertyInfo.Name == "toolbar_Full")
{
object toolObj;
if (propertyInfo.Name == "toolbar") toolObj = propertyInfo.GetValue(obj, new object[0]);
else toolObj = ((object[])propertyInfo.GetValue(obj, new object[0]))[0];
if (toolObj.GetType() == typeof(string) && ((string)toolObj).StartsWith("[") && ((string)toolObj).EndsWith("]"))
{
isObject = true;
GetFieldOrPropertyValue(ref sbJSON, toolObj, removeEnters, isObject);
sbJSON.Append(", ");
continue;
}
}
GetFieldOrPropertyValue(ref sbJSON, propertyInfo.GetValue(obj, new object[0]), removeEnters, isObject);
sbJSON.Append(", ");
}
hasCommaAtEnd = true;
}
#endregion
if (hasCommaAtEnd)
sbJSON.Length -= 2;
sbJSON.Append(oc.ToString()).Append("}");
return sbJSON.ToString();
}
private static bool campareArray(string[] obj1, string[] obj2)
{
if (!obj1.GetType().IsArray || !obj2.GetType().IsArray)
return false;
if (obj1.Length != obj2.Length)
return false;
for (int i = 0; i < obj1.Length; i++)
if (obj1[i].ToString() != obj2[i].ToString())
return false;
return true;
}
private static bool campareArray(int[] obj1, int[] obj2)
{
if (!obj1.GetType().IsArray || !obj2.GetType().IsArray)
return false;
if (obj1.Length != obj2.Length)
return false;
for (int i = 0; i < obj1.Length; i++)
if (obj1[i].ToString() != obj2[i].ToString())
return false;
return true;
}
private static bool campareArray(object[][] obj1, object[][] obj2)
{
if (!obj1.GetType().IsArray || !obj2.GetType().IsArray)
return false;
if (obj1.Length != obj2.Length)
return false;
for (int i = 0; i < obj1.Length; i++)
if (!campareArray(obj1[i], obj2[i]))
return false;
return true;
}
private static bool campareArray(object[] obj1, object[] obj2)
{
if (!obj1.GetType().IsArray || !obj2.GetType().IsArray)
return false;
if (obj1.Length != obj2.Length)
return false;
for (int i = 0; i < obj1.Length; i++)
if ((obj1[i].GetType().IsArray) && !campareArray((object[])obj1[i], (object[])obj2[i]))
return false;
else if (obj1[i].ToString() != obj2[i].ToString())
return false;
return true;
}
private static void GetFieldOrPropertyValue(ref System.Text.StringBuilder sbJSON, object value, bool removeEnters, bool isObject)
{
Type type = value.GetType();
if (type == typeof(System.DateTime))
sbJSON.Append("new Date(" + ((DateTime)value - DateTime.Parse("1/1/1970")).TotalMilliseconds.ToString() + ")");
else if (type == typeof(System.String))
{
string app = isObject ? string.Empty : "\"";
sbJSON.Append(app + EscapeStringForJavaScript((removeEnters ? ((string)value).Replace("\r", "").Replace("\n", "").Replace("\t", "").Replace("\b", "") : (string)value)) + app);
}
else if (type == typeof(System.Int16) || type == typeof(System.Int32) || type == typeof(System.Int64))
sbJSON.Append(value.ToString());
else if (type == typeof(System.Decimal) || type == typeof(System.Double) || type == typeof(System.Single))
sbJSON.Append(value.ToString().Replace(',', '.'));
else if (type.IsArray)
{
bool hasCommaAtEnd = false;
sbJSON.Append("[");
foreach (object o in (Array)value)
{
GetFieldOrPropertyValue(ref sbJSON, o, removeEnters, isObject);
sbJSON.Append(", ");
hasCommaAtEnd = true;
}
if (hasCommaAtEnd)
sbJSON.Length -= 2;
sbJSON.Append("]");
}
else if (type == typeof(System.Boolean))
sbJSON.Append(value.ToString().ToLower());
else
sbJSON.Append(EscapeStringForJavaScript(value.ToString()));
}
private static string EscapeStringForJavaScript(string input)
{
input = input.Replace("\\", @"\\");
input = input.Replace("\b", @"\u0008");
input = input.Replace("\t", @"\u0009");
input = input.Replace("\n", @"\u000a");
input = input.Replace("\f", @"\u000c");
input = input.Replace("\r", @"\u000d");
input = input.Replace("\"", @"""");
input = input.Replace("\"", "\\\"");
return input;
}
}
#endregion
[Serializable]
public class CKEditorConfig
{
#region Consts
public const int CKEDITOR_CTRL = 1000;
public const int CKEDITOR_SHIFT = 2000;
public const int CKEDITOR_ALT = 4000;
#endregion
#region GlobalConfig
public static CKEditorConfig GlobalConfig;
#endregion
#region CKSerializable Property
///
/// Extra height in pixel to leave between the bottom boundary of content with document size when auto resizing.
/// Default Value: 0
///
[CKSerializable]
public int autoGrow_bottomSpace { get; set; }
///
/// The maximum height to which the editor can reach using AutoGrow. Zero means unlimited.
/// Default Value: 0
///
[CKSerializable]
public int autoGrow_maxHeight { get; set; }
///
/// The minimum height to which the editor can reach using AutoGrow.
/// Default Value: 200
///
[CKSerializable]
public int autoGrow_minHeight { get; set; }
///
/// Whether to have the auto grow happen on editor creation.
/// Default Value: false
///
[CKSerializable]
public bool autoGrow_onStartup { get; set; }
///
/// Whether automatically create wrapping blocks around inline contents inside document body, this helps to ensure the integrality of the block enter mode. Note: Changing the default value might introduce unpredictable usability issues.
/// Default Value: true
///
[CKSerializable]
public bool autoParagraph { get; set; }
///
/// Whether the replaced element (usually a textarea) is to be updated automatically when posting the form containing the editor.
/// Default Value: true
///
[CKSerializable]
public bool autoUpdateElement { get; set; }
///
/// The base Z-index for floating dialogs and popups.
/// Default Value: 2000
///
[CKSerializable]
public int baseFloatZIndex { get; set; }
///
/// The base href URL used to resolve relative and absolute URLs in the editor content.
/// Default Value: ""
///
[CKSerializable]
public string baseHref { get; set; }
///
/// Whether to escape basic HTML entities in the document, including: nbsp, gt, lt, amp.
/// Default Value: true
///
[CKSerializable]
public bool basicEntities { get; set; }
///
/// A list of keystrokes to be blocked if not defined in the CKEDITOR.config.keystrokes setting. In this way it is possible
/// to block the default browser behavior for those keystrokes.
/// Default Value:
/// new int[]
/// {
/// CKEDITOR_CTRL + 66 /*B*/,
/// CKEDITOR_CTRL + 73 /*I*/,
/// CKEDITOR_CTRL + 85 /*U*/
/// };
///
[CKSerializable]
public int[] blockedKeystrokes { get; set; }
///
/// Sets the "class" attribute to be used on the body element of the editing area. This can be useful when reusing the original CSS
/// file you're using on your live website and you want to assing to the editor the same class name you're using for the region
/// that'll hold the contents. In this way, class specific CSS rules will be enabled.
/// Default Value: ""
///
[CKSerializable]
public string bodyClass { get; set; }
///
/// Sets the "id" attribute to be used on the body element of the editing area. This can be useful when reusing the original CSS
/// file you're using on your live website and you want to assing to the editor the same id you're using for the region
/// that'll hold the contents. In this way, id specific CSS rules will be enabled.
/// Default Value: ""
///
[CKSerializable]
public string bodyId { get; set; }
///
/// Whether to show the browser native context menu when the CTRL or the META (Mac) key is pressed while opening the context menu.
/// Default Value: true
///
[CKSerializable]
public bool browserContextMenuOnCtrl { get; set; }
///
/// Holds the style definition to be used to apply the text background color.
/// Default Value:
/// "{
/// element : 'span',
/// styles : { 'background-color' : '#(color)' }
/// }"
///
///
[CKSerializable(IsObject = true)]
public object colorButton_backStyle { get; set; }
///
/// Defines the colors to be displayed in the color selectors. It's a string containing the hexadecimal notation for HTML colors,
/// without the "#" prefix. Since 3.3: A name may be optionally defined by prefixing the entries with the name and
/// the slash character. For example, "FontColor1/FF9900" will be displayed as the color #FF9900 in the selector,
/// but will be outputted as "FontColor1".
/// Default Value: "000,800000,8B4513,2F4F4F,008080,000080,4B0082,696969,B22222,A52A2A,DAA520,006400,40E0D0,0000CD,800080,808080,F00,FF8C00,FFD700,008000,0FF,00F,EE82EE,A9A9A9,FFA07A,FFA500,FFFF00,00FF00,AFEEEE,ADD8E6,DDA0DD,D3D3D3,FFF0F5,FAEBD7,FFFFE0,F0FFF0,F0FFFF,F0F8FF,E6E6FA,FFF"
///
[CKSerializable]
public string colorButton_colors { get; set; }
///
/// Whether to enable the More Colors button in the color selectors.
/// Default Value: true
///
[CKSerializable]
public bool colorButton_enableMore { get; set; }
///
/// Holds the style definition to be used to apply the text foreground color.
/// Default Value:
/// "{
/// element : 'span',
/// styles : { 'color' : '#(color)' },
/// overrides : [ { element : 'font', attributes : { 'color' : null } } ]
/// }"
///
[CKSerializable(IsObject = true)]
public object colorButton_foreStyle { get; set; }
///
/// The CSS file(s) to be used to apply style to the contents. It should reflect the CSS used in the final pages where
/// the contents are to be used.
/// Default Value: new string[] { "~/contents.css" };
///
public string[] contentsCss { get; set; }
[CKSerializable(Name = "contentsCss", IsObject = true)]
private string[] contentsCssSer
{
get
{
List retVal = new List();
ResolveParameters(contentsCss, retVal, true);
return retVal.ToArray();
}
}
///
/// The writting direction of the language used to write the editor contents. Allowed values are:
/// public enum contentsLangDirections
/// {
/// Ui - which indicate content direction will be the same with the user interface language direction;
/// Ltr, - for Left-To-Right language (like English);
/// Rtl - for Right-To-Left languages (like Arabic).
/// }
/// Default Value: contentsLangDirections.Ui
///
public contentsLangDirections contentsLangDirection { get; set; }
[CKSerializable(Name = "contentsLangDirection")]
private string contentsLangDirectionSer { get { return contentsLangDirection.ToString().ToLower(); } }
///
/// Language code of the writting language which is used to author the editor contents.
/// Default Value: Same value with editor's UI language.
///
[CKSerializable]
public string contentsLanguage { get; set; }
///
/// The style definition to be used to apply the bold style in the text.
/// Default Value: "{ element : 'strong', overrides : 'b' }"
///
[CKSerializable(IsObject = true)]
public object coreStyles_bold { get; set; }
///
/// The style definition to be used to apply the italic style in the text.
/// Default Value: { element : 'em', overrides : 'i' }
///
[CKSerializable(IsObject = true)]
public object coreStyles_italic { get; set; }
///
/// The style definition to be used to apply the strike style in the text.
/// Default Value: { element : 'strike' }
///
[CKSerializable(IsObject = true)]
public object coreStyles_strike { get; set; }
///
/// The style definition to be used to apply the subscript style in the text.
/// Default Value: { element : 'sub' }
///
[CKSerializable(IsObject = true)]
public object coreStyles_subscript { get; set; }
///
/// The style definition to be used to apply the superscript style in the text.
/// Default Value: { element : 'sup' }
///
[CKSerializable(IsObject = true)]
public object coreStyles_superscript { get; set; }
///
/// The style definition to be used to apply the underline style in the text.
/// Default Value: { element : 'u' }
///
[CKSerializable(IsObject = true)]
public object coreStyles_underline { get; set; }
///
/// The URL path for the custom configuration file to be loaded. If not overloaded with inline configurations, it defaults
/// to the "config.js" file present in the root of the CKEditor installation directory.
/// CKEditor will recursively load custom configuration files defined inside other custom configuration files.
/// Default Value: "config.js"
///
[CKSerializable]
public string customConfig { get; set; }
///
/// The language to be used if CKEDITOR.config.language is left empty and it's not possible to localize the editor to the user language.
/// Default Value: "en"
///
[CKSerializable]
public string defaultLanguage { get; set; }
///
/// A setting that stores CSS rules to be injected into the page with styles to be applied to the tooltip element.
/// Default Value: ""
///
[CKSerializable]
public string devtools_styles { get; set; }
///
/// The color of the dialog background cover. It should be a valid CSS color string.
/// Default Value: "white"
///
[CKSerializable]
public string dialog_backgroundCoverColor { get; set; }
///
/// The opacity of the dialog background cover. It should be a number within the range [0.0, 1.0].
/// Default Value: 0.5
///
[CKSerializable]
public double dialog_backgroundCoverOpacity { get; set; }
///
/// The guideline to follow when generating the dialog buttons. There are 3 possible options:
/// public enum DialogButtonsOrder
/// {
/// OS - the buttons will be displayed in the default order of the user's OS
/// Ltr - for Left-To-Right order
/// Rtl - for Right-To-Left order
/// }
/// Default Value: DialogButtonsOrder.OS;
///
public DialogButtonsOrder dialog_buttonsOrder { get; set; }
[CKSerializable(Name = "dialog_buttonsOrder")]
private string dialog_buttonsOrderSer { get { return dialog_buttonsOrder.ToString().ToLower(); } }
///
/// The distance of magnetic borders used in moving and resizing dialogs, measured in pixels.
/// Default Value: 20
///
[CKSerializable]
public int dialog_magnetDistance { get; set; }
///
/// If the dialog has more than one tab, put focus into the first tab as soon as dialog is opened.
/// Default Value: false
///
[CKSerializable]
public bool dialog_startupFocusTab { get; set; }
///
/// Disables the built-in spell checker while typing natively available in the browser (currently Firefox and Safari only).
/// Even if word suggestions will not appear in the CKEditor context menu, this feature is useful to help quickly identifying misspelled words.
/// This setting is currently compatible with Firefox only due to limitations in other browsers.
/// Default Value: true
///
[CKSerializable]
public bool disableNativeSpellChecker { get; set; }
///
/// Disables the "table tools" offered natively by the browser (currently Firefox only) to make quick table editing operations,
/// like adding or deleting rows and columns.
/// Default Value: true
///
[CKSerializable]
public bool disableNativeTableHandles { get; set; }
///
/// Disables the ability of resize objects (image and tables) in the editing area.
/// Default Value: false
///
[CKSerializable]
public bool disableObjectResizing { get; set; }
///
/// Disables inline styling on read-only elements.
/// Default Value: false
///
[CKSerializable]
public bool disableReadonlyStyling { get; set; }
///
/// Sets the doctype to be used when loading the editor content as HTML.
/// Default Value: ''
///
[CKSerializable]
public string docType { get; set; }
///
/// Whether to render or not the editing block area in the editor interface.
/// Default Value: true
///
[CKSerializable]
public bool editingBlock { get; set; }
///
/// The e-mail address anti-spam protection option. The protection will be applied when creating or modifying e-mail links through the editor interface.
/// Two methods of protection can be choosed:
/// The e-mail parts (name, domain and any other query string) are assembled into a function call pattern. Such function must be provided by
/// the developer in the pages that will use the contents.
/// Only the e-mail address is obfuscated into a special string that has no meaning for humans or spam bots, but which is properly rendered and accepted by the browser.
/// Both approaches require JavaScript to be enabled.
/// Default Value: "" (empty string = disabled)
///
[CKSerializable]
public string emailProtection { get; set; }
///
/// Allow context-sensitive tab key behaviors, including the following scenarios:
/// When selection is anchored inside table cells:
/// If TAB is pressed, select the contents of the "next" cell. If in the last cell in the table, add a new row to it and focus its first cell.
/// If SHIFT+TAB is pressed, select the contents of the "previous" cell. Do nothing when it's in the first cell.
/// Default Value: true
///
[CKSerializable]
public bool enableTabKeyTools { get; set; }
///
/// Sets the behavior for the ENTER key. It also dictates other behaviour rules in the editor, like whether the element is to be used as a paragraph separator when indenting text.
/// The allowed values are the following constants, and their relative behavior:
/// public enum EnterMode
/// {
/// P = 1 - new
paragraphs are created
/// BR = 2 - lines are broken with elements
/// DIV = 3 - new
blocks are created
/// }
/// Note: It's recommended to use the CKEDITOR.ENTER_P value because of its semantic value and correctness. The editor is optimized for this value.
/// Default Value: EnterMode.P;
///
public EnterMode enterMode { get; set; }
[CKSerializable(Name = "enterMode", IsObject = true)]
private int enterModeSer { get { return (int)this.enterMode; } }
///
/// Whether to use HTML entities in the output.
/// Default Value: true
///
[CKSerializable]
public bool entities { get; set; }
///
/// An additional list of entities to be used. It's a string containing each entry separated by a comma.
/// Entities names or number must be used, exclusing the "&" preffix and the ";" termination.
/// Default Value: "#39" // The single quote (') character.
///
[CKSerializable]
public string entities_additional { get; set; }
///
/// Whether to convert some symbols, mathematical symbols, and Greek letters to HTML entities. This may be more relevant for users typing text written in Greek.
/// The list of entities can be found at the W3C HTML 4.01 Specification, section 24.3.1.
/// Default Value: true
///
[CKSerializable]
public bool entities_greek { get; set; }
///
/// Whether to convert some Latin characters (Latin alphabet No. 1, ISO 8859-1) to HTML entities.
/// The list of entities can be found at the W3C HTML 4.01 Specification, section 24.2.1.
/// Default Value: true
///
[CKSerializable]
public bool entities_latin { get; set; }
///
/// Whether to convert all remaining characters not included in the ASCII character table to their relative decimal numeric representation of HTML entity.
/// When set to force, it will convert all entities into this format. For example the phrase "This is Chinese: 汉语." is output as "This is Chinese: 汉语."
/// Default Value: false
///
[CKSerializable]
public string entities_processNumerical { get; set; }
///
/// List of additional plugins to be loaded.
/// This is a tool setting which makes it easier to add new plugins, whithout having to touch and possibly breaking the CKEDITOR.config.plugins setting.
/// Default Value: ""
///
[CKSerializable]
public string extraPlugins { get; set; }
///
/// The location of an external file browser, that should be launched when "Browse Server" button is pressed.
/// If configured, the "Browse Server" button will appear in Link, Image and Flash dialogs.
/// Default Value: "" (empty string = disabled)
///
[CKSerializable]
public string filebrowserBrowseUrl { get; set; }
///
/// The location of an external file browser, that should be launched when "Browse Server" button is pressed in the Flash dialog.
/// If not set, CKEditor will use CKEDITOR.config.filebrowserBrowseUrl.
/// Default Value: "" (empty string = disabled)
///
[CKSerializable]
public string filebrowserFlashBrowseUrl { get; set; }
///
/// The location of a script that handles file uploads in the Flash dialog. If not set, CKEditor will use CKEDITOR.config.filebrowserUploadUrl.
/// Default Value: "" (empty string = disabled)
///
[CKSerializable]
public string filebrowserFlashUploadUrl { get; set; }
///
/// The location of an external file browser, that should be launched when "Browse Server" button is pressed in the Link tab of Image dialog.
/// If not set, CKEditor will use CKEDITOR.config.filebrowserBrowseUrl.
/// Default Value: "" (empty string = disabled)
///
[CKSerializable]
public string filebrowserImageBrowseLinkUrl { get; set; }
///
/// The location of an external file browser, that should be launched when "Browse Server" button is pressed in the Image dialog.
/// If not set, CKEditor will use CKEDITOR.config.filebrowserBrowseUrl.
/// Default Value: "" (empty string = disabled)
///
[CKSerializable]
public string filebrowserImageBrowseUrl { get; set; }
///
/// The location of a script that handles file uploads in the Image dialog. If not set, CKEditor will use CKEDITOR.config.filebrowserUploadUrl.
/// Default Value: "" (empty string = disabled)
///
[CKSerializable]
public string filebrowserImageUploadUrl { get; set; }
///
/// The location of a script that handles file uploads. If set, the "Upload" tab will appear in "Link", "Image" and "Flash" dialogs.
/// Default Value: "" (empty string = disabled)
///
[CKSerializable]
public string filebrowserUploadUrl { get; set; }
///
/// The "features" to use in the file browser popup window.
/// Default Value: "location=no,menubar=no,toolbar=no,dependent=yes,minimizable=no,modal=yes,alwaysRaised=yes,resizable=yes,scrollbars=yes"
///
[CKSerializable]
public string filebrowserWindowFeatures { get; set; }
///
/// Whether a filler text (non-breaking space entity - ) will be inserted into empty block elements in HTML output,
/// this is used to render block elements properly with line-height; When a function is instead specified,
/// it'll be passed a CKEDITOR.htmlParser.element to decide whether adding the filler text by expecting a boolean return value.
/// Default Value: true
///
[CKSerializable]
public bool fillEmptyBlocks { get; set; }
///
/// Defines the style to be used to highlight results with the find dialog.
/// Default Value: "{ element : 'span', styles : { 'background-color' : '#004', 'color' : '#fff' } }"
///
[CKSerializable(IsObject = true)]
public object find_highlight { get; set; }
///
/// The text to be displayed in the Font combo is none of the available values matches the current cursor position or text selection.
/// Default Value: ""
///
[CKSerializable]
public string font_defaultLabel { get; set; }
///
/// The list of fonts names to be displayed in the Font combo in the toolbar. Entries are separated by semi-colons (;),
/// while it's possible to have more than one font for each entry, in the HTML way (separated by comma).
/// A display name may be optionally defined by prefixing the entries with the name and the slash character.
/// For example, "Arial/Arial, Helvetica, sans-serif" will be displayed as "Arial" in the list, but will be outputted as "Arial, Helvetica, sans-serif".
/// Default Value:
/// "Arial/Arial, Helvetica, sans-serif; Comic Sans MS/Comic Sans MS, cursive; Courier New/Courier New, Courier, monospace;
/// Georgia/Georgia, serif;Lucida Sans Unicode/Lucida Sans Unicode, Lucida Grande, sans-serif;
/// Tahoma/Tahoma, Geneva, sans-serif;Times New Roman/Times New Roman, Times, serif;
/// Trebuchet MS/Trebuchet MS, Helvetica, sans-serif; Verdana/Verdana, Geneva, sans-serif"
///
[CKSerializable(RemoveEnters = true)]
public string font_names { get; set; }
///
/// The style definition to be used to apply the font in the text.
/// Default Value:
/// "{
/// element : 'span',
/// styles : { 'font-family' : '#(family)' },
/// overrides : [ { element : 'font', attributes : { 'face' : null } } ]
/// }"
///
[CKSerializable(IsObject = true)]
public object font_style { get; set; }
///
/// The text to be displayed in the Font Size combo is none of the available values matches the current cursor position or text selection.
/// Default Value: ""
///
[CKSerializable]
public string fontSize_defaultLabel { get; set; }
///
/// The list of fonts size to be displayed in the Font Size combo in the toolbar. Entries are separated by semi-colons (;).
/// Any kind of "CSS like" size can be used, like "12px", "2.3em", "130%", "larger" or "x-small".
/// A display name may be optionally defined by prefixing the entries with the name and the slash character.
/// For example, "Bigger Font/14px" will be displayed as "Bigger Font" in the list, but will be outputted as "14px".
/// Default Value: "8/8px;9/9px;10/10px;11/11px;12/12px;14/14px;16/16px;18/18px;20/20px;22/22px;24/24px;26/26px;28/28px;36/36px;48/48px;72/72px"
///
[CKSerializable]
public string fontSize_sizes { get; set; }
///
/// The style definition to be used to apply the font size in the text.
/// Default Value:
/// "{
/// element : 'span',
/// styles : { 'font-size' : '#(size)' },
/// overrides : [ { element : 'font', attributes : { 'size' : null } } ]
/// }"
///
[CKSerializable]
public object fontSize_style { get; set; }
///
/// Force the respect of CKEDITOR.config.enterMode as line break regardless of the context,
/// E.g. If CKEDITOR.config.enterMode is set to CKEDITOR.ENTER_P, press enter key inside a 'div' will create a new paragraph with 'p' instead of 'div'.
/// Default Value: false
///
[CKSerializable]
public bool forceEnterMode { get; set; }
///
/// Whether to force all pasting operations to insert on plain text into the editor, loosing any formatting information possibly available in the source text.
/// Default Value: false
///
[CKSerializable]
public bool forcePasteAsPlainText { get; set; }
///
/// Whether to force using "&" instead of "&" in elements attributes values,
/// it's not recommended to change this setting for compliance with the W3C XHTML 1.0 standards (C.12, XHTML 1.0).
/// Default Value: false
///
[CKSerializable]
public bool forceSimpleAmpersand { get; set; }
///
/// The style definition to be used to apply the "Address" format.
/// Default Value: "{ element : 'address' }"
///
[CKSerializable(IsObject = true)]
public object format_address { get; set; }
///
/// The style definition to be used to apply the "Normal (DIV)" format.
/// Default Value: "{ element : 'div' }"
///
[CKSerializable(IsObject = true)]
public object format_div { get; set; }
///
/// The style definition to be used to apply the "Heading 1" format.
/// Default Value: "{ element : 'h1' }"
///
[CKSerializable(IsObject = true)]
public object format_h1 { get; set; }
///
/// The style definition to be used to apply the "Heading 2" format.
/// Default Value: "{ element : 'h2' }"
///
[CKSerializable(IsObject = true)]
public object format_h2 { get; set; }
///
/// The style definition to be used to apply the "Heading 3" format.
/// Default Value: "{ element : 'h3' }"
///
[CKSerializable(IsObject = true)]
public object format_h3 { get; set; }
///
/// The style definition to be used to apply the "Heading 4" format.
/// Default Value: "{ element : 'h4' }"
///
[CKSerializable(IsObject = true)]
public object format_h4 { get; set; }
///
/// The style definition to be used to apply the "Heading 5" format.
/// Default Value: "{ element : 'h5' }"
///
[CKSerializable(IsObject = true)]
public object format_h5 { get; set; }
///
/// The style definition to be used to apply the "Heading 6" format.
/// Default Value: "{ element : 'h6' }"
///
[CKSerializable(IsObject = true)]
public object format_h6 { get; set; }
///
/// The style definition to be used to apply the "Normal" format.
/// Default Value: "{ element : 'p' }"
///
[CKSerializable(IsObject = true)]
public object format_p { get; set; }
///
/// The style definition to be used to apply the "Formatted" format.
/// Default Value: "{ element : 'pre' }"
///
[CKSerializable(IsObject = true)]
public object format_pre { get; set; }
///
/// A list of semi colon separated style names (by default tags) representing the style definition for each entry to be displayed
/// in the Format combo in the toolbar. Each entry must have its relative definition configuration in a setting named
/// "format_(tagName)". For example, the "p" entry has its definition taken from config.format_p.
/// Default Value: "p;h1;h2;h3;h4;h5;h6;pre;address;div"
///
[CKSerializable]
public string format_tags { get; set; }
///
/// Indicates whether the contents to be edited are being inputted as a full HTML page.
/// A full page includes the , and tags.
/// The final output will also reflect this setting, including the contents only if this setting is disabled.
/// Default Value: false
///
[CKSerializable]
public bool fullPage { get; set; }
///
/// The height of editing area( content ), in relative or absolute, e.g. 30px, 5em. Note: Percentage unit is not supported yet.e.g. 30%.
/// Default Value: "200"
///
[CKSerializable]
public string height { get; set; }
///
/// Whether escape HTML when editor update original input element.
/// Default Value: true
///
[CKSerializable(ForceAddToJSON = true)]
public bool htmlEncodeOutput { get; set; }
///
/// Whether the editor must output an empty value ("") if it's contents is made by an empty paragraph only.
/// Default Value: true
///
[CKSerializable]
public bool ignoreEmptyParagraph { get; set; }
///
/// Padding text to set off the image in preview area.
/// Default Value: ""
///
[CKSerializable]
public string image_previewText { get; set; }
///
/// Whether to remove links when emptying the link URL field in the image dialog.
/// Default Value: true
///
[CKSerializable]
public bool image_removeLinkByEmptyURL { get; set; }
///
/// List of classes to use for indenting the contents. If it's null, no classes will be used and instead the #indentUnit and #indentOffset properties will be used.
/// Default Value: []
///
public string[] indentClasses { get; set; }
[CKSerializable(Name = "indentClasses", IsObject = true)]
private string[] indentClassesSer
{
get
{
List retVal = new List();
ResolveParameters(indentClasses, retVal, true);
return retVal.ToArray();
}
}
///
/// Size of each indentation step
/// Default Value: 40
///
[CKSerializable]
public int indentOffset { get; set; }
///
/// Unit for the indentation style
/// Default Value: "px"
///
[CKSerializable]
public string indentUnit { get; set; }
///
/// Allows CKEditor to override jQuery.fn.val(), making it possible to use the val() function on textareas, as usual, having it synchronized with CKEditor.
/// This configuration option is global and executed during the jQuery Adapter loading. It can't be customized across editor instances.
/// Default Value: true
///
[CKSerializable]
public bool jqueryOverrideVal { get; set; }
///
/// A list associating keystrokes to editor commands. Each element in the list is an array where the first item is the keystroke,
/// and the second is the name of the command to be executed.
/// Default Value: null
///
[CKSerializable]
public object[] justifyClasses { get; set; }
///
/// A list associating keystrokes to editor commands. Each element in the list is an array where the first item is the keystroke,
/// and the second is the name of the command to be executed.
/// Default Value:
/// GlobalConfigObj.keystrokes = new object[]
/// {
/// new object[] { CKEDITOR_ALT + 121 /*F10*/, "toolbarFocus" },
/// new object[] { CKEDITOR_ALT + 122 /*F11*/, "elementsPathFocus" },
/// new object[] { CKEDITOR_SHIFT + 121 /*F10*/, "contextMenu" },
/// new object[] { CKEDITOR_CTRL + 90 /*Z*/, "undo" },
/// new object[] { CKEDITOR_CTRL + 89 /*Y*/, "redo" },
/// new object[] { CKEDITOR_CTRL + CKEDITOR_SHIFT + 90 /*Z*/, "redo" },
/// new object[] { CKEDITOR_CTRL + 76 /*L*/, "link" },
/// new object[] { CKEDITOR_CTRL + 66 /*B*/, "bold" },
/// new object[] { CKEDITOR_CTRL + 73 /*I*/, "italic" },
/// new object[] { CKEDITOR_CTRL + 85 /*U*/, "underline" },
/// new object[] { CKEDITOR_ALT + 109 /*-*/, "toolbarCollapse" }
/// };
///
[CKSerializable]
public object[] keystrokes { get; set; }
///
/// The user interface language localization to use. If empty, the editor automatically localize the editor to the user language,
/// if supported, otherwise the CKEDITOR.config.defaultLanguage language is used.
/// Default Value: ""
///
[CKSerializable]
public string language { get; set; }
///
/// A comma separated list of items group names to be displayed in the context menu.
/// The items order will reflect the order in this list if no priority has been definted in the groups.
/// Default Value: "clipboard,form,tablecell,tablecellproperties,tablerow,tablecolumn,table,anchor,link,image,flash,checkbox,radio,textfield,hiddenfield,imagebutton,button,select,textarea"
///
[CKSerializable]
public string menu_groups { get; set; }
///
/// The HTML to load in the editor when the "new page" command is executed.
/// Default Value: ""
///
[CKSerializable]
public string newpage_html { get; set; }
///
/// The file that provides the MS Word cleanup function for pasting operations.
/// Note: This is a global configuration shared by all editor instances present in the page.
/// Default Value: "default"
///
[CKSerializable]
public string pasteFromWordCleanupFile { get; set; }
///
/// Whether to transform MS Word outline numbered headings into lists.
/// Default Value: false
///
[CKSerializable]
public bool pasteFromWordNumberedHeadingToList { get; set; }
///
/// Whether to prompt the user about the clean up of content being pasted from MS Word.
/// Default Value: false
///
[CKSerializable]
public bool pasteFromWordPromptCleanup { get; set; }
///
/// Whether to ignore all font related formatting styles, including:
/// font size;
/// font family;
/// font foreground/background color.
/// Default Value: true
///
[CKSerializable]
public bool pasteFromWordRemoveFontStyles { get; set; }
///
/// Whether to remove element styles that can't be managed with the editor. Note that this doesn't handle the font specific styles,
/// which depends on the CKEDITOR.config.pasteFromWordRemoveFontStyles setting instead.
/// Default Value: false
///
[CKSerializable]
public bool pasteFromWordRemoveStyles { get; set; }
// todo
// ///
// /// Comma separated list of plugins to load and initialize for an editor instance. This should be rarely changed, using instead the CKEDITOR.config.extraPlugins and CKEDITOR.config.removePlugins for customizations.
// ///
// [CKSerializable]
// public string plugins { get; set; }
///
/// List of regular expressions to be executed over the input HTML, indicating HTML source code that matched must not present in WYSIWYG mode for editing.
/// Default Value: []
///
public string[] protectedSource { get; set; }
///
/// If true, makes the editor start in read-only state. Otherwise, it will check if the linked
[CKSerializable]
public bool readOnly { get; set; }
///
/// The dialog contents to removed. It's a string composed by dialog name and tab name with a colon between them.
/// Separate each pair with semicolon (see example). Note: All names are case-sensitive.
/// Note: Be cautious when specifying dialog tabs that are mandatory, like "info",
/// dialog functionality might be broken because of this!
/// Default Value: ""
///
[CKSerializable]
public string removeDialogTabs { get; set; }
///
/// A comma separated list of elements attributes to be removed when executing the "remove format" command.
/// Default Value: "class,style,lang,width,height,align,hspace,valign"
///
[CKSerializable]
public string removeFormatAttributes { get; set; }
///
/// A comma separated list of elements to be removed when executing the "remove " format" command. Note that only inline elements are allowed.
/// Default Value: "b,big,code,del,dfn,em,font,i,ins,kbd,q,samp,small,span,strike,strong,sub,sup,tt,u,var"
///
[CKSerializable]
public string removeFormatTags { get; set; }
///
/// List of plugins that must not be loaded. This is a tool setting which makes it easier to avoid loading plugins definied
/// in the CKEDITOR.config.plugins setting, whithout having to touch it and potentially breaking it.
/// Default Value: ""
///
[CKSerializable]
public string removePlugins { get; set; }
///
/// The directions to which the editor resizing is enabled. Possible values are:
/// public enum ResizeDir
/// {
/// Both,
/// Vertical,
/// Horizontal
///}
/// Default Value: ResizeDir.Both;
///
public ResizeDir resize_dir { get; set; }
[CKSerializable(Name = "resize_dir")]
private string resize_dirSer { get { return resize_dir.ToString().ToLower(); } }
///
/// Whether to enable the resizing feature. If disabled the resize handler will not be visible.
/// Default Value: true
///
[CKSerializable]
public bool resize_enabled { get; set; }
///
/// The maximum editor height, in pixels, when resizing it with the resize handle.
/// Default Value: 3000
///
[CKSerializable]
public int resize_maxHeight { get; set; }
///
/// The maximum editor width, in pixels, when resizing it with the resize handle.
/// Default Value: 3000
///
[CKSerializable]
public int resize_maxWidth { get; set; }
///
/// The minimum editor height, in pixels, when resizing it with the resize handle.
/// Note: It fallbacks to editor's actual height if that's smaller than the default value.
/// Default Value: 250
///
[CKSerializable]
public int resize_minHeight { get; set; }
///
/// The minimum editor width, in pixels, when resizing it with the resize handle.
/// Note: It fallbacks to editor's actual width if that's smaller than the default value.
/// Default Value: 750
///
[CKSerializable]
public int resize_minWidth { get; set; }
///
/// If enabled (true), turns on SCAYT automatically after loading the editor.
/// Default Value: false
///
[CKSerializable]
public bool scayt_autoStartup { get; set; }
///
/// Customizes the display of SCAYT context menu commands ("Add Word", "Ignore" and "Ignore All"). It must be a string with one or more of the following words separated by a pipe ("|"):
/// enum ScaytContextCommands
/// {
/// Off = 0 - disables all options
/// All = 1 - enables all options
/// Ignore = 2 - enables the "Ignore" option
/// Ignoreall = 4 - enables the "Ignore All" option
/// Add = 8 - enables the "Add Word" option
/// }
/// Default Value: ScaytContextCommands.All;
///
public ScaytContextCommands scayt_contextCommands { get; set; }
[CKSerializable(Name = "scayt_contextCommands")]
private string scayt_contextCommandsSer { get { return scayt_contextCommands.ToString().ToLower().Replace(", ", "|").Replace(",", "|"); } }
///
/// Define order of placing of SCAYT context menu items by groups. It must be a string with one or more of the following words separated by a pipe ("|"):
/// enum ScaytContextMenuItemsOrder
/// {
/// Suggest = 1 - main suggestion word list
/// Moresuggest = 2 - moresuggest
/// Control = 4 - SCAYT commands, such as 'Ignore' and 'Add Word'
/// }
/// Default Value: ScaytContextMenuItemsOrder.Suggest | ScaytContextMenuItemsOrder.Moresuggest | ScaytContextMenuItemsOrder.Control;
///
public ScaytContextMenuItemsOrder scayt_contextMenuItemsOrder { get; set; }
[CKSerializable(Name = "scayt_contextMenuItemsOrder")]
private string scayt_contextMenuItemsOrderSer { get { return scayt_contextMenuItemsOrder.ToString().ToLower().Replace(", ", "|").Replace(",", "|"); } }
///
/// Links SCAYT to custom dictionaries. It's a string containing dictionary ids separared by commas (",").
/// Available only for licensed version. Further details at http://wiki.spellchecker.net/doku.php?id=custom_dictionary_support .
/// Default Value: ""
///
[CKSerializable]
public string scayt_customDictionaryIds { get; set; }
///
/// Sets the customer ID for SCAYT. Required for migration from free version with banner to paid version.
/// Default Value: ""
///
[CKSerializable]
public string scayt_customerid { get; set; }
///
/// Defines the number of SCAYT suggestions to show in the main context menu. The possible values are:
/// 0 (zero): All suggestions are displayed in the main context menu.
/// Positive number: The maximum number of suggestions to shown in context menu. Other entries will be shown in "More Suggestions" sub-menu.
/// Negative number: No suggestions are shown in the main context menu. All entries will be listed in the "Suggestions" sub-menu.
/// Default Value: 5
///
[CKSerializable]
public int scayt_maxSuggestions { get; set; }
///
/// Enables/disables the "More Suggestions" sub-menu in the context menu. The possible values are:
/// public enum ScaytMoreSuggestions
/// {
/// On,
/// Off
/// }
/// Default Value: ScaytMoreSuggestions.On;
///
public ScaytMoreSuggestions scayt_moreSuggestions { get; set; }
[CKSerializable(Name = "scayt_moreSuggestions")]
private string scayt_moreSuggestionsSer { get { return scayt_moreSuggestions.ToString().ToLower(); } }
///
/// Sets the default spellchecking language for SCAYT.
/// Default Value: "en_US"
///
[CKSerializable]
public string scayt_sLang { get; set; }
///
/// Set the URL to SCAYT core. Required to switch to licensed version of SCAYT application.
/// Further details at http://wiki.spellchecker.net/doku.php?id=3rd:wysiwyg:fckeditor:wscckf3l .
/// Default Value: ""
///
[CKSerializable]
public string scayt_srcUrl { get; set; }
///
/// Sets the visibility of the SCAYT tabs in the settings dialog and toolbar button.
/// The value must contain a "1" (enabled) or "0" (disabled) number for each of the following entries, in this precise order,
/// separated by a comma (","): "Options", "Languages" and "Dictionary".
/// Default Value: "1,1,1"
///
[CKSerializable]
public string scayt_uiTabs { get; set; }
///
/// Makes it possible to activate a custom dictionary on SCAYT. The user dictionary name must be used.
/// Available only for licensed version.
/// Default Value: ""
///
[CKSerializable]
public string scayt_userDictionaryName { get; set; }
private string _sharedSpacesBottom;
public string sharedSpacesBottom
{
get { return _sharedSpacesBottom; }
set
{
_sharedSpacesBottom = value;
if (!string.IsNullOrEmpty(_sharedSpacesBottom) && !removePlugins.Contains("resize"))
removePlugins = string.IsNullOrEmpty(removePlugins) ? "resize" : (removePlugins + ",resize");
}
}
private string _sharedSpacesTop;
public string sharedSpacesTop
{
get { return _sharedSpacesTop; }
set
{
_sharedSpacesTop = value;
if (!string.IsNullOrEmpty(_sharedSpacesTop) && !removePlugins.Contains("maximize"))
removePlugins = string.IsNullOrEmpty(removePlugins) ? "maximize" : (removePlugins + ",maximize");
}
}
[CKSerializable(IsObject = true)]
private string sharedSpaces
{
get
{
string retVal = string.Empty;
if (!string.IsNullOrEmpty(sharedSpacesBottom) || !string.IsNullOrEmpty(sharedSpacesTop))
{
retVal += "{";
if (!string.IsNullOrEmpty(sharedSpacesTop)) retVal += ("top:'" + sharedSpacesTop + "'");
if (!string.IsNullOrEmpty(sharedSpacesBottom) && !string.IsNullOrEmpty(sharedSpacesTop)) retVal += ",";
if (!string.IsNullOrEmpty(sharedSpacesBottom)) retVal += ("bottom:'" + sharedSpacesBottom + "'");
retVal += "}";
}
return retVal;
}
}
///
/// Just like the CKEDITOR.config.enterMode setting, it defines the behavior for the SHIFT+ENTER key.
/// The allowed values are the following constants, and their relative behavior:
/// public enum EnterMode
/// {
/// P = 1 - new
paragraphs are created
/// BR = 2 - lines are broken with elements
/// DIV = 3 - new