skylinecms 3.0.7

data/public/skyline/javascripts/src/skyline/src/uploader.js

@@ -0,0 +1,115 @@
+//= require <Swiff.Uploader>
+/*
+  Class: Skyline.Uploader
+  An extended version of Swiff.Uploader. It has some extra event's and
+  default behaviour.
+  
+  Events:
+  
+  updateStatus    - Some status needs to be updated (removal of file or selection)
+  completeSuccess - Triggered if all files were successfully uploaded.
+  completeFailure - Triggered if some files did not complete successfully (stopped not included)
+*/
+Skyline.Uploader = new Class({
+	Extends: Swiff.Uploader,
+	options: {
+		queued: true,
+		verbose: false
+	},
+	initialize : function(options){
+    if(!options){options = {};}
+    if(!options.fileClass){ options.fileClass = Skyline.Uploader.File; }
+		
+    this.addEvents({
+      "complete" : this._onComplete,
+      "fileStop" : this._onFileStop,
+      "fileRemove" : this._updateStatus,      
+      "queue" : this._updateStatus,
+      "load" : this._onLoad,
+      "fail" : this._onFail
+    });
+    		
+		this.parent(options);
+	},
+	
+	_updateStatus: function(){
+	  this.fireEvent("updateStatus");
+  },
+	
+  // Events
+  _onFileStop : function(){
+    this.fileList.each(function(file){
+      if(file.status == Swiff.Uploader.STATUS_QUEUED || file.status == Swiff.Uploader.STATUS_RUNNING){
+        file.stop();
+      }
+    });
+  },
+  _onComplete : function(){
+    var invalids = this.fileList.filter(function(el){
+      return el.status != 3;
+    });
+    //  All files have successfully been uploaded
+    if(invalids.length === 0){
+      this.fireEvent("completeSuccess");
+    } else {
+      this.fireEvent("completeFailure");
+    }
+  },
+  
+  // Triggered when the Flash loaded fine.
+  _onLoad : function(){
+    // Relay interactions from overlayed flash to browse button
+    this.target.addEvents({
+      click: function(){ return false; },
+      mousedown: function(){ this.focus(); }
+    });
+  },
+    
+  // An error occured with the flash file.
+  _onFail : function(error){
+		switch (error) {
+			case 'hidden': // works after enabling the movie and clicking refresh
+				alert('To enable the embedded uploader, unblock it in your browser and refresh (see Adblock).');
+				break;
+			case 'blocked': // This no *full* fail, it works after the user clicks the button
+				alert('To enable the embedded uploader, enable the blocked Flash movie (see Flashblock).');
+				break;
+			case 'empty': // Oh oh, wrong path
+				alert('A required file was not found, please be patient and we fix this.');
+				break;
+			case 'flash': // no flash 9+ :(
+				alert('To enable the embedded uploader, install the latest Adobe Flash plugin.');
+		}
+  }
+	  
+});
+
+Skyline.Uploader.File = new Class({
+  Extends: Swiff.Uploader.File,
+  initialize : function(){
+    this.addEvents({
+      "complete" : this._onComplete    
+    });
+    this.parent.apply(this,arguments);
+  },
+  _onComplete: function(){
+    if(this.status === Swiff.Uploader.STATUS_ERROR){
+      this.fireEvent("failure");
+    } else if(this.status === Swiff.Uploader.STATUS_COMPLETE){
+      var status = JSON.decode(this.response.text, true);
+      if(status && status["status"]){
+        this.response.json = status;        
+        this.response.code = status["status"];      
+        if(status["status"] == 200){
+          this.fireEvent("success");
+        } else {
+          this.fireEvent("failure");
+        }
+      } else {
+        // We don't know and assume the status 200 mean's it's ok
+        this.fireEvent("success");
+      }
+    }
+
+  }
+});

data/public/skyline/javascripts/src/skyline/src/utils.js

@@ -0,0 +1,31 @@
+Skyline.Utils = {
+  /*
+    Function: getJsLocation(filename)
+    Find the url, filename and parent url of "filename"
+    
+    Returns:
+    A Hash with the following keys:
+    filename - The filename you passed in
+    url - The full SRC/url of the filename
+    base - The parent url of filename
+  */
+  getJsLocation : function(filename){
+    var sElements = document.getElementsByTagName("SCRIPT");
+    var r = {};
+  	for (var i=0; i<sElements.length; i++) {
+  		src = sElements[i].src;
+  		if (src && src.indexOf(filename) != -1) {
+
+  			r.filename = filename;
+  			r.base = src.substring(0, src.lastIndexOf('/'));
+        r.url = src;
+
+  			if ((p = src.indexOf('?')) != -1){
+  				r.query = src.substring(p + 1);
+  			}
+  			return r;
+  		}
+  	}
+
+  }
+};

data/public/skyline/javascripts/src/skyline/vendor/fancyupload/FancyUpload2.js

@@ -0,0 +1,251 @@
+/**
+ * FancyUpload - Flash meets Ajax for powerful and elegant uploads.
+ * 
+ * Updated to latest 3.0 API. Hopefully 100% compat!
+ *
+ * @version		3.0
+ *
+ * @license		MIT License
+ *
+ * @author		Harald Kirschner <http://digitarald.de>
+ * @copyright	Authors
+ */
+
+var FancyUpload2 = new Class({
+
+	Extends: Swiff.Uploader,
+	
+	options: {
+		queued: 1,
+		// compat
+		limitSize: 0,
+		limitFiles: 0,
+		validateFile: $lambda(true)
+	},
+
+	initialize: function(status, list, options) {
+		this.status = $(status);
+		this.list = $(list);
+
+		// compat
+		options.fileClass = options.fileClass || FancyUpload2.File;
+		options.fileSizeMax = options.limitSize || options.fileSizeMax;
+		options.fileListMax = options.limitFiles || options.fileListMax;
+
+		this.parent(options);
+
+		this.addEvents({
+			'load': this.render,
+			'select': this.onSelect,
+			'cancel': this.onCancel,
+			'start': this.onStart,
+			'queue': this.onQueue,
+			'complete': this.onComplete
+		});
+	},
+
+	render: function() {
+		this.overallTitle = this.status.getElement('.overall-title');
+		this.currentTitle = this.status.getElement('.current-title');
+		this.currentText = this.status.getElement('.current-text');
+
+		var progress = this.status.getElement('.overall-progress');
+		this.overallProgress = new Fx.ProgressBar(progress, {
+			text: new Element('span', {'class': 'progress-text'}).inject(progress, 'after')
+		});
+		progress = this.status.getElement('.current-progress')
+		this.currentProgress = new Fx.ProgressBar(progress, {
+			text: new Element('span', {'class': 'progress-text'}).inject(progress, 'after')
+		});
+				
+		this.updateOverall();
+	},
+
+	onSelect: function() {
+		this.status.removeClass('status-browsing');
+	},
+
+	onCancel: function() {
+		this.status.removeClass('file-browsing');
+	},
+
+	onStart: function() {
+		this.status.addClass('file-uploading');
+		this.overallProgress.set(0);
+	},
+
+	onQueue: function() {
+		this.updateOverall();
+	},
+
+	onComplete: function() {
+		this.status.removeClass('file-uploading');
+		if (this.size) {
+			this.overallProgress.start(100);
+		} else {
+			this.overallProgress.set(0);
+			this.currentProgress.set(0);
+		}
+		
+	},
+
+	updateOverall: function() {
+		this.overallTitle.set('html', MooTools.lang.get('FancyUpload', 'progressOverall').substitute({
+			total: Swiff.Uploader.formatUnit(this.size, 'b')
+		}));
+		if (!this.size) {
+			this.currentTitle.set('html', MooTools.lang.get('FancyUpload', 'currentTitle'));
+			this.currentText.set('html', '');
+		}
+	},
+	
+	/**
+	 * compat
+	 */
+	upload: function() {
+		this.start();
+	},
+	
+	removeFile: function() {
+		return this.remove();
+	}
+
+});
+
+FancyUpload2.File = new Class({
+	
+	Extends: Swiff.Uploader.File,
+
+	render: function() {
+		if (this.invalid) {
+			if (this.validationError) {
+				var msg = MooTools.lang.get('FancyUpload', 'validationErrors')[this.validationError] || this.validationError;
+				this.validationErrorMessage = msg.substitute({
+					name: this.name,
+					size: Swiff.Uploader.formatUnit(this.size, 'b'),
+					fileSizeMin: Swiff.Uploader.formatUnit(this.base.options.fileSizeMin || 0, 'b'),
+					fileSizeMax: Swiff.Uploader.formatUnit(this.base.options.fileSizeMax || 0, 'b'),
+					fileListMax: this.base.options.fileListMax || 0,
+					fileListSizeMax: Swiff.Uploader.formatUnit(this.base.options.fileListSizeMax || 0, 'b')
+				});
+			}
+			this.remove();
+			return;
+		}
+		
+		this.addEvents({
+			'start': this.onStart,
+			'progress': this.onProgress,
+			'complete': this.onComplete,
+			'error': this.onError,
+			'remove': this.onRemove
+		});
+		
+		this.info = new Element('span', {'class': 'file-info'});
+		this.element = new Element('li', {'class': 'file'}).adopt(
+			new Element('span', {'class': 'file-size', 'html': Swiff.Uploader.formatUnit(this.size, 'b')}),
+			new Element('a', {
+				'class': 'file-remove',
+				href: '#',
+				html: MooTools.lang.get('FancyUpload', 'remove'),
+				title: MooTools.lang.get('FancyUpload', 'removeTitle'),
+				events: {
+					click: function() {
+						this.remove();
+						return false;
+					}.bind(this)
+				}
+			}),
+			new Element('span', {'class': 'file-name', 'html': MooTools.lang.get('FancyUpload', 'fileName').substitute(this)}),
+			this.info
+		).inject(this.base.list);
+	},
+	
+	validate: function() {
+		return (this.parent() && this.base.options.validateFile(this));
+	},
+	
+	onStart: function() {
+		this.element.addClass('file-uploading');
+		this.base.currentProgress.cancel().set(0);
+		this.base.currentTitle.set('html', MooTools.lang.get('FancyUpload', 'currentFile').substitute(this));
+	},
+
+	onProgress: function() {
+		this.base.overallProgress.start(this.base.percentLoaded);
+		this.base.currentText.set('html', MooTools.lang.get('FancyUpload', 'currentProgress').substitute({
+			rate: (this.progress.rate) ? Swiff.Uploader.formatUnit(this.progress.rate, 'bps') : '- B',
+			bytesLoaded: Swiff.Uploader.formatUnit(this.progress.bytesLoaded, 'b'),
+			timeRemaining: (this.progress.timeRemaining) ? Swiff.Uploader.formatUnit(this.progress.timeRemaining, 's') : '-'
+		}));
+		this.base.currentProgress.start(this.progress.percentLoaded);
+	},
+	
+	onComplete: function() {
+		this.element.removeClass('file-uploading');
+		
+		this.base.currentText.set('html', 'Upload completed');
+		this.base.currentProgress.start(100);
+		
+		if (this.response.error) {
+			var msg = MooTools.lang.get('FancyUpload', 'errors')[this.response.error] || '{error} #{code}';
+			this.errorMessage = msg.substitute($extend({
+				name: this.name,
+				size: Swiff.Uploader.formatUnit(this.size, 'b')
+			}, this.response));
+			var args = [this, this.errorMessage, this.response];
+			
+			this.fireEvent('error', args).base.fireEvent('fileError', args);
+		} else {
+			this.base.fireEvent('fileSuccess', [this, this.response.text || '']);
+		}
+	},
+
+	onError: function() {
+		this.element.addClass('file-failed');
+		var error = MooTools.lang.get('FancyUpload', 'fileError').substitute(this);
+		this.info.set('html', '<strong>' + error + ':</strong> ' + this.errorMessage);
+	},
+
+	onRemove: function() {
+		this.element.getElements('a').setStyle('visibility', 'hidden');
+		this.element.fade('out').retrieve('tween').chain(Element.destroy.bind(Element, this.element));
+	}
+	
+});
+
+// Avoiding MooTools.lang dependency
+(function() {
+	var phrases = {
+		'progressOverall': 'Overall Progress ({total})',
+		'currentTitle': 'File Progress',
+		'currentFile': 'Uploading "{name}"',
+		'currentProgress': 'Upload: {bytesLoaded} with {rate}, {timeRemaining} remaining.',
+		'fileName': '{name}',
+		'remove': 'Remove',
+		'removeTitle': 'Click to remove this entry.',
+		'fileError': 'Upload failed',
+		'validationErrors': {
+			'duplicate': 'File <em>{name}</em> is already added, duplicates are not allowed.',
+			'sizeLimitMin': 'File <em>{name}</em> (<em>{size}</em>) is too small, the minimal file size is {fileSizeMin}.',
+			'sizeLimitMax': 'File <em>{name}</em> (<em>{size}</em>) is too big, the maximal file size is <em>{fileSizeMax}</em>.',
+			'fileListMax': 'File <em>{name}</em> could not be added, amount of <em>{fileListMax} files</em> exceeded.',
+			'fileListSizeMax': 'File <em>{name}</em> (<em>{size}</em>) is too big, overall filesize of <em>{fileListSizeMax}</em> exceeded.'
+		},
+		'errors': {
+			'httpStatus': 'Server returned HTTP-Status <code>#{code}</code>',
+			'securityError': 'Security error occured ({text})',
+			'ioError': 'Error caused a send or load operation to fail ({text})'
+		}
+	};
+	
+	if (MooTools.lang) {
+		MooTools.lang.set('en-US', 'FancyUpload', phrases);
+	} else {
+		MooTools.lang = {
+			get: function(from, key) {
+				return phrases[key];
+			}
+		};
+	}
+})();

data/public/skyline/javascripts/src/skyline/vendor/fancyupload/FancyUpload3.Attach.js

@@ -0,0 +1,222 @@
+/**
+ * FancyUpload.Attach - Flash meets Ajax for powerful and elegant uploads.
+ *
+ * @version		3.0 rc3
+ *
+ * @license		MIT License
+ *
+ * @author		Harald Kirschner <mail [at] digitarald [dot] de>
+ * @copyright	Authors
+ */
+
+if (!window.FancyUpload3) var FancyUpload3 = {};
+
+FancyUpload3.Attach = new Class({
+
+	Extends: Swiff.Uploader,
+	
+	options: {
+		queued: false,
+		instantStart: true
+	},
+
+	initialize: function(list, selects, options) {
+		this.list = $(list);
+		this.selects = $(selects) ? $$($(selects)) : $$(selects);
+				
+		options.target = this.selects[0];
+		options.fileClass = options.fileClass || FancyUpload3.Attach.File;
+		
+		this.parent(options);
+
+		/**
+		 * Button state
+		 */
+		var self = this;
+		
+		this.selects.addEvents({
+			click: function() {
+				return false;
+			},
+			mouseenter: function() {
+				this.addClass('hover');
+				self.reposition();
+			},
+			mouseleave: function() {
+				this.removeClass('hover');
+				this.blur();
+			},
+			mousedown: function() {
+				this.focus();
+			}
+		});
+		
+		if (this.selects.length == 2) {
+			this.selects[1].setStyle('display', 'none');
+			this.addEvents({
+				'selectSuccess': this.onSelectSuccess,
+				'fileRemove': this.onFileRemove
+			});
+		}
+	},
+	
+	onSelectSuccess: function() {
+		if (this.fileList.length > 0) {
+			this.selects[0].setStyle('display', 'none');
+			this.selects[1].setStyle('display', 'inline');
+			this.target = this.selects[1];
+			this.reposition();
+		}
+	},
+	
+	onFileRemove: function() {
+		if (this.fileList.length == 0) {
+			this.selects[0].setStyle('display', 'inline');
+			this.selects[1].setStyle('display', 'none');
+			this.target = this.selects[0];
+			this.reposition();
+		}
+	},
+	
+	start: function() {
+		if (Browser.Platform.linux && window.confirm(MooTools.lang.get('FancyUpload', 'linuxWarning'))) return this;
+		return this.parent();
+	}
+	
+});
+
+FancyUpload3.Attach.File = new Class({
+
+	Extends: Swiff.Uploader.File,
+
+	render: function() {
+		
+		if (this.invalid) {
+			if (this.validationError) {
+				var msg = MooTools.lang.get('FancyUpload', 'validationErrors')[this.validationError] || this.validationError;
+				this.validationErrorMessage = msg.substitute({
+					name: this.name,
+					size: Swiff.Uploader.formatUnit(this.size, 'b'),
+					fileSizeMin: Swiff.Uploader.formatUnit(this.base.options.fileSizeMin || 0, 'b'),
+					fileSizeMax: Swiff.Uploader.formatUnit(this.base.options.fileSizeMax || 0, 'b'),
+					fileListMax: this.base.options.fileListMax || 0,
+					fileListSizeMax: Swiff.Uploader.formatUnit(this.base.options.fileListSizeMax || 0, 'b')
+				});
+			}
+			this.remove();
+			return;
+		}
+		
+		this.addEvents({
+			'open': this.onOpen,
+			'remove': this.onRemove,
+			'requeue': this.onRequeue,
+			'progress': this.onProgress,
+			'stop': this.onStop,
+			'complete': this.onComplete,
+			'error': this.onError
+		});
+		
+		this.ui = {};
+		
+		this.ui.element = new Element('li', {'class': 'file', id: 'file-' + this.id});
+		this.ui.title = new Element('span', {'class': 'file-title', text: this.name});
+		this.ui.size = new Element('span', {'class': 'file-size', text: Swiff.Uploader.formatUnit(this.size, 'b')});
+		
+		this.ui.cancel = new Element('a', {'class': 'file-cancel', text: 'Cancel', href: '#'});
+		this.ui.cancel.addEvent('click', function() {
+			this.remove();
+			return false;
+		}.bind(this));
+		
+		this.ui.element.adopt(
+			this.ui.title,
+			this.ui.size,
+			this.ui.cancel
+		).inject(this.base.list).highlight();
+		
+		var progress = new Element('img', {'class': 'file-progress', src: '../../assets/progress-bar/bar.gif'}).inject(this.ui.size, 'after');
+		this.ui.progress = new Fx.ProgressBar(progress, {
+			fit: true
+		}).set(0);
+					
+		this.base.reposition();
+
+		return this.parent();
+	},
+
+	onOpen: function() {
+		this.ui.element.addClass('file-uploading');
+		if (this.ui.progress) this.ui.progress.set(0);
+	},
+
+	onRemove: function() {
+		this.ui = this.ui.element.destroy();
+	},
+
+	onProgress: function() {
+		if (this.ui.progress) this.ui.progress.start(this.progress.percentLoaded);
+	},
+
+	onStop: function() {
+		this.remove();
+	},
+	
+	onComplete: function() {
+		this.ui.element.removeClass('file-uploading');
+
+		if (this.response.error) {
+			var msg = MooTools.lang.get('FancyUpload', 'errors')[this.response.error] || '{error} #{code}';
+			this.errorMessage = msg.substitute($extend({name: this.name}, this.response));
+			
+			this.base.fireEvent('fileError', [this, this.response, this.errorMessage]);
+			this.fireEvent('error', [this, this.response, this.errorMessage]);
+			return;
+		}
+		
+		if (this.ui.progress) this.ui.progress = this.ui.progress.cancel().element.destroy();
+		this.ui.cancel = this.ui.cancel.destroy();
+		
+		var response = this.response.text || '';
+		this.base.fireEvent('fileSuccess', [this, response]);
+	},
+
+	onError: function() {
+		this.ui.element.addClass('file-failed');		
+	}
+
+});
+
+//Avoiding MooTools.lang dependency
+(function() {
+	
+	var phrases = {
+		'fileName': '{name}',
+		'cancel': 'Cancel',
+		'cancelTitle': 'Click to cancel and remove this entry.',
+		'validationErrors': {
+			'duplicate': 'File <em>{name}</em> is already added, duplicates are not allowed.',
+			'sizeLimitMin': 'File <em>{name}</em> (<em>{size}</em>) is too small, the minimal file size is {fileSizeMin}.',
+			'sizeLimitMax': 'File <em>{name}</em> (<em>{size}</em>) is too big, the maximal file size is <em>{fileSizeMax}</em>.',
+			'fileListMax': 'File <em>{name}</em> could not be added, amount of <em>{fileListMax} files</em> exceeded.',
+			'fileListSizeMax': 'File <em>{name}</em> (<em>{size}</em>) is too big, overall filesize of <em>{fileListSizeMax}</em> exceeded.'
+		},
+		'errors': {
+			'httpStatus': 'Server returned HTTP-Status #{code}',
+			'securityError': 'Security error occured ({text})',
+			'ioError': 'Error caused a send or load operation to fail ({text})'
+		},
+		'linuxWarning': 'Warning: Due to a misbehaviour of Adobe Flash Player on Linux,\nthe browser will probably freeze during the upload process.\nDo you want to start the upload anyway?'
+	};
+	
+	if (MooTools.lang) {
+		MooTools.lang.set('en-US', 'FancyUpload', phrases);
+	} else {
+		MooTools.lang = {
+			get: function(from, key) {
+				return phrases[key];
+			}
+		};
+	}
+	
+})();