skylinecms 3.0.7

data/public/skyline/javascripts/src/skyline.editor/vendor/tinymce/jscripts/tiny_mce/classes/ui/Button.js

@@ -0,0 +1,68 @@
+/**
+ * $Id: Button.js 1045 2009-03-04 20:03:18Z spocke $
+ *
+ * @author Moxiecode
+ * @copyright Copyright � 2004-2008, Moxiecode Systems AB, All rights reserved.
+ */
+
+(function(tinymce) {
+	var DOM = tinymce.DOM;
+
+	/**#@+
+	 * @class This class is used to create a UI button. A button is basically a link
+	 * that is styled to look like a button or icon.
+	 * @member tinymce.ui.Button
+	 * @base tinymce.ui.Control
+	 */
+	tinymce.create('tinymce.ui.Button:tinymce.ui.Control', {
+		/**
+		 * Constructs a new button control instance.
+		 *
+		 * @param {String} id Control id for the button.
+		 * @param {Object} s Optional name/value settings object.
+		 */
+		Button : function(id, s) {
+			this.parent(id, s);
+			this.classPrefix = 'mceButton';
+		},
+
+		/**#@+
+		 * @method
+		 */
+
+		/**
+		 * Renders the button as a HTML string. This method is much faster than using the DOM and when
+		 * creating a whole toolbar with buttons it does make a lot of difference.
+		 *
+		 * @return {String} HTML for the button control element.
+		 */
+		renderHTML : function() {
+			var cp = this.classPrefix, s = this.settings, h, l;
+
+			l = DOM.encode(s.label || '');
+			h = '<a id="' + this.id + '" href="javascript:;" class="' + cp + ' ' + cp + 'Enabled ' + s['class'] + (l ? ' ' + cp + 'Labeled' : '') +'" onmousedown="return false;" onclick="return false;" title="' + DOM.encode(s.title) + '">';
+
+			if (s.image)
+				h += '<img class="mceIcon" src="' + s.image + '" />' + l + '</a>';
+			else
+				h += '<span class="mceIcon ' + s['class'] + '"></span>' + (l ? '<span class="' + cp + 'Label">' + l + '</span>' : '') + '</a>';
+
+			return h;
+		},
+
+		/**
+		 * Post render handler. This function will be called after the UI has been
+		 * rendered so that events can be added.
+		 */
+		postRender : function() {
+			var t = this, s = t.settings;
+
+			tinymce.dom.Event.add(t.id, 'click', function(e) {
+				if (!t.isDisabled())
+					return s.onclick.call(s.scope, e);
+			});
+		}
+
+		/**#@-*/
+	});
+})(tinymce);

data/public/skyline/javascripts/src/skyline.editor/vendor/tinymce/jscripts/tiny_mce/classes/ui/ColorSplitButton.js

@@ -0,0 +1,212 @@
+/**
+ * $Id: ColorSplitButton.js 1133 2009-05-20 15:10:57Z spocke $
+ *
+ * @author Moxiecode
+ * @copyright Copyright � 2004-2008, Moxiecode Systems AB, All rights reserved.
+ */
+
+(function(tinymce) {
+	var DOM = tinymce.DOM, Event = tinymce.dom.Event, is = tinymce.is, each = tinymce.each;
+
+	/**#@+
+	 * @class This class is used to create UI color split button. A color split button will present show a small color picker
+	 * when you press the open menu.
+	 * @member tinymce.ui.ColorSplitButton
+	 * @base tinymce.ui.SplitButton
+	 */
+	tinymce.create('tinymce.ui.ColorSplitButton:tinymce.ui.SplitButton', {
+		/**
+		 * Constructs a new color split button control instance.
+		 *
+		 * @param {String} id Control id for the color split button.
+		 * @param {Object} s Optional name/value settings object.
+		 */
+		ColorSplitButton : function(id, s) {
+			var t = this;
+
+			t.parent(id, s);
+
+			t.settings = s = tinymce.extend({
+				colors : '000000,993300,333300,003300,003366,000080,333399,333333,800000,FF6600,808000,008000,008080,0000FF,666699,808080,FF0000,FF9900,99CC00,339966,33CCCC,3366FF,800080,999999,FF00FF,FFCC00,FFFF00,00FF00,00FFFF,00CCFF,993366,C0C0C0,FF99CC,FFCC99,FFFF99,CCFFCC,CCFFFF,99CCFF,CC99FF,FFFFFF',
+				grid_width : 8,
+				default_color : '#888888'
+			}, t.settings);
+
+			t.onShowMenu = new tinymce.util.Dispatcher(t);
+			t.onHideMenu = new tinymce.util.Dispatcher(t);
+
+			t.value = s.default_color;
+		},
+
+		/**#@+
+		 * @method
+		 */
+
+		/**
+		 * Shows the color menu. The color menu is a layer places under the button
+		 * and displays a table of colors for the user to pick from.
+		 */
+		showMenu : function() {
+			var t = this, r, p, e, p2;
+
+			if (t.isDisabled())
+				return;
+
+			if (!t.isMenuRendered) {
+				t.renderMenu();
+				t.isMenuRendered = true;
+			}
+
+			if (t.isMenuVisible)
+				return t.hideMenu();
+
+			e = DOM.get(t.id);
+			DOM.show(t.id + '_menu');
+			DOM.addClass(e, 'mceSplitButtonSelected');
+			p2 = DOM.getPos(e);
+			DOM.setStyles(t.id + '_menu', {
+				left : p2.x,
+				top : p2.y + e.clientHeight,
+				zIndex : 200000
+			});
+			e = 0;
+
+			Event.add(DOM.doc, 'mousedown', t.hideMenu, t);
+			t.onShowMenu.dispatch(t);
+
+			if (t._focused) {
+				t._keyHandler = Event.add(t.id + '_menu', 'keydown', function(e) {
+					if (e.keyCode == 27)
+						t.hideMenu();
+				});
+
+				DOM.select('a', t.id + '_menu')[0].focus(); // Select first link
+			}
+
+			t.isMenuVisible = 1;
+		},
+
+		/**
+		 * Hides the color menu. The optional event parameter is used to check where the event occured so it
+		 * doesn't close them menu if it was a event inside the menu.
+		 *
+		 * @param {Event} e Optional event object.
+		 */
+		hideMenu : function(e) {
+			var t = this;
+
+			// Prevent double toogles by canceling the mouse click event to the button
+			if (e && e.type == "mousedown" && DOM.getParent(e.target, function(e) {return e.id === t.id + '_open';}))
+				return;
+
+			if (!e || !DOM.getParent(e.target, '.mceSplitButtonMenu')) {
+				DOM.removeClass(t.id, 'mceSplitButtonSelected');
+				Event.remove(DOM.doc, 'mousedown', t.hideMenu, t);
+				Event.remove(t.id + '_menu', 'keydown', t._keyHandler);
+				DOM.hide(t.id + '_menu');
+			}
+
+			t.onHideMenu.dispatch(t);
+
+			t.isMenuVisible = 0;
+		},
+
+		/**
+		 * Renders the menu to the DOM.
+		 */
+		renderMenu : function() {
+			var t = this, m, i = 0, s = t.settings, n, tb, tr, w;
+
+			w = DOM.add(s.menu_container, 'div', {id : t.id + '_menu', 'class' : s['menu_class'] + ' ' + s['class'], style : 'position:absolute;left:0;top:-1000px;'});
+			m = DOM.add(w, 'div', {'class' : s['class'] + ' mceSplitButtonMenu'});
+			DOM.add(m, 'span', {'class' : 'mceMenuLine'});
+
+			n = DOM.add(m, 'table', {'class' : 'mceColorSplitMenu'});
+			tb = DOM.add(n, 'tbody');
+
+			// Generate color grid
+			i = 0;
+			each(is(s.colors, 'array') ? s.colors : s.colors.split(','), function(c) {
+				c = c.replace(/^#/, '');
+
+				if (!i--) {
+					tr = DOM.add(tb, 'tr');
+					i = s.grid_width - 1;
+				}
+
+				n = DOM.add(tr, 'td');
+
+				n = DOM.add(n, 'a', {
+					href : 'javascript:;',
+					style : {
+						backgroundColor : '#' + c
+					},
+					mce_color : '#' + c
+				});
+			});
+
+			if (s.more_colors_func) {
+				n = DOM.add(tb, 'tr');
+				n = DOM.add(n, 'td', {colspan : s.grid_width, 'class' : 'mceMoreColors'});
+				n = DOM.add(n, 'a', {id : t.id + '_more', href : 'javascript:;', onclick : 'return false;', 'class' : 'mceMoreColors'}, s.more_colors_title);
+
+				Event.add(n, 'click', function(e) {
+					s.more_colors_func.call(s.more_colors_scope || this);
+					return Event.cancel(e); // Cancel to fix onbeforeunload problem
+				});
+			}
+
+			DOM.addClass(m, 'mceColorSplitMenu');
+
+			Event.add(t.id + '_menu', 'click', function(e) {
+				var c;
+
+				e = e.target;
+
+				if (e.nodeName == 'A' && (c = e.getAttribute('mce_color')))
+					t.setColor(c);
+
+				return Event.cancel(e); // Prevent IE auto save warning
+			});
+
+			return w;
+		},
+
+		/**
+		 * Sets the current color for the control and hides the menu if it should be visible.
+		 *
+		 * @param {String} c Color code value in hex for example: #FF00FF
+		 */
+		setColor : function(c) {
+			var t = this;
+
+			DOM.setStyle(t.id + '_preview', 'backgroundColor', c);
+
+			t.value = c;
+			t.hideMenu();
+			t.settings.onselect(c);
+		},
+
+		postRender : function() {
+			var t = this, id = t.id;
+
+			t.parent();
+			DOM.add(id + '_action', 'div', {id : id + '_preview', 'class' : 'mceColorPreview'});
+			DOM.setStyle(t.id + '_preview', 'backgroundColor', t.value);
+		},
+
+		/**
+		 * Destroys the control. This means it will be removed from the DOM and any
+		 * events tied to it will also be removed.
+		 */
+		destroy : function() {
+			this.parent();
+
+			Event.clear(this.id + '_menu');
+			Event.clear(this.id + '_more');
+			DOM.remove(this.id + '_menu');
+		}
+
+		/**#@-*/
+	});
+})(tinymce);

data/public/skyline/javascripts/src/skyline.editor/vendor/tinymce/jscripts/tiny_mce/classes/ui/Container.js

@@ -0,0 +1,56 @@
+/**
+ * $Id: Container.js 520 2008-01-07 16:30:32Z spocke $
+ *
+ * @author Moxiecode
+ * @copyright Copyright � 2004-2008, Moxiecode Systems AB, All rights reserved.
+ */
+
+/**#@+
+ * @class This class is the base class for all container controls like toolbars. This class should not
+ * be instantiated directly other container controls should inherit from this one.
+ * @member tinymce.ui.Container
+ * @base tinymce.ui.Control
+ */
+tinymce.create('tinymce.ui.Container:tinymce.ui.Control', {
+	/**
+	 * Base contrustor a new container control instance.
+	 *
+	 * @param {String} id Control id to use for the container.
+	 * @param {Object} s Optional name/value settings object.
+	 */
+	Container : function(id, s) {
+		this.parent(id, s);
+		this.controls = [];
+		this.lookup = {};
+	},
+
+	/**#@+
+	 * @method
+	 */
+
+	/**
+	 * Adds a control to the collection of controls for the container.
+	 *
+	 * @param {tinymce.ui.Control} c Control instance to add to the container.
+	 * @return {tinymce.ui.Control} Same control instance that got passed in.
+	 */
+	add : function(c) {
+		this.lookup[c.id] = c;
+		this.controls.push(c);
+
+		return c;
+	},
+
+	/**
+	 * Returns a control by id from the containers collection.
+	 *
+	 * @param {String} n Id for the control to retrive.
+	 * @return {tinymce.ui.Control} Control instance by the specified name or undefined if it wasn't found.
+	 */
+	get : function(n) {
+		return this.lookup[n];
+	}
+
+	/**#@-*/
+});
+

data/public/skyline/javascripts/src/skyline.editor/vendor/tinymce/jscripts/tiny_mce/classes/ui/Control.js

@@ -0,0 +1,182 @@
+/**
+ * $Id: Control.js 1045 2009-03-04 20:03:18Z spocke $
+ *
+ * @author Moxiecode
+ * @copyright Copyright � 2004-2008, Moxiecode Systems AB, All rights reserved.
+ */
+
+(function(tinymce) {
+	// Shorten class names
+	var DOM = tinymce.DOM, is = tinymce.is;
+
+	/**#@+
+	 * @class This class is the base class for all controls like buttons, toolbars, containers. This class should not
+	 * be instantiated directly other controls should inherit from this one.
+	 * @member tinymce.ui.Control
+	 */
+	tinymce.create('tinymce.ui.Control', {
+		/**
+		 * Constructs a new control instance.
+		 *
+		 * @param {String} id Control id.
+		 * @param {Object} s Optional name/value settings object.
+		 */
+		Control : function(id, s) {
+			this.id = id;
+			this.settings = s = s || {};
+			this.rendered = false;
+			this.onRender = new tinymce.util.Dispatcher(this);
+			this.classPrefix = '';
+			this.scope = s.scope || this;
+			this.disabled = 0;
+			this.active = 0;
+		},
+
+		/**#@+
+		 * @method
+		 */
+
+		/**
+		 * Sets the disabled state for the control. This will add CSS classes to the
+		 * element that contains the control. So that it can be disabled visually.
+		 *
+		 * @param {bool} s Boolean state if the control should be disabled or not.
+		 */
+		setDisabled : function(s) {
+			var e;
+
+			if (s != this.disabled) {
+				e = DOM.get(this.id);
+
+				// Add accessibility title for unavailable actions
+				if (e && this.settings.unavailable_prefix) {
+					if (s) {
+						this.prevTitle = e.title;
+						e.title = this.settings.unavailable_prefix + ": " + e.title;
+					} else
+						e.title = this.prevTitle;
+				}
+
+				this.setState('Disabled', s);
+				this.setState('Enabled', !s);
+				this.disabled = s;
+			}
+		},
+
+		/**
+		 * Returns true/false if the control is disabled or not. This is a method since you can then
+		 * choose to check some class or some internal bool state in subclasses.
+		 *
+		 * @return {bool} true/false if the control is disabled or not.
+		 */
+		isDisabled : function() {
+			return this.disabled;
+		},
+
+		/**
+		 * Sets the activated state for the control. This will add CSS classes to the
+		 * element that contains the control. So that it can be activated visually.
+		 *
+		 * @param {bool} s Boolean state if the control should be activated or not.
+		 */
+		setActive : function(s) {
+			if (s != this.active) {
+				this.setState('Active', s);
+				this.active = s;
+			}
+		},
+
+		/**
+		 * Returns true/false if the control is disabled or not. This is a method since you can then
+		 * choose to check some class or some internal bool state in subclasses.
+		 *
+		 * @return {bool} true/false if the control is disabled or not.
+		 */
+		isActive : function() {
+			return this.active;
+		},
+
+		/**
+		 * Sets the specified class state for the control.
+		 *
+		 * @param {String} c Class name to add/remove depending on state.
+		 * @param {bool} s True/false state if the class should be removed or added.
+		 */
+		setState : function(c, s) {
+			var n = DOM.get(this.id);
+
+			c = this.classPrefix + c;
+
+			if (s)
+				DOM.addClass(n, c);
+			else
+				DOM.removeClass(n, c);
+		},
+
+		/**
+		 * Returns true/false if the control has been rendered or not.
+		 *
+		 * @return {bool} State if the control has been rendered or not.
+		 */
+		isRendered : function() {
+			return this.rendered;
+		},
+
+		/**
+		 * Renders the control as a HTML string. This method is much faster than using the DOM and when
+		 * creating a whole toolbar with buttons it does make a lot of difference.
+		 *
+		 * @return {String} HTML for the button control element.
+		 */
+		renderHTML : function() {
+		},
+
+		/**
+		 * Renders the control to the specified container element.
+		 *
+		 * @param {Element} n HTML DOM element to add control to.
+		 */
+		renderTo : function(n) {
+			DOM.setHTML(n, this.renderHTML());
+		},
+
+		/**
+		 * Post render event. This will be executed after the control has been rendered and can be used to
+		 * set states, add events to the control etc. It's recommended for subclasses of the control to call this method by using this.parent().
+		 */
+		postRender : function() {
+			var t = this, b;
+
+			// Set pending states
+			if (is(t.disabled)) {
+				b = t.disabled;
+				t.disabled = -1;
+				t.setDisabled(b);
+			}
+
+			if (is(t.active)) {
+				b = t.active;
+				t.active = -1;
+				t.setActive(b);
+			}
+		},
+
+		/**
+		 * Removes the control. This means it will be removed from the DOM and any
+		 * events tied to it will also be removed.
+		 */
+		remove : function() {
+			DOM.remove(this.id);
+			this.destroy();
+		},
+
+		/**
+		 * Destroys the control will free any memory by removing event listeners etc.
+		 */
+		destroy : function() {
+			tinymce.dom.Event.clear(this.id);
+		}
+
+		/**#@-*/
+	});
+})(tinymce);