FM / plugins

/home/sharedstore/public_html/prestashop.sharedstore.ma/js/jquery/plugins/

/home/sharedstore/public_html/prestashop.sharedstore.ma/js/jquery/plugins

Name	Size	Mode	Actions
ajaxfileupload/	-	0755	rm
alerts/	-	0755	rm
autocomplete/	-	0755	rm
bxslider/	-	0755	rm
chosen/	-	0755	rm
cluetip/	-	0755	rm
fancybox/	-	0755	rm
footable/	-	0755	rm
footable-sort/	-	0755	rm
growl/	-	0755	rm
imgareaselect/	-	0755	rm
jgrowl/	-	0755	rm
jqzoom/	-	0755	rm
jstree/	-	0755	rm
select2/	-	0755	rm
smartWizard/	-	0755	rm
tabpane/	-	0755	rm
thickbox/	-	0755	rm
timepicker/	-	0755	rm
treeview-categories/	-	0755	rm
validate/	-	0755	rm
index.php	1319	0644	edit dl rm
jquery.autosize.js	3177	0644	edit dl rm
jquery.chosen.js	40437	0644	edit dl rm
jquery.colorpicker.js	18263	0644	edit dl rm
jquery.cooki-plugin.js	1698	0644	edit dl rm
jquery.dimensions.js	2515	0644	edit dl rm
jquery.dragtable.js	16915	0644	edit dl rm
jquery.easing.js	4955	0644	edit dl rm
jquery.excanvas.js	19415	0644	edit dl rm
jquery.fieldselection.js	1796	0644	edit dl rm
jquery.flip.js	11771	0644	edit dl rm
jquery.flot.js	37554	0644	edit dl rm
jquery.highlight.js	1364	0644	edit dl rm
jquery.hoverIntent.js	1609	0644	edit dl rm
jquery.idTabs.js	2149	0644	edit dl rm
jquery.ifxtransfer.js	2018	0644	edit dl rm
jquery.jqminmax.js	1955	0644	edit dl rm
jquery.jscroll.js	15036	0644	edit dl rm
jquery.pngFix.js	2572	0644	edit dl rm
jquery.scrollTo.js	2676	0644	edit dl rm
jquery.serialScroll.js	2013	0644	edit dl rm
jquery.sortable.js	2872	0644	edit dl rm
jquery.tablednd.js	12115	0644	edit dl rm
jquery.tablefilter.js	1917	0644	edit dl rm
jquery.tagify.js	3841	0644	edit dl rm
jquery.typewatch.js	2298	0644	edit dl rm
jquery.validate-creditcard.js	3902	0644	edit dl rm
jquery.validate.js	21068	0644	edit dl rm

Edit: /home/sharedstore/public_html/prestashop.sharedstore.ma/js/jquery/plugins/jquery.dragtable.js (16915B)

/*!
 * dragtable - jquery ui widget to re-order table columns 
 * version 3.0
 * 
 * Copyright (c) 2010, Jesse Baird <jebaird@gmail.com>
 * 12/2/2010
 * https://github.com/jebaird/dragtable
 * 
 * Dual licensed under the MIT (MIT-LICENSE.txt)
 * and GPL (GPL-LICENSE.txt) licenses.
 * 
 * 
 * 
 * Forked from https://github.com/akottr/dragtable - Andres Koetter akottr@gmail.com
 * 
 *
 * 
 * 
 * quick down and and dirty on how this works
 * ###########################################
 * so when a column is selected we grab all of the cells in that row and clone append them to a semi copy of the parent table and the 
 * "real" cells get a place holder class witch is removed when the dragstop event is triggered
 * 
 * 
 * make it easy to have a button swap columns
 * 
 * 
 * Events - in order of trigger
 * start - when the user mouses down on handle or th, use in favor of display helper
 * beforechagne - called when a col will be moved
 * change - called after the col has been moved
 * stop - after the user mouses up and stops dragging
 * 
 * 
 * 
 * 
 * IE notes
 * 	ie8 in quirks mode will only drag once after that the events are lost
 * 
 */

var self = this,
				o = self.options,
				el = self.element;
		
			//offsetappendTarget catch for this
			if( o.appendTarget.length == 0 ){
				o.appendTarget = $( document.body );
			}
			//grab the ths and the handles and bind them 
			el.delegate(o.items, 'mousedown.' + self.widgetEventPrefix, function(e){
				
				var $handle = $(this),
					elementOffsetTop = self.element.position().top;

//make sure we are working with a th instead of a handle
				if( $handle.hasClass( o.handle ) ){
					
					$handle = $handle.closest('th');
					//change the target to the th, so the handler can pick up the offsetleft
					e.currentTarget = $handle.closest('th')[0]
				}
				
							
			self.getCol( $handle.index() )
					.attr( 'tabindex', -1 )
	                .focus()
					.disableSelection()
					.css({
	                    top: elementOffsetTop,
	                    //need to account for the scroll left of the append target, other wise the display will be off by that many pix
	                    left: ( self.currentColumnCollectionOffset.left + o.appendTarget[0].scrollLeft )
					})
	                .appendTo( o.appendTarget )

self._mousemoveHandler( e );
				//############
			});
                
		},
		
		/*
		 * e.currentTarget is used for figuring out offsetLeft
		 * getCol must be called before this is 
		 * 
		 */
		_mousemoveHandler: function( e ){
			//call this first, catch any drag display issues
			this._start( e )
				
			var self = this,
				o = self.options,
            	prevMouseX = e.pageX,
            	dragDisplayWidth = self.dragDisplay.outerWidth(),
            	halfDragDisplayWidth = dragDisplayWidth / 2,
            	appendTargetOP = o.appendTarget.offsetParent()[0],
            	scroll = o.scroll,
				//get the col count, used to contain col swap
				colCount = self.element[ 0 ]
								.getElementsByTagName( 'thead' )[ 0 ]
								.getElementsByTagName( 'tr' )[ 0 ]
								.getElementsByTagName( 'th' )
								.length - 1;

$( document ).bind('mousemove.' + self.widgetEventPrefix, function( e ){
            	var columnPos = self._setCurrentColumnCollectionOffset(),
            		mouseXDiff = e.pageX - prevMouseX,
            		appendTarget = o.appendTarget[0],
            		left =  ( parseInt( self.dragDisplay[0].style.left ) + mouseXDiff  );
                self.dragDisplay.css( 'left', left )
                
               /*
                * when moving left and e.pageX and prevMouseX are the same it will trigger right when moving left
                * 
                * it should only swap cols when the col dragging is half over the prev/next col
                */                    
               if( e.pageX  < prevMouseX ){
                   //move left
                   var threshold = columnPos.left - halfDragDisplayWidth;
                   
                   
                   //scroll left
				 	if( left < ( appendTarget.clientWidth  - dragDisplayWidth ) && scroll == true ) {
				 		var scrollLeft =  appendTarget.scrollLeft + mouseXDiff
				 		/*
				 		 * firefox does scroll the body with target being body but chome does
				 		 */
				 		if( appendTarget.tagName == 'BODY' ) {
							window.scroll( window.scrollX + scrollLeft, window.scrollY );
						} else {
							appendTarget.scrollLeft = scrollLeft;
						}
				 		
				 	}
                   
                   
                   if( left  < threshold ){
                   		self._swapCol(self.startIndex-1);
                   }

}else{
				 //move right
				 	var threshold = columnPos.left + halfDragDisplayWidth ;
				 	
				 	//scroll right
				 	if( left > (appendTarget.clientWidth - dragDisplayWidth ) && scroll == true ) {
				 		//console.log(  o.appendTarget[0].clientWidth + (e.pageX - prevMouseX))
				 		
				 		var scrollLeft =  appendTarget.scrollLeft + mouseXDiff
				 		/*
				 		 * firefox does scroll the body with target being body but chome does
				 		 */
				 		if( appendTarget.tagName == 'BODY' ) {
							window.scroll( window.scrollX + scrollLeft, window.scrollY );
						} else {
							appendTarget.scrollLeft = scrollLeft;
						}
				 		
				 	}
				 	
                    //move to the right only if x is greater than threshold and the current col isn' the last one
                    if( left  > threshold  && colCount != self.startIndex ){
                    	self._swapCol( self.startIndex + 1 );
                    }
				}
				//update mouse position
				prevMouseX = e.pageX;
		
            })
            .one( 'mouseup.' + self.widgetEventPrefix ,function(e ){
                self._stop( e );
            });
                          
		},
		
		_start: function( e ){
			
			$( document )
                	//move disableselection and cursor to default handlers of the start event
	                .disableSelection()
	                .css( 'cursor', 'move')

return this._eventHelper('start',e,{
					//'draggable': $dragDisplay
				});
                
                
		},
		_stop: function( e ){

if( this._eventHelper('stop',e,{}) == true ){
				 $( document )
			 	 .unbind( 'mousemove.' + this.widgetEventPrefix )
			 	 .enableSelection()
			 	 .css( 'cursor', 'move')
				
				this.dropCol();
				this.dragDisplay.remove()
			};  
	                    
		},
		
		_setOption: function(option, value) {
			$.Widget.prototype._setOption.apply( this, arguments );
           
		},
		
		/*
		 * get the selected index cell out of table row
		 * needs to work as fast as possible. and performance gains in this method are worth the time
		 * 	because its used to build the drag display and get the cells on col swap
		 * http://jsperf.com/binary-regex-vs-string-equality/4
		 */
		_getCells: function( elem, index ){
			//console.time('getcells');
			var ei = this.tableElemIndex,
				//TODO: clean up this format 
				tds = {
					//store where the cells came from
					'semantic':{
						'0': [],//head throws error if ei.head or ei['head']
						'1': [],//body
						'2': []//footer
					},
					//keep a ref in a flat array for easy access
					'array':[]
				},
				//cache regex, reduces looking up the chain
				tbodyRegex = this.tbodyRegex,
				theadRegex = this.theadRegex,
				//reduce looking up the chain, dont do it for the foot think thats more overhead since not many tables have a tfoot
				tdsSemanticBody = tds.semantic[ei.body],
				tdsSemanticHead = tds.semantic[ei.head];
			
			//console.log(index);
			//check does this col exsist
			if(index <= -1 || typeof elem.rows[0].cells[index] == undefined){
				return tds;
			}
			
			for(var i = 0, length = elem.rows.length; i < length; i++){
				
				var td = elem.rows[i].cells[index];
				
				//if the row has no cells dont error out;
				if( td == undefined ){
					continue;
				}
				
				var parentNodeName = td.parentNode.parentNode.nodeName;
				tds.array.push(td);
				//faster to leave out ^ and $ in the regular expression
				if( tbodyRegex.test( parentNodeName ) ){
					
					tdsSemanticBody.push( td );
					
				}else if( theadRegex.test( parentNodeName ) ){
					
					tdsSemanticHead.push( td );
				
				}else if( this.tfootRegex.test( parentNodeName ) ){
					
					tds.semantic[ei.foot].push( td );
				}
				
					 		
		 	}
		 	//console.timeEnd('getcells');
		 	return tds;
		},
		/*
		 * returns all element attrs in a string key="value" key2="value"
		 */
		_getElementAttributes: function(element){
			
        	var attrsString = '',
	        	attrs = element.attributes;
	        for(var i=0, length = attrs.length; i < length; i++) {
	            attrsString += attrs[i].nodeName + '="' + attrs[i].nodeValue+'"';
	        }
	        return attrsString;
		},

/*
     	 * faster than swap nodes
     	 * only works if a b parent are the same, works great for columns
     	 */
     	_swapCells: function(a, b) {
        	a.parentNode.insertBefore(b, a);
     	},

/*
		 * used to trigger optional events
		 */
		_eventHelper: function(eventName ,eventObj, additionalData){
			return this._trigger( 
				eventName, 
				eventObj, 
				$.extend({
					column: this.currentColumnCollection,
					order: this.order(),
					startIndex: this.startIndex,
					endIndex: this.endIndex,
					dragDisplay: this.dragDisplay,
					columnOffset: this.currentColumnCollectionOffset			
				},additionalData)
			);
		},
		/*
		 * build copy of table and attach the selected col to it, also removes the select col out of the table
		 * @returns copy of table with the selected col
		 * 
		 * populates self.dragDisplay
		 * TODO: name this something better, like select col or get dragDisplay
		 * 
		 */		
		getCol: function(index){
			//console.log('index of col '+index);
			//drag display is just simple html
			//console.profile('selectCol');
			
			//colHeader.addClass('ui-state-disabled')

var $table = this.element,
				self = this,
				eIndex = self.tableElemIndex,
				placholderClassnames = ' ' + this.options.placeholder;
				
				//BUG: IE thinks that this table is disabled, dont know how that happend
				self.dragDisplay = $('<table '+self._getElementAttributes($table[0])+'></table>')
									.addClass('dragtable-drag-col');
			
			//start and end are the same to start out with
			self.startIndex = self.endIndex = index;

var cells = self._getCells($table[0], index);
			self.currentColumnCollection = cells.array;
			//console.log(cells);
			//################################
			
			//TODO: convert to for in // its faster than each
			$.each(cells.semantic,function(k,collection){
				//dont bother processing if there is nothing here
				
				if(collection.length == 0){
					return;
				}
                
                if ( k == '0' ){
                    var target = document.createElement('thead');
						self.dragDisplay[0].appendChild(target);

}else{ 
                    var target = document.createElement('tbody');
						self.dragDisplay[0].appendChild(target);

}

for(var i = 0,length = collection.length; i < length; i++){
					
					var clone = collection[i].cloneNode(true);
					collection[i].className+=placholderClassnames;
					var tr = document.createElement('tr');
					tr.appendChild(clone);
					//console.log(tr);
					
					
					target.appendChild(tr);
					//collection[i]=;
				}
			});
    		
    		
    		this._setCurrentColumnCollectionOffset();
    		
    		
            self.dragDisplay  = $('<div class="dragtable-drag-wrapper"></div>').append(self.dragDisplay)
    		return self.dragDisplay;
		},
		
		
		_setCurrentColumnCollectionOffset: function(){
			return this.currentColumnCollectionOffset = $( this.currentColumnCollection[0] ).position();
		},
		
		/*
		 * move column left or right
		 */
		_swapCol: function( to ){
			
			//cant swap if same position
			if(to == this.startIndex){
				return false;
			}
			
			var from = this.startIndex;
			this.endIndex = to;
			//this col cant be moved past me
			var th = this.element.find('th').eq( to );
			//check on th
			if( th.hasClass( this.options.boundary ) == true ){
				return false;
			}
			//check handle element
			if( th.find( '.' + this.options.handle ).hasClass( this.options.boundary ) == true ){
				return false;
			}
			
			if( this._eventHelper('breforechange',{}) === false ){
				return false;
			};
			
			
	        if(from < to) {
	        	//console.log('move right');
	        	for(var i = from; i < to; i++) {
	        		var row2 = this._getCells(this.element[0],i+1);
	        	//	console.log(row2)
	        		for(var j = 0, length = row2.array.length; j < length; j++){
	          			this._swapCells(this.currentColumnCollection[j],row2.array[j]);
	          		}
	          	}
	        } else {
	        	//console.log('move left');
	        	for(var i = from; i > to; i--) {
	            	var row2 = this._getCells(this.element[0],i-1);
	            	for(var j = 0, length = row2.array.length; j < length; j++){
	          			this._swapCells(row2.array[j],this.currentColumnCollection[j]);
	          		}
	        	}
	        }
	        this._eventHelper('change',{});
	        
	        this.startIndex = this.endIndex;
		},
		/*
		 * called when drag start is finished
		 */
		dropCol: function(){
			//TODO: cache this when the option is set
			var regex = new RegExp("(?:^|\\s)" + this.options.placeholder + "(?!\\S)",'g');
			//remove placeholder class
			//dont use jquery.fn.removeClass for performance reasons
			for(var i = 0, length = this.currentColumnCollection.length; i < length; i++){
				var td = this.currentColumnCollection[i];
				
				td.className = td.className.replace(regex,'')
			}

},
		/*
		 * get / set the current order of the cols
		 */
		order: function(order){
			var self = this,
				elem = self.element,
				options = self.options,
				headers = elem.find('thead tr:first').children('th');
				
			
			if(order == undefined){
				//get
				var ret = [];
				headers.each(function(){
					var header = this.getAttribute(options.dataHeader);
					if(header == null){
						//the attr is missing so grab the text and use that
						header = $(this).text();
					}
					
					ret.push(header);
					
				});
				
				return ret;
				
			}else{
				//set
				//headers and order have to match up
				if(order.length != headers.length){
					//console.log('length not the same')
					return self;
				}
				for(var i = 0, length = order.length; i < length; i++){
					 
					 var start = headers.filter('['+ options.dataHeader +'='+ order[i] +']').index();
					 if(start != -1){
					 	//console.log('start index '+start+' - swap to '+i);
					 	self.startIndex = start;
					 	
						self.currentColumnCollection = self._getCells(self.element[0], start).array;

self._swapCol(i);
					 }
					 
					 
				}
				return self;
			}
		},
				
		destroy: function() {
			var self = this,
				o = self.options;
			
			this.element.undelegate( o.items, 'mousedown.' + self.widgetEventPrefix );
			
			$( document ).unbind('.' + self.widgetEventPrefix )
            
		}

});

})(jQuery);

cmd: