social_stream-base 0.5.0

data/lib/generators/social_stream/base/templates/public/javascripts/main.js

@@ -0,0 +1,28 @@
+// initialise plugins
+jQuery(function(){
+  
+   
+    jQuery('ul.sf-menu').superfish({
+        delay: 2000, // one second delay on mouseout
+        animation: {
+            height: 'show'
+        }, // fade-in and slide-down animation
+        speed: 'fast', // faster animation speed
+        autoArrows: false,
+        dropShadows: false // disable drop shadows
+    });
+    
+    
+});
+
+
+
+$(document).ready(function(){
+    $('#tabright> ul').tabs({
+        fx: {
+             height: 'toggle',
+            opacity: 'toggle'
+        }
+    });
+});
+

data/lib/generators/social_stream/base/templates/public/javascripts/menu-collapsed.js

@@ -0,0 +1,42 @@
+/* 
+   Simple JQuery Collapsing menu.
+   HTML structure to use:
+
+   <ul id="menu">
+     <li><a href="#">Sub menu heading</a>
+     <ul>
+       <li><a href="http://site.com/">Link</a></li>
+       <li><a href="http://site.com/">Link</a></li>
+       <li><a href="http://site.com/">Link</a></li>
+       ...
+       ...
+     </ul>
+     <li><a href="#">Sub menu heading</a>
+     <ul>
+       <li><a href="http://site.com/">Link</a></li>
+       <li><a href="http://site.com/">Link</a></li>
+       <li><a href="http://site.com/">Link</a></li>
+       ...
+       ...
+     </ul>
+     ...
+     ...
+   </ul>
+
+Copyright 2007 by Marco van Hylckama Vlieg
+
+web: http://www.i-marco.nl/weblog/
+email: marco@i-marco.nl
+
+Free for non-commercial use
+*/
+
+function initMenu() {
+  $('#menu ul').hide();
+  $('#menu li a').click(
+    function() {
+        $(this).next().slideToggle('normal');	
+      }
+    );
+  }
+$(document).ready(function() {initMenu();});

data/lib/generators/social_stream/base/templates/public/javascripts/menu.js

@@ -0,0 +1,25 @@
+function initMenu() {
+	$('.menu ul').hide();
+	$('.menu li a').click( function() {
+		$(this).next().slideToggle('normal');
+	}
+	);
+	//Logo menu for current subject
+  //Full Caption Sliding (Hidden to Visible)
+  $('.logo_grid.logo_full').hover( function() {
+    $(".logo_menu", this).stop().animate({top:'101px'},{queue:false,duration:160});
+  }, function() {
+    $(".logo_menu", this).stop().animate({top:'1119px'},{queue:false,duration:160});
+  });
+}
+
+function expandSubMenu(id) {
+	$('#' + id + '_menu').next().show();
+}
+
+$(document).ready(function() {
+	initMenu();
+});
+
+
+

data/lib/generators/social_stream/base/templates/public/javascripts/rails.js

@@ -0,0 +1,158 @@
+/**
+ * Unobtrusive scripting adapter for jQuery
+ *
+ * Requires jQuery 1.4.3 or later.
+ * https://github.com/rails/jquery-ujs
+ */
+
+(function($) {
+	// Make sure that every Ajax request sends the CSRF token
+	function CSRFProtection(xhr) {
+		var token = $('meta[name="csrf-token"]').attr('content');
+		if (token) xhr.setRequestHeader('X-CSRF-Token', token);
+	}
+	if ('ajaxPrefilter' in $) $.ajaxPrefilter(function(options, originalOptions, xhr){ CSRFProtection(xhr) });
+	else $(document).ajaxSend(function(e, xhr){ CSRFProtection(xhr) });
+
+	// Triggers an event on an element and returns the event result
+	function fire(obj, name, data) {
+		var event = $.Event(name);
+		obj.trigger(event, data);
+		return event.result !== false;
+	}
+
+	// Submits "remote" forms and links with ajax
+	function handleRemote(element) {
+		var method, url, data,
+			dataType = element.data('type') || ($.ajaxSettings && $.ajaxSettings.dataType);
+
+	if (fire(element, 'ajax:before')) {
+		if (element.is('form')) {
+			method = element.attr('method');
+			url = element.attr('action');
+			data = element.serializeArray();
+			// memoized value from clicked submit button
+			var button = element.data('ujs:submit-button');
+			if (button) {
+				data.push(button);
+				element.data('ujs:submit-button', null);
+			}
+		} else {
+			method = element.data('method');
+			url = element.attr('href');
+			data = null;
+		}
+			$.ajax({
+				url: url, type: method || 'GET', data: data, dataType: dataType,
+				// stopping the "ajax:beforeSend" event will cancel the ajax request
+				beforeSend: function(xhr, settings) {
+					if (settings.dataType === undefined) {
+						xhr.setRequestHeader('accept', '*/*;q=0.5, ' + settings.accepts.script);
+					}
+					return fire(element, 'ajax:beforeSend', [xhr, settings]);
+				},
+				success: function(data, status, xhr) {
+					element.trigger('ajax:success', [data, status, xhr]);
+				},
+				complete: function(xhr, status) {
+					element.trigger('ajax:complete', [xhr, status]);
+				},
+				error: function(xhr, status, error) {
+					element.trigger('ajax:error', [xhr, status, error]);
+				}
+			});
+		}
+	}
+
+	// Handles "data-method" on links such as:
+	// <a href="/users/5" data-method="delete" rel="nofollow" data-confirm="Are you sure?">Delete</a>
+	function handleMethod(link) {
+		var href = link.attr('href'),
+			method = link.data('method'),
+			csrf_token = $('meta[name=csrf-token]').attr('content'),
+			csrf_param = $('meta[name=csrf-param]').attr('content'),
+			form = $('<form method="post" action="' + href + '"></form>'),
+			metadata_input = '<input name="_method" value="' + method + '" type="hidden" />';
+
+		if (csrf_param !== undefined && csrf_token !== undefined) {
+			metadata_input += '<input name="' + csrf_param + '" value="' + csrf_token + '" type="hidden" />';
+		}
+
+		form.hide().append(metadata_input).appendTo('body');
+		form.submit();
+	}
+
+	function disableFormElements(form) {
+		form.find('input[data-disable-with]').each(function() {
+			var input = $(this);
+			input.data('ujs:enable-with', input.val())
+				.val(input.data('disable-with'))
+				.attr('disabled', 'disabled');
+		});
+	}
+
+	function enableFormElements(form) {
+		form.find('input[data-disable-with]').each(function() {
+			var input = $(this);
+			input.val(input.data('ujs:enable-with')).removeAttr('disabled');
+		});
+	}
+
+	function allowAction(element) {
+		var message = element.data('confirm');
+		return !message || (fire(element, 'confirm') && confirm(message));
+	}
+
+	function requiredValuesMissing(form) {
+		var missing = false;
+		form.find('input[name][required]').each(function() {
+			if (!$(this).val()) missing = true;
+		});
+		return missing;
+	}
+
+	$('a[data-confirm], a[data-method], a[data-remote]').live('click.rails', function(e) {
+		var link = $(this);
+		if (!allowAction(link)) return false;
+
+		if (link.data('remote') != undefined) {
+			handleRemote(link);
+			return false;
+		} else if (link.data('method')) {
+			handleMethod(link);
+			return false;
+		}
+	});
+
+	$('form').live('submit.rails', function(e) {
+		var form = $(this), remote = form.data('remote') != undefined;
+		if (!allowAction(form)) return false;
+
+		// skip other logic when required values are missing
+		if (requiredValuesMissing(form)) return !remote;
+
+		if (remote) {
+			handleRemote(form);
+			return false;
+		} else {
+			// slight timeout so that the submit button gets properly serialized
+			setTimeout(function(){ disableFormElements(form) }, 13);
+		}
+	});
+
+	$('form input[type=submit], form button[type=submit], form button:not([type])').live('click.rails', function() {
+		var button = $(this);
+		if (!allowAction(button)) return false;
+		// register the pressed submit button
+		var name = button.attr('name'), data = name ? {name:name, value:button.val()} : null;
+		button.closest('form').data('ujs:submit-button', data);
+	});
+
+	$('form').live('ajax:beforeSend.rails', function(event) {
+		if (this == event.target) disableFormElements($(this));
+	});
+
+	$('form').live('ajax:complete.rails', function(event) {
+		if (this == event.target) enableFormElements($(this));
+	});
+})( jQuery );

data/lib/generators/social_stream/base/templates/public/javascripts/superfish.js

@@ -0,0 +1,121 @@
+
+/*
+ * Superfish v1.4.8 - jQuery menu widget
+ * Copyright (c) 2008 Joel Birch
+ *
+ * Dual licensed under the MIT and GPL licenses:
+ * 	http://www.opensource.org/licenses/mit-license.php
+ * 	http://www.gnu.org/licenses/gpl.html
+ *
+ * CHANGELOG: http://users.tpg.com.au/j_birch/plugins/superfish/changelog.txt
+ */
+
+;(function($){
+	$.fn.superfish = function(op){
+
+		var sf = $.fn.superfish,
+			c = sf.c,
+			$arrow = $(['<span class="',c.arrowClass,'"> &#187;</span>'].join('')),
+			over = function(){
+				var $$ = $(this), menu = getMenu($$);
+				clearTimeout(menu.sfTimer);
+				$$.showSuperfishUl().siblings().hideSuperfishUl();
+			},
+			out = function(){
+				var $$ = $(this), menu = getMenu($$), o = sf.op;
+				clearTimeout(menu.sfTimer);
+				menu.sfTimer=setTimeout(function(){
+					o.retainPath=($.inArray($$[0],o.$path)>-1);
+					$$.hideSuperfishUl();
+					if (o.$path.length && $$.parents(['li.',o.hoverClass].join('')).length<1){over.call(o.$path);}
+				},o.delay);	
+			},
+			getMenu = function($menu){
+				var menu = $menu.parents(['ul.',c.menuClass,':first'].join(''))[0];
+				sf.op = sf.o[menu.serial];
+				return menu;
+			},
+			addArrow = function($a){ $a.addClass(c.anchorClass).append($arrow.clone()); };
+			
+		return this.each(function() {
+			var s = this.serial = sf.o.length;
+			var o = $.extend({},sf.defaults,op);
+			o.$path = $('li.'+o.pathClass,this).slice(0,o.pathLevels).each(function(){
+				$(this).addClass([o.hoverClass,c.bcClass].join(' '))
+					.filter('li:has(ul)').removeClass(o.pathClass);
+			});
+			sf.o[s] = sf.op = o;
+			
+			$('li:has(ul)',this)[($.fn.hoverIntent && !o.disableHI) ? 'hoverIntent' : 'hover'](over,out).each(function() {
+				if (o.autoArrows) addArrow( $('>a:first-child',this) );
+			})
+			.not('.'+c.bcClass)
+				.hideSuperfishUl();
+			
+			var $a = $('a',this);
+			$a.each(function(i){
+				var $li = $a.eq(i).parents('li');
+				$a.eq(i).focus(function(){over.call($li);}).blur(function(){out.call($li);});
+			});
+			o.onInit.call(this);
+			
+		}).each(function() {
+			var menuClasses = [c.menuClass];
+			if (sf.op.dropShadows  && !($.browser.msie && $.browser.version < 7)) menuClasses.push(c.shadowClass);
+			$(this).addClass(menuClasses.join(' '));
+		});
+	};
+
+	var sf = $.fn.superfish;
+	sf.o = [];
+	sf.op = {};
+	sf.IE7fix = function(){
+		var o = sf.op;
+		if ($.browser.msie && $.browser.version > 6 && o.dropShadows && o.animation.opacity!=undefined)
+			this.toggleClass(sf.c.shadowClass+'-off');
+		};
+	sf.c = {
+		bcClass     : 'sf-breadcrumb',
+		menuClass   : 'sf-js-enabled',
+		anchorClass : 'sf-with-ul',
+		arrowClass  : 'sf-sub-indicator',
+		shadowClass : 'sf-shadow'
+	};
+	sf.defaults = {
+		hoverClass	: 'sfHover',
+		pathClass	: 'overideThisToUse',
+		pathLevels	: 1,
+		delay		: 800,
+		animation	: {opacity:'show'},
+		speed		: 'normal',
+		autoArrows	: true,
+		dropShadows : true,
+		disableHI	: false,		// true disables hoverIntent detection
+		onInit		: function(){}, // callback functions
+		onBeforeShow: function(){},
+		onShow		: function(){},
+		onHide		: function(){}
+	};
+	$.fn.extend({
+		hideSuperfishUl : function(){
+			var o = sf.op,
+				not = (o.retainPath===true) ? o.$path : '';
+			o.retainPath = false;
+			var $ul = $(['li.',o.hoverClass].join(''),this).add(this).not(not).removeClass(o.hoverClass)
+					.find('>ul').hide().css('visibility','hidden');
+			o.onHide.call($ul);
+			return this;
+		},
+		showSuperfishUl : function(){
+			var o = sf.op,
+				sh = sf.c.shadowClass+'-off',
+				$ul = this.addClass(o.hoverClass)
+					.find('>ul:hidden').css('visibility','visible');
+			sf.IE7fix.call($ul);
+			o.onBeforeShow.call($ul);
+			$ul.animate(o.animation,o.speed,function(){ sf.IE7fix.call($ul); o.onShow.call($ul); });
+			return this;
+		}
+	});
+
+})(jQuery);

data/lib/generators/social_stream/base/templates/public/javascripts/ui.checkbox.js

@@ -0,0 +1,309 @@
+/**
+ * @author alexander.farkas
+ * @version 1.4.1
+ */
+$(document).ready(function() {
+
+	var baseClasses = /ui-checkbox|ui-radio/;
+    $.widget('ui.checkBox', {
+		options: {
+	        hideInput: true,
+			addVisualElement: true,
+			addLabel: true,
+			_delegated: false
+	    },
+        _create: function(){
+            var that = this, 
+				opts = this.options
+			;
+			
+			if(!this.element.is(':radio,:checkbox')){
+				if($.nodeName(this.element[0], 'input')){return false;}
+				this._addDelegate();
+				this.updateContainer();
+				return false;
+			}
+            this.labels = $([]);
+			
+            this.checkedStatus = false;
+			this.disabledStatus = false;
+			this.hoverStatus = false;
+            
+            this.radio = (this.element.is(':radio'));
+					
+            this.visualElement = $([]);
+            if (opts.hideInput) {
+				this.element
+					.addClass('ui-helper-hidden-accessible')
+				;
+				if(opts.addVisualElement){
+					this.visualElement = $('<span />')
+						.addClass(this.radio ? 'ui-radio' : 'ui-checkbox')
+					;
+					this.element.after(this.visualElement[0]);
+				}
+            }
+			
+			if(opts.addLabel){
+				this.labels = $('label[for=' + this.element.attr('id') + ']')
+					.addClass(this.radio ? 'ui-radio' : 'ui-checkbox')
+				;
+			}
+			if(!opts._delegated){
+				this._addEvents();
+			}
+			this.initialized = true;
+            this.reflectUI({type: 'initialReflect'});
+			return undefined;
+        },
+		updateContainer: function(){
+			if(!this.element.is(':radio,:checkbox') && !$.nodeName(this.element[0], 'input')){
+				$('input', this.element[0])
+					.filter(function(){
+						return !($.data(this, 'checkBox'));
+					})
+					.checkBox($.extend({}, this.options, {_delegated: true}))
+				;
+			}
+		},
+		_addDelegate: function(){
+			var opts 		= this.options,
+					
+				toggleHover = function(e, that){
+					if(!that){return;}
+					that.hover = !!(e.type == 'focus' || e.type == 'mouseenter' || e.type == 'focusin' || e.type == 'mouseover');
+					that._changeStateClassChain.call(that);
+					return undefined;
+				}
+			;
+			
+			
+			this.element
+				.bind('click', function(e){
+					if(!$.nodeName(e.target, 'input')){return;}
+					var inst = ($.data(e.target) || {}).checkBox;
+					if(!inst){return;}
+					inst.reflectUI.call(inst, e.target, e);
+				})
+				.bind('focusin.checkBox focusout.checkBox', function(e){
+					if(!$.nodeName(e.target, 'input')){return;}
+					var inst = ($.data(e.target) || {}).checkBox;
+					toggleHover(e, inst);
+				})
+			;
+			
+			if (opts.hideInput){
+				this.element
+					.bind('usermode', function(e){
+						if(!e.enabled){return;}
+						$('input', this).each(function(){
+		                    var inst = ($.data(this) || {}).checkBox;
+							(inst && inst.destroy.call(inst, true));
+						});
+	                })
+				;
+            }
+			
+			if(opts.addVisualElement){
+				this.element
+					.bind('mouseover.checkBox mouseout.checkBox', function(e){
+						if(!$.nodeName(e.target, 'span')){return;}
+						var inst = ( $.data($(e.target).prev()[0]) || {} ).checkBox;
+						toggleHover(e, inst);
+					})
+					.bind('click.checkBox', function(e){
+						if(!$.nodeName(e.target, 'span') || !baseClasses.test( e.target.className || '' )){return;}
+						$(e.target).prev()[0].click();
+						return false;
+					})
+				;
+			}
+			if(opts.addLabel){
+				this.element
+					.delegate('label.ui-radio, label.ui-checkbox', 'mouseenter.checkBox mouseleave.checkBox', function(e){
+						var inst = ( $.data(document.getElementById( $(this).attr('for') )) || {} ).checkBox;
+						toggleHover( e, inst );
+					});
+			}
+			
+		},
+		_addEvents: function(){
+			var that 		= this, 
+			
+				opts 		= this.options,
+					
+				toggleHover = function(e){
+					if(that.disabledStatus){
+						return false;
+					}
+					that.hover = (e.type == 'focus' || e.type == 'mouseenter');
+					that._changeStateClassChain();
+					return undefined;
+				}
+			;
+			
+			this.element
+				.bind('click.checkBox', $.proxy(this, 'reflectUI'))
+				.bind('focus.checkBox blur.checkBox', toggleHover)
+			;
+			if (opts.hideInput){
+				this.element
+					.bind('usermode', function(e){
+	                    (e.enabled &&
+	                        that.destroy.call(that, true));
+	                })
+				;
+            }
+			if(opts.addVisualElement){
+					this.visualElement
+						.bind('mouseenter.checkBox mouseleave.checkBox', toggleHover)
+						.bind('click.checkBox', function(e){
+							that.element[0].click();
+							return false;
+						})
+					;
+				}
+			if(opts.addLabel){
+				this.labels.bind('mouseenter.checkBox mouseleave.checkBox', toggleHover);
+			}
+		},
+		_changeStateClassChain: function(){
+			var allElements = this.labels.add(this.visualElement),
+				stateClass 	= '',
+				baseClass 	= 'ui-'+((this.radio) ? 'radio' : 'checkbox')
+			;
+				
+			if(this.checkedStatus){
+				stateClass += '-checked'; 
+				allElements.addClass(baseClass+'-checked');
+			} else {
+				allElements.removeClass(baseClass+'-checked');
+			}
+			
+			if(this.disabledStatus){
+				stateClass += '-disabled'; 
+				allElements.addClass(baseClass+'-disabled');
+			} else {
+				allElements.removeClass(baseClass+'-disabled');
+			}
+			if(this.hover){
+				stateClass += '-hover'; 
+				allElements.addClass(baseClass+'-hover');
+			} else {
+				allElements.removeClass(baseClass+'-hover');
+			}
+			
+			baseClass += '-state';
+			if(stateClass){
+				stateClass = baseClass + stateClass;
+			}
+			
+			function switchStateClass(){
+				var classes = this.className.split(' '),
+					found = false;
+				$.each(classes, function(i, classN){
+					if(classN.indexOf(baseClass) === 0){
+						found = true;
+						classes[i] = stateClass;
+						return false;
+					}
+					return undefined;
+				});
+				if(!found){
+					classes.push(stateClass);
+				}
+				this.className = classes.join(' ');
+			}
+			
+			this.labels.each(switchStateClass);
+			this.visualElement.each(switchStateClass);
+		},
+        destroy: function(onlyCss){
+            this.element.removeClass('ui-helper-hidden-accessible');
+						if(this.visualElement){
+							this.visualElement.addClass('ui-helper-hidden');
+						}
+            if (!onlyCss) {
+                var o = this.options;
+                this.element.unbind('.checkBox');
+								if(this.visualElement){
+                  this.visualElement.remove();
+                }
+								if(this.labels){
+									this.labels.unbind('.checkBox').removeClass('ui-state-hover ui-state-checked ui-state-disabled');
+								}
+            }
+        },
+		
+        disable: function(){
+            this.element[0].disabled = true;
+            this.reflectUI({type: 'manuallyDisabled'});
+        },
+		
+        enable: function(){
+            this.element[0].disabled = false;
+            this.reflectUI({type: 'manuallyenabled'});
+        },
+		
+        toggle: function(e){
+            this.changeCheckStatus((this.element.is(':checked')) ? false : true, e);
+        },
+		
+        changeCheckStatus: function(status, e){
+            if(e && e.type == 'click' && this.element[0].disabled){
+				return false;
+			}
+			this.element.attr({'checked': status});
+            this.reflectUI(e || {
+                type: 'changeCheckStatus'
+            });
+			return undefined;
+        },
+		
+        propagate: function(n, e, _noGroupReflect){
+			if(!e || e.type != 'initialReflect'){
+				if (this.radio && !_noGroupReflect) {
+					//dynamic
+	                $(document.getElementsByName(this.element.attr('name')))
+						.checkBox('reflectUI', e, true);
+	            }
+	            return this._trigger(n, e, {
+	                options: this.options,
+	                checked: this.checkedStatus,
+	                labels: this.labels,
+					disabled: this.disabledStatus
+	            });
+			}
+			return undefined;
+        },
+		
+      reflectUI: function(e){
+      
+				var oldChecked 		= this.checkedStatus, 
+				oldDisabledStatus 	= this.disabledStatus;
+	            					
+				this.disabledStatus = this.element.is(':disabled');
+				this.checkedStatus = this.element.is(':checked');
+				
+				if (this.disabledStatus != oldDisabledStatus || this.checkedStatus !== oldChecked) {
+	
+					//Change status callback
+	
+					if (this.checkedStatus==true){
+						var id = this.element[0].id;
+						checkBoxEnable(id);
+					} else if (this.checkedStatus==false){
+						var id = this.element[0].id;
+						checkBoxDisable(id);
+					}
+	
+					this._changeStateClassChain();
+					
+					(this.disabledStatus != oldDisabledStatus && this.propagate('disabledChange', e));
+					
+					(this.checkedStatus !== oldChecked && this.propagate('change', e));
+				}
+            
+      }
+    });
+});