} dictionary
148 | *
149 | * @returns {String} The minified version
150 | */
151 | _min: function( value, dictionary ) {
152 | /**
153 | * If a value actually is a single character, prefix it
154 | * with ___ to avoid mistaking it for a minification code
155 | */
156 | if( typeof value === 'string' && value.length === 1 ) {
157 | return '___' + value;
158 | }
159 |
160 | var index = lm.utils.indexOf( value, dictionary );
161 |
162 | /**
163 | * value not found in the dictionary, return it unmodified
164 | */
165 | if( index === -1 ) {
166 | return value;
167 |
168 | /**
169 | * value found in dictionary, return its base36 counterpart
170 | */
171 | } else {
172 | return index.toString( 36 );
173 | }
174 | },
175 |
176 | _max: function( value, dictionary ) {
177 | /**
178 | * value is a single character. Assume that it's a translation
179 | * and return the original value from the dictionary
180 | */
181 | if( typeof value === 'string' && value.length === 1 ) {
182 | return dictionary[ parseInt( value, 36 ) ];
183 | }
184 |
185 | /**
186 | * value originally was a single character and was prefixed with ___
187 | * to avoid mistaking it for a translation. Remove the prefix
188 | * and return the original character
189 | */
190 | if( typeof value === 'string' && value.substr( 0, 3 ) === '___' ) {
191 | return value[ 3 ];
192 | }
193 | /**
194 | * value was not minified
195 | */
196 | return value;
197 | }
198 | } );
199 |
--------------------------------------------------------------------------------
/src/js/container/ItemContainer.js:
--------------------------------------------------------------------------------
1 | lm.container.ItemContainer = function( config, parent, layoutManager ) {
2 | lm.utils.EventEmitter.call( this );
3 |
4 | this.width = null;
5 | this.height = null;
6 | this.title = config.componentName;
7 | this.parent = parent;
8 | this.layoutManager = layoutManager;
9 | this.isHidden = false;
10 |
11 | this._config = config;
12 | this._element = $( [
13 | ''
16 | ].join( '' ) );
17 |
18 | this._contentElement = this._element.find( '.lm_content' );
19 | };
20 |
21 | lm.utils.copy( lm.container.ItemContainer.prototype, {
22 |
23 | /**
24 | * Get the inner DOM element the container's content
25 | * is intended to live in
26 | *
27 | * @returns {DOM element}
28 | */
29 | getElement: function() {
30 | return this._contentElement;
31 | },
32 |
33 | /**
34 | * Hide the container. Notifies the containers content first
35 | * and then hides the DOM node. If the container is already hidden
36 | * this should have no effect
37 | *
38 | * @returns {void}
39 | */
40 | hide: function() {
41 | this.emit( 'hide' );
42 | this.isHidden = true;
43 | this._element.hide();
44 | },
45 |
46 | /**
47 | * Shows a previously hidden container. Notifies the
48 | * containers content first and then shows the DOM element.
49 | * If the container is already visible this has no effect.
50 | *
51 | * @returns {void}
52 | */
53 | show: function() {
54 | this.emit( 'show' );
55 | this.isHidden = false;
56 | this._element.show();
57 | // call shown only if the container has a valid size
58 | if( this.height != 0 || this.width != 0 ) {
59 | this.emit( 'shown' );
60 | }
61 | },
62 |
63 | /**
64 | * Set the size from within the container. Traverses up
65 | * the item tree until it finds a row or column element
66 | * and resizes its items accordingly.
67 | *
68 | * If this container isn't a descendant of a row or column
69 | * it returns false
70 | * @todo Rework!!!
71 | * @param {Number} width The new width in pixel
72 | * @param {Number} height The new height in pixel
73 | *
74 | * @returns {Boolean} resizeSuccesful
75 | */
76 | setSize: function( width, height ) {
77 | var rowOrColumn = this.parent,
78 | rowOrColumnChild = this,
79 | totalPixel,
80 | percentage,
81 | direction,
82 | newSize,
83 | delta,
84 | i;
85 |
86 | while( !rowOrColumn.isColumn && !rowOrColumn.isRow ) {
87 | rowOrColumnChild = rowOrColumn;
88 | rowOrColumn = rowOrColumn.parent;
89 |
90 |
91 | /**
92 | * No row or column has been found
93 | */
94 | if( rowOrColumn.isRoot ) {
95 | return false;
96 | }
97 | }
98 |
99 | direction = rowOrColumn.isColumn ? "height" : "width";
100 | newSize = direction === "height" ? height : width;
101 |
102 | totalPixel = this[ direction ] * ( 1 / ( rowOrColumnChild.config[ direction ] / 100 ) );
103 | percentage = ( newSize / totalPixel ) * 100;
104 | delta = ( rowOrColumnChild.config[ direction ] - percentage ) / (rowOrColumn.contentItems.length - 1);
105 |
106 | for( i = 0; i < rowOrColumn.contentItems.length; i++ ) {
107 | if( rowOrColumn.contentItems[ i ] === rowOrColumnChild ) {
108 | rowOrColumn.contentItems[ i ].config[ direction ] = percentage;
109 | } else {
110 | rowOrColumn.contentItems[ i ].config[ direction ] += delta;
111 | }
112 | }
113 |
114 | rowOrColumn.callDownwards( 'setSize' );
115 |
116 | return true;
117 | },
118 |
119 | /**
120 | * Closes the container if it is closable. Can be called by
121 | * both the component within at as well as the contentItem containing
122 | * it. Emits a close event before the container itself is closed.
123 | *
124 | * @returns {void}
125 | */
126 | close: function() {
127 | if( this._config.isClosable ) {
128 | this.emit( 'close' );
129 | this.parent.close();
130 | }
131 | },
132 |
133 | /**
134 | * Returns the current state object
135 | *
136 | * @returns {Object} state
137 | */
138 | getState: function() {
139 | return this._config.componentState;
140 | },
141 |
142 | /**
143 | * Merges the provided state into the current one
144 | *
145 | * @param {Object} state
146 | *
147 | * @returns {void}
148 | */
149 | extendState: function( state ) {
150 | this.setState( $.extend( true, this.getState(), state ) );
151 | },
152 |
153 | /**
154 | * Notifies the layout manager of a stateupdate
155 | *
156 | * @param {serialisable} state
157 | */
158 | setState: function( state ) {
159 | this._config.componentState = state;
160 | this.parent.emitBubblingEvent( 'stateChanged' );
161 | },
162 |
163 | /**
164 | * Set's the components title
165 | *
166 | * @param {String} title
167 | */
168 | setTitle: function( title ) {
169 | this.parent.setTitle( title );
170 | },
171 |
172 | /**
173 | * Set's the containers size. Called by the container's component.
174 | * To set the size programmatically from within the container please
175 | * use the public setSize method
176 | *
177 | * @param {[Int]} width in px
178 | * @param {[Int]} height in px
179 | *
180 | * @returns {void}
181 | */
182 | _$setSize: function( width, height ) {
183 | if( width !== this.width || height !== this.height ) {
184 | this.width = width;
185 | this.height = height;
186 | var cl = this._contentElement[0];
187 | var hdelta = cl.offsetWidth - cl.clientWidth;
188 | var vdelta = cl.offsetHeight - cl.clientHeight;
189 | this._contentElement.width( this.width-hdelta )
190 | .height( this.height-vdelta );
191 | this.emit( 'resize' );
192 | }
193 | }
194 | } );
195 |
--------------------------------------------------------------------------------
/test/event-emitter-tests.js:
--------------------------------------------------------------------------------
1 | describe( 'the EventEmitter works', function(){
2 | var EmitterImplementor = function() {
3 | lm.utils.EventEmitter.call( this );
4 | };
5 |
6 | it( 'is possible to inherit from EventEmitter', function(){
7 | var myObject = new EmitterImplementor();
8 | expect( typeof myObject.on ).toBe( 'function' );
9 | expect( typeof myObject.unbind ).toBe( 'function' );
10 | expect( typeof myObject.trigger ).toBe( 'function' );
11 | });
12 |
13 | it( 'notifies callbacks', function(){
14 | var myObject = new EmitterImplementor();
15 | var myListener = { callback: function(){} };
16 | spyOn( myListener, 'callback' );
17 | expect( myListener.callback ).not.toHaveBeenCalled();
18 | myObject.on( 'someEvent', myListener.callback );
19 | expect( myListener.callback ).not.toHaveBeenCalled();
20 | myObject.emit( 'someEvent', 'Good', 'Morning' );
21 | expect( myListener.callback ).toHaveBeenCalledWith( 'Good', 'Morning' );
22 | expect(myListener.callback.calls.length).toEqual(1);
23 | });
24 |
25 | it( 'triggers an \'all\' event', function(){
26 | var myObject = new EmitterImplementor();
27 | var myListener = { callback: function(){}, allCallback: function(){} };
28 | spyOn( myListener, 'callback' );
29 | spyOn( myListener, 'allCallback' );
30 |
31 | myObject.on( 'someEvent', myListener.callback );
32 | myObject.on( lm.utils.EventEmitter.ALL_EVENT, myListener.allCallback );
33 |
34 |
35 | expect( myListener.callback ).not.toHaveBeenCalled();
36 | expect( myListener.allCallback ).not.toHaveBeenCalled();
37 | myObject.emit( 'someEvent', 'Good', 'Morning' );
38 | expect( myListener.callback ).toHaveBeenCalledWith( 'Good', 'Morning' );
39 | expect(myListener.callback.calls.length).toEqual(1);
40 | expect( myListener.allCallback ).toHaveBeenCalledWith( 'someEvent', 'Good', 'Morning' );
41 | expect(myListener.allCallback.calls.length).toEqual(1);
42 |
43 | myObject.emit( 'someOtherEvent', 123 );
44 | expect(myListener.callback.calls.length).toEqual(1);
45 | expect(myListener.allCallback ).toHaveBeenCalledWith( 'someOtherEvent', 123 );
46 | expect(myListener.allCallback.calls.length).toEqual(2);
47 | });
48 |
49 | it( 'triggers sets the right context', function(){
50 | var myObject = new EmitterImplementor();
51 | var context = null;
52 | var myListener = { callback: function(){
53 | context = this;
54 | }};
55 |
56 | myObject.on( 'someEvent', myListener.callback, {some: 'thing' } );
57 | expect( context ).toBe( null );
58 | myObject.emit( 'someEvent' );
59 | expect( context.some ).toBe( 'thing' );
60 | });
61 |
62 | it( 'unbinds events', function(){
63 | var myObject = new EmitterImplementor();
64 | var myListener = { callback: function(){}};
65 | spyOn( myListener, 'callback' );
66 | myObject.on( 'someEvent', myListener.callback );
67 | expect(myListener.callback.calls.length).toEqual(0);
68 | myObject.emit( 'someEvent' );
69 | expect(myListener.callback.calls.length).toEqual(1);
70 | myObject.unbind( 'someEvent', myListener.callback );
71 | myObject.emit( 'someEvent' );
72 | expect(myListener.callback.calls.length).toEqual(1);
73 | });
74 |
75 | it( 'unbinds all events if no context is provided', function(){
76 | var myObject = new EmitterImplementor();
77 | var myListener = { callback: function(){}};
78 | spyOn( myListener, 'callback' );
79 | myObject.on( 'someEvent', myListener.callback );
80 | expect(myListener.callback.calls.length).toEqual(0);
81 | myObject.emit( 'someEvent' );
82 | expect(myListener.callback.calls.length).toEqual(1);
83 | myObject.unbind( 'someEvent' );
84 | myObject.emit( 'someEvent' );
85 | expect(myListener.callback.calls.length).toEqual(1);
86 | });
87 |
88 | it( 'unbinds events for a specific context only', function(){
89 | var myObject = new EmitterImplementor();
90 | var myListener = { callback: function(){}};
91 | var contextA = { name: 'a' };
92 | var contextB = { name: 'b' };
93 | spyOn( myListener, 'callback' );
94 | myObject.on( 'someEvent', myListener.callback, contextA );
95 | myObject.on( 'someEvent', myListener.callback, contextB );
96 | expect(myListener.callback.calls.length).toEqual(0);
97 | myObject.emit( 'someEvent' );
98 | expect(myListener.callback.calls.length).toEqual(2);
99 | myObject.unbind( 'someEvent', myListener.callback, contextA );
100 | myObject.emit( 'someEvent' );
101 | expect(myListener.callback.calls.length).toEqual(3);
102 | myObject.unbind( 'someEvent', myListener.callback, contextB );
103 | myObject.emit( 'someEvent' );
104 | expect(myListener.callback.calls.length).toEqual(3);
105 | });
106 |
107 | it( 'throws an exception when trying to unsubscribe for a non existing method', function(){
108 | var myObject = new EmitterImplementor();
109 | var myListener = { callback: function(){}};
110 |
111 | myObject.on( 'someEvent', myListener.callback );
112 |
113 | expect(function(){
114 | myObject.unbind( 'someEvent', function(){} );
115 | }).toThrow();
116 |
117 | expect(function(){
118 | myObject.unbind( 'doesNotExist', myListener.callback );
119 | }).toThrow();
120 |
121 | expect(function(){
122 | myObject.unbind( 'someEvent', myListener.callback );
123 | }).not.toThrow();
124 | });
125 |
126 | it( 'throws an exception when attempting to bind a non-function', function() {
127 | var myObject = new EmitterImplementor();
128 |
129 | expect(function(){
130 | myObject.on( 'someEvent', 1 );
131 | }).toThrow();
132 |
133 | expect(function(){
134 | myObject.on( 'someEvent', undefined );
135 | }).toThrow();
136 |
137 | expect(function(){
138 | myObject.on( 'someEvent', {} );
139 | }).toThrow();
140 | });
141 | });
--------------------------------------------------------------------------------
/src/js/controls/Tab.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Represents an individual tab within a Stack's header
3 | *
4 | * @param {lm.controls.Header} header
5 | * @param {lm.items.AbstractContentItem} contentItem
6 | *
7 | * @constructor
8 | */
9 | lm.controls.Tab = function( header, contentItem ) {
10 | this.header = header;
11 | this.contentItem = contentItem;
12 | this.element = $( lm.controls.Tab._template );
13 | this.titleElement = this.element.find( '.lm_title' );
14 | this.closeElement = this.element.find( '.lm_close_tab' );
15 | this.closeElement[ contentItem.config.isClosable ? 'show' : 'hide' ]();
16 | this.isActive = false;
17 |
18 | this.setTitle( contentItem.config.title );
19 | this.contentItem.on( 'titleChanged', this.setTitle, this );
20 |
21 | this._layoutManager = this.contentItem.layoutManager;
22 |
23 | if(
24 | this._layoutManager.config.settings.reorderEnabled === true &&
25 | contentItem.config.reorderEnabled === true
26 | ) {
27 | this._dragListener = new lm.utils.DragListener( this.element );
28 | this._dragListener.on( 'dragStart', this._onDragStart, this );
29 | this.contentItem.on( 'destroy', this._dragListener.destroy, this._dragListener );
30 | }
31 |
32 | this._onTabClickFn = lm.utils.fnBind( this._onTabClick, this );
33 | this._onCloseClickFn = lm.utils.fnBind( this._onCloseClick, this );
34 |
35 | this.element.on( 'mousedown touchstart', this._onTabClickFn );
36 |
37 | if( this.contentItem.config.isClosable ) {
38 | this.closeElement.on( 'click touchstart', this._onCloseClickFn );
39 | this.closeElement.on('mousedown', this._onCloseMousedown);
40 | } else {
41 | this.closeElement.remove();
42 | }
43 |
44 | this.contentItem.tab = this;
45 | this.contentItem.emit( 'tab', this );
46 | this.contentItem.layoutManager.emit( 'tabCreated', this );
47 |
48 | if( this.contentItem.isComponent ) {
49 | this.contentItem.container.tab = this;
50 | this.contentItem.container.emit( 'tab', this );
51 | }
52 | };
53 |
54 | /**
55 | * The tab's html template
56 | *
57 | * @type {String}
58 | */
59 | lm.controls.Tab._template = '' +
60 | '' +
61 | '';
62 |
63 | lm.utils.copy( lm.controls.Tab.prototype, {
64 |
65 | /**
66 | * Sets the tab's title to the provided string and sets
67 | * its title attribute to a pure text representation (without
68 | * html tags) of the same string.
69 | *
70 | * @public
71 | * @param {String} title can contain html
72 | */
73 | setTitle: function( title ) {
74 | this.element.attr( 'title', lm.utils.stripTags( title ) );
75 | this.titleElement.html( title );
76 | },
77 |
78 | /**
79 | * Sets this tab's active state. To programmatically
80 | * switch tabs, use header.setActiveContentItem( item ) instead.
81 | *
82 | * @public
83 | * @param {Boolean} isActive
84 | */
85 | setActive: function( isActive ) {
86 | if( isActive === this.isActive ) {
87 | return;
88 | }
89 | this.isActive = isActive;
90 |
91 | if( isActive ) {
92 | this.element.addClass( 'lm_active' );
93 | } else {
94 | this.element.removeClass( 'lm_active' );
95 | }
96 | },
97 |
98 | /**
99 | * Destroys the tab
100 | *
101 | * @private
102 | * @returns {void}
103 | */
104 | _$destroy: function() {
105 | this.element.off( 'mousedown touchstart', this._onTabClickFn );
106 | this.closeElement.off( 'click touchstart', this._onCloseClickFn );
107 | if( this._dragListener ) {
108 | this.contentItem.off( 'destroy', this._dragListener.destroy, this._dragListener );
109 | this._dragListener.off( 'dragStart', this._onDragStart );
110 | this._dragListener = null;
111 | }
112 | this.element.remove();
113 | },
114 |
115 | /**
116 | * Callback for the DragListener
117 | *
118 | * @param {Number} x The tabs absolute x position
119 | * @param {Number} y The tabs absolute y position
120 | *
121 | * @private
122 | * @returns {void}
123 | */
124 | _onDragStart: function( x, y ) {
125 | if( this.contentItem.parent.isMaximised === true ) {
126 | this.contentItem.parent.toggleMaximise();
127 | }
128 | new lm.controls.DragProxy(
129 | x,
130 | y,
131 | this._dragListener,
132 | this._layoutManager,
133 | this.contentItem,
134 | this.header.parent
135 | );
136 | },
137 |
138 | /**
139 | * Callback when the tab is clicked
140 | *
141 | * @param {jQuery DOM event} event
142 | *
143 | * @private
144 | * @returns {void}
145 | */
146 | _onTabClick: function( event ) {
147 | // left mouse button or tap
148 | if( event.button === 0 || event.type === 'touchstart' ) {
149 | var activeContentItem = this.header.parent.getActiveContentItem();
150 | if( this.contentItem !== activeContentItem ) {
151 | this.header.parent.setActiveContentItem( this.contentItem );
152 | }
153 |
154 | // middle mouse button
155 | } else if( event.button === 1 && this.contentItem.config.isClosable ) {
156 | this._onCloseClick( event );
157 | }
158 | },
159 |
160 | /**
161 | * Callback when the tab's close button is
162 | * clicked
163 | *
164 | * @param {jQuery DOM event} event
165 | *
166 | * @private
167 | * @returns {void}
168 | */
169 | _onCloseClick: function( event ) {
170 | event.stopPropagation();
171 | this.header.parent.removeChild( this.contentItem );
172 | },
173 |
174 |
175 | /**
176 | * Callback to capture tab close button mousedown
177 | * to prevent tab from activating.
178 | *
179 | * @param (jQuery DOM event) event
180 | *
181 | * @private
182 | * @returns {void}
183 | */
184 | _onCloseMousedown: function(event) {
185 | event.stopPropagation();
186 | }
187 | } );
188 |
--------------------------------------------------------------------------------
/src/js/utils/utils.js:
--------------------------------------------------------------------------------
1 | lm.utils.F = function() {
2 | };
3 |
4 | lm.utils.extend = function( subClass, superClass ) {
5 | subClass.prototype = lm.utils.createObject( superClass.prototype );
6 | subClass.prototype.contructor = subClass;
7 | };
8 |
9 | lm.utils.createObject = function( prototype ) {
10 | if( typeof Object.create === 'function' ) {
11 | return Object.create( prototype );
12 | } else {
13 | lm.utils.F.prototype = prototype;
14 | return new lm.utils.F();
15 | }
16 | };
17 |
18 | lm.utils.objectKeys = function( object ) {
19 | var keys, key;
20 |
21 | if( typeof Object.keys === 'function' ) {
22 | return Object.keys( object );
23 | } else {
24 | keys = [];
25 | for( key in object ) {
26 | keys.push( key );
27 | }
28 | return keys;
29 | }
30 | };
31 |
32 | lm.utils.getHashValue = function( key ) {
33 | var matches = location.hash.match( new RegExp( key + '=([^&]*)' ) );
34 | return matches ? matches[ 1 ] : null;
35 | };
36 |
37 | lm.utils.getQueryStringParam = function( param ) {
38 | if( window.location.hash ) {
39 | return lm.utils.getHashValue( param );
40 | } else if( !window.location.search ) {
41 | return null;
42 | }
43 |
44 | var keyValuePairs = window.location.search.substr( 1 ).split( '&' ),
45 | params = {},
46 | pair,
47 | i;
48 |
49 | for( i = 0; i < keyValuePairs.length; i++ ) {
50 | pair = keyValuePairs[ i ].split( '=' );
51 | params[ pair[ 0 ] ] = pair[ 1 ];
52 | }
53 |
54 | return params[ param ] || null;
55 | };
56 |
57 | lm.utils.copy = function( target, source ) {
58 | for( var key in source ) {
59 | target[ key ] = source[ key ];
60 | }
61 | return target;
62 | };
63 |
64 | /**
65 | * This is based on Paul Irish's shim, but looks quite odd in comparison. Why?
66 | * Because
67 | * a) it shouldn't affect the global requestAnimationFrame function
68 | * b) it shouldn't pass on the time that has passed
69 | *
70 | * @param {Function} fn
71 | *
72 | * @returns {void}
73 | */
74 | lm.utils.animFrame = function( fn ) {
75 | return ( window.requestAnimationFrame ||
76 | window.webkitRequestAnimationFrame ||
77 | window.mozRequestAnimationFrame ||
78 | function( callback ) {
79 | window.setTimeout( callback, 1000 / 60 );
80 | })( function() {
81 | fn();
82 | } );
83 | };
84 |
85 | lm.utils.indexOf = function( needle, haystack ) {
86 | if( !( haystack instanceof Array ) ) {
87 | throw new Error( 'Haystack is not an Array' );
88 | }
89 |
90 | if( haystack.indexOf ) {
91 | return haystack.indexOf( needle );
92 | } else {
93 | for( var i = 0; i < haystack.length; i++ ) {
94 | if( haystack[ i ] === needle ) {
95 | return i;
96 | }
97 | }
98 | return -1;
99 | }
100 | };
101 |
102 | if( typeof /./ != 'function' && typeof Int8Array != 'object' ) {
103 | lm.utils.isFunction = function( obj ) {
104 | return typeof obj == 'function' || false;
105 | };
106 | } else {
107 | lm.utils.isFunction = function( obj ) {
108 | return toString.call( obj ) === '[object Function]';
109 | };
110 | }
111 |
112 | lm.utils.fnBind = function( fn, context, boundArgs ) {
113 |
114 | if( Function.prototype.bind !== undefined ) {
115 | return Function.prototype.bind.apply( fn, [ context ].concat( boundArgs || [] ) );
116 | }
117 |
118 | var bound = function() {
119 |
120 | // Join the already applied arguments to the now called ones (after converting to an array again).
121 | var args = ( boundArgs || [] ).concat( Array.prototype.slice.call( arguments, 0 ) );
122 |
123 | // If not being called as a constructor
124 | if( !(this instanceof bound) ) {
125 | // return the result of the function called bound to target and partially applied.
126 | return fn.apply( context, args );
127 | }
128 | // If being called as a constructor, apply the function bound to self.
129 | fn.apply( this, args );
130 | };
131 | // Attach the prototype of the function to our newly created function.
132 | bound.prototype = fn.prototype;
133 | return bound;
134 | };
135 |
136 | lm.utils.removeFromArray = function( item, array ) {
137 | var index = lm.utils.indexOf( item, array );
138 |
139 | if( index === -1 ) {
140 | throw new Error( 'Can\'t remove item from array. Item is not in the array' );
141 | }
142 |
143 | array.splice( index, 1 );
144 | };
145 |
146 | lm.utils.now = function() {
147 | if( typeof Date.now === 'function' ) {
148 | return Date.now();
149 | } else {
150 | return ( new Date() ).getTime();
151 | }
152 | };
153 |
154 | lm.utils.getUniqueId = function() {
155 | return ( Math.random() * 1000000000000000 )
156 | .toString( 36 )
157 | .replace( '.', '' );
158 | };
159 |
160 | /**
161 | * A basic XSS filter. It is ultimately up to the
162 | * implementing developer to make sure their particular
163 | * applications and usecases are save from cross site scripting attacks
164 | *
165 | * @param {String} input
166 | * @param {Boolean} keepTags
167 | *
168 | * @returns {String} filtered input
169 | */
170 | lm.utils.filterXss = function( input, keepTags ) {
171 |
172 | var output = input
173 | .replace( /javascript/gi, 'javascript' )
174 | .replace( /expression/gi, 'expression' )
175 | .replace( /onload/gi, 'onload' )
176 | .replace( /script/gi, 'script' )
177 | .replace( /onerror/gi, 'onerror' );
178 |
179 | if( keepTags === true ) {
180 | return output;
181 | } else {
182 | return output
183 | .replace( />/g, '>' )
184 | .replace( /]+)>)/ig, '' ) );
197 | };
--------------------------------------------------------------------------------
/src/js/controls/DragProxy.js:
--------------------------------------------------------------------------------
1 | /**
2 | * This class creates a temporary container
3 | * for the component whilst it is being dragged
4 | * and handles drag events
5 | *
6 | * @constructor
7 | * @private
8 | *
9 | * @param {Number} x The initial x position
10 | * @param {Number} y The initial y position
11 | * @param {lm.utils.DragListener} dragListener
12 | * @param {lm.LayoutManager} layoutManager
13 | * @param {lm.item.AbstractContentItem} contentItem
14 | * @param {lm.item.AbstractContentItem} originalParent
15 | */
16 | lm.controls.DragProxy = function( x, y, dragListener, layoutManager, contentItem, originalParent ) {
17 |
18 | lm.utils.EventEmitter.call( this );
19 |
20 | this._dragListener = dragListener;
21 | this._layoutManager = layoutManager;
22 | this._contentItem = contentItem;
23 | this._originalParent = originalParent;
24 |
25 | this._area = null;
26 | this._lastValidArea = null;
27 |
28 | this._dragListener.on( 'drag', this._onDrag, this );
29 | this._dragListener.on( 'dragStop', this._onDrop, this );
30 |
31 | this.element = $( lm.controls.DragProxy._template );
32 | if( originalParent && originalParent._side ) {
33 | this._sided = originalParent._sided;
34 | this.element.addClass( 'lm_' + originalParent._side );
35 | if( [ 'right', 'bottom' ].indexOf( originalParent._side ) >= 0 )
36 | this.element.find( '.lm_content' ).after( this.element.find( '.lm_header' ) );
37 | }
38 | this.element.css( { left: x, top: y } );
39 | this.element.find( '.lm_tab' ).attr( 'title', lm.utils.stripTags( this._contentItem.config.title ) );
40 | this.element.find( '.lm_title' ).html( this._contentItem.config.title );
41 | this.childElementContainer = this.element.find( '.lm_content' );
42 | this.childElementContainer.append( contentItem.element );
43 |
44 | this._updateTree();
45 | this._layoutManager._$calculateItemAreas();
46 | this._setDimensions();
47 |
48 | $( document.body ).append( this.element );
49 |
50 | var offset = this._layoutManager.container.offset();
51 |
52 | this._minX = offset.left;
53 | this._minY = offset.top;
54 | this._maxX = this._layoutManager.container.width() + this._minX;
55 | this._maxY = this._layoutManager.container.height() + this._minY;
56 | this._width = this.element.width();
57 | this._height = this.element.height();
58 |
59 | this._setDropPosition( x, y );
60 | };
61 |
62 | lm.controls.DragProxy._template = '' +
63 | '' +
70 | '
' +
71 | '
' + container._config.title + '
' );
41 |
42 | if( state.style ) {
43 | $( 'head' ).append( '' );
44 | }
45 |
46 | if( state.className ) {
47 | container.getElement().addClass( state.className );
48 | }
49 |
50 | if( state.bg ) {
51 | container
52 | .getElement()
53 | .text( 'hey' )
54 | .append( '
' )
55 | .append( $( '