locomotive-aloha-rails 0.20.1

data/vendor/assets/javascripts/aloha/plugins/extra/formatlesspaste/lib/formatlesspaste-plugin.js

@@ -0,0 +1,103 @@
+/*!
+* Aloha Editor
+* Author & Copyright (c) 2010 Gentics Software GmbH
+* aloha-sales@gentics.com
+* Licensed unter the terms of http://www.aloha-editor.com/license.html
+*/
+
+define(
+['aloha/core', 'aloha/plugin', 'aloha/jquery', 'aloha/floatingmenu', 
+ 'formatlesspaste/formatlesshandler', 'aloha/contenthandlermanager',
+ 'i18n!formatlesspaste/nls/i18n', 'i18n!aloha/nls/i18n','css!formatlesspaste/css/formatless.css'],
+function(Aloha, Plugin, jQuery, FloatingMenu, FormatlessPasteHandler, ContentHandlerManager, i18n, i18nCore) {
+	
+
+	
+
+	// Public Methods
+	return Plugin.create('formatlesspaste', {
+		
+		
+		/**
+		 * Configure Formatless pasting
+		 */
+		formatlessPasteOption: false, 
+		
+		//Here we removes the text-level semantic and edit elements (http://dev.w3.org/html5/spec/text-level-semantics.html#usage-summary)
+		strippedElements : [
+			"a",
+			"em",
+			"strong",
+			"small",
+			"s",
+			"cite",
+			"q",
+			"dfn",
+			"abbr",
+			"time",
+			"code",
+			"var",
+			"samp",
+			"kbd",
+			"sub",
+			"sup",
+			"i",
+			"b",
+			"u",
+			"mark",
+			"ruby",
+			"rt",
+			"rp",
+			"bdi",
+			"bdo",
+			"ins",
+			"del" 
+		],
+
+		/**
+		 * Initialize the PastePlugin
+		 */
+		init: function() {
+			var that = this;
+
+			if ( typeof this.settings.formatlessPasteOption !== 'undefined') {
+				this.formatlessPasteOption = this.settings.formatlessPasteOption;
+			}
+			
+			if ( typeof this.settings.strippedElements !== 'undefined') {
+				this.strippedElements = this.settings.strippedElements;
+			}
+
+			if ( this.formatlessPasteOption ) {
+				this.registerFormatlessPasteHandler(); 
+			};
+
+		},
+
+		/**
+		 * Register Formatless paste handler
+		 */
+		registerFormatlessPasteHandler: function(){
+		
+			ContentHandlerManager.register( 'formatless', FormatlessPasteHandler );
+			FormatlessPasteHandler.strippedElements = this.strippedElements;
+			// add button to toggle format-less pasting
+			this.formatlessPasteButton = new Aloha.ui.Button({
+					'iconClass' : 'aloha-button aloha-button-formatless-paste',
+					'size' : 'small',
+					'onclick' : function () { 
+						//toggle the value of allowFormatless
+						FormatlessPasteHandler.enabled = !FormatlessPasteHandler.enabled;
+					},
+					'tooltip' : i18n.t( 'button.formatlessPaste.tooltip' ),
+					'toggle' : true
+				});
+			FloatingMenu.addButton(
+				'Aloha.continuoustext',
+				this.formatlessPasteButton,
+				i18nCore.t( 'floatingmenu.tab.format' ),
+				1
+			);
+		},
+	});
+});

data/vendor/assets/javascripts/aloha/plugins/extra/formatlesspaste/nls/de/i18n.js

@@ -0,0 +1 @@
+define({"button.formatlessPaste.tooltip":"Einf\u00fcgen ohne Formatierung ein/ausschalten."});

data/vendor/assets/javascripts/aloha/plugins/extra/formatlesspaste/nls/i18n.js

@@ -0,0 +1,7 @@
+define({
+	root: {"button.formatlessPaste.tooltip":"Toggle Formatless Pasting"}
+,	"de":true,
+	"fr":true,
+	"pl":true,
+	"ru":true
+});

data/vendor/assets/javascripts/aloha/plugins/extra/formatlesspaste/package.json

@@ -0,0 +1,8 @@
+{
+	"js": [
+		"src/paste.js",
+		"src/wordpastehandler.js",
+		"src/oembedpastehandler.js",
+		"src/genericpastehandler.js"
+	]
+}

data/vendor/assets/javascripts/aloha/plugins/extra/headerids/css/headerids.css

@@ -0,0 +1,8 @@
+/*!
+* Aloha Editor
+* Author & Copyright (c) 2010 Gentics Software GmbH
+* aloha-sales@gentics.com
+* Licensed unter the terms of http://www.aloha-editor.com/license.html
+*/
+.aloha-headerids-label { margin: 5px; display:block; }
+.aloha-headerids-input { margin-right: 5px; }

data/vendor/assets/javascripts/aloha/plugins/extra/headerids/lib/headerids-plugin.js

@@ -0,0 +1,127 @@
+/*!
+* Aloha Editor
+* Author & Copyright (c) 2010 Gentics Software GmbH
+* aloha-sales@gentics.com
+* Licensed unter the terms of http://www.aloha-editor.com/license.html
+*/
+define(
+['aloha/jquery','aloha/plugin', 'aloha/floatingmenu', 'i18n!headerids/nls/i18n', 'i18n!aloha/nls/i18n', 'css!headerids/css/headerids.css'],
+function(jQuery, Plugin, FloatingMenu, i18n, i18nCore) {
+	
+
+	var
+		$ = jQuery,
+		GENTICS = window.GENTICS,
+		Aloha = window.Aloha;
+	
+	
+	
+	// namespace prefix for this plugin
+    var ns = 'aloha-headerids';
+    
+    
+    // ------------------------------------------------------------------------
+    // Local (helper) functions
+    // ------------------------------------------------------------------------
+    
+    // Creates a selector string with this component's namepsace prefixed the each classname
+    function nsSel () {
+        var strBldr = [], prx = ns;
+        $.each(arguments, function () { strBldr.push('.' + (this == '' ? prx : prx + '-' + this)); });
+        return strBldr.join(' ').trim();
+    };
+    
+    // Creates string with this component's namepsace prefixed the each classname
+    function nsClass () {
+        var strBldr = [], prx = ns;
+        $.each(arguments, function () { strBldr.push(this == '' ? prx : prx + '-' + this); });
+        return strBldr.join(' ').trim();
+    };
+    
+    
+    
+
+	
+	
+     return Plugin.create('headerids', {
+		_constructor: function(){
+			this._super('headerids');
+		},
+		
+		config: ['true'],
+				
+		/**
+		 * Initialize the plugin
+		 */
+		init: function () {
+			var that = this;
+	
+			// mark active Editable with a css class
+			Aloha.bind("aloha-editable-activated", function(jEvent, params) { that.check(params.editable.obj); });
+			Aloha.bind("aloha-editable-deactivated", function(jEvent, params) { that.check(params.editable.obj); });
+			Aloha.bind('aloha-ready', function (ev) { that.initSidebar(Aloha.Sidebar.right); });
+		},
+		
+		check: function(editable) {
+			var that = this;
+			var config = that.getEditableConfig(editable);
+			if(jQuery.inArray('true',config) == -1) {
+				// Return if the plugin should do nothing in this editable
+				return;
+			}		
+			jQuery(editable).find('h1, h2, h3, h4, h5, h6').not('.aloha-customized').each(function(){ 
+				that.processH(this); 
+			});
+		},
+		
+		processH: function(h) {
+			var that = this;
+			jQuery(h).attr('id',that.sanitize(jQuery(h).text()));
+		},
+				
+		sanitize: function(str) {
+			return (str.replace(/[^a-z0-9]+/gi,'_'));
+		},
+		
+		
+		//ns = headerids
+		initSidebar: function(sidebar) {
+			var pl = this;
+			pl.sidebar = sidebar;
+			sidebar.addPanel({
+                    
+                    id         : nsClass('sidebar-panel'),
+                    title     : 'Sprungmarken',
+                    content     : '',
+                    expanded : true,
+                    activeOn : 'h1, h2, h3, h4, h5, h6',
+                    
+                    onInit     : function () {
+                        var that = this,
+                            content = this.setContent('<label class="'+nsClass('label')+'" for="'+nsClass('input')+'">'+i18n.t('headerids.label.target')+'</label><input id="'+nsClass('input')+'" class="'+nsClass('input')+'" type="text" name="value"/> <button class="'+nsClass('reset-button')+'">'+i18n.t('headerids.button.reset')+'</button><button class="'+nsClass('set-button')+'">'+i18n.t('headerids.button.set')+'</button>').content;
+                        
+                        content.find(nsSel('set-button')).click(function () {
+                            var content = that.content;
+							jQuery(that.effective).attr('id',jQuery(nsSel('input')).val());
+							jQuery(that.effective).addClass('aloha-customized');
+                        });
+						
+						content.find(nsSel('reset-button')).click(function () {
+                            var content = that.content;
+                            pl.processH(that.effective);
+							jQuery(that.effective).removeClass('aloha-customized');
+							that.content.find(nsSel('input')).val(that.effective.attr('id'));
+                        });
+                    },
+                    
+                    onActivate: function (effective) {
+						var that = this;
+						that.effective = effective;
+						that.content.find(nsSel('input')).val(effective.attr('id'));
+                    }
+                    
+                });
+			sidebar.show();
+		}
+	});
+});

data/vendor/assets/javascripts/aloha/plugins/extra/headerids/nls/de/i18n.js

@@ -0,0 +1 @@
+define({ "headerids.label.target": "Sprungziel", "headerids.button.reset":"Zurücksetzen","headerids.button.set":"Zuweisen" });

data/vendor/assets/javascripts/aloha/plugins/extra/headerids/nls/en/i18n.js

@@ -0,0 +1 @@
+define({ "headerids.label.target": "Target", "headerids.button.reset":"Reset","headerids.button.set":"Set" });

data/vendor/assets/javascripts/aloha/plugins/extra/headerids/nls/i18n.js

@@ -0,0 +1,5 @@
+define({
+	root: { "headerids.label.target": "Target", "headerids.button.reset":"Reset","headerids.button.set":"Set" },
+	"de":true,
+	"en":true
+});

data/vendor/assets/javascripts/aloha/plugins/extra/hints/dep/jquery.poshytip.js

@@ -0,0 +1,470 @@
+/*
+ * Poshy Tip jQuery plugin v1.1
+ * http://vadikom.com/tools/poshy-tip-jquery-plugin-for-stylish-tooltips/
+ * Copyright 2010-2011, Vasil Dinkov, http://vadikom.com/
+ */
+
+(function($) {
+
+	var tips = [],
+		reBgImage = /^url\(["']?([^"'\)]*)["']?\);?$/i,
+		rePNG = /\.png$/i,
+		ie6 = $.browser.msie && $.browser.version == 6;
+
+	// make sure the tips' position is updated on resize
+	function handleWindowResize() {
+		$.each(tips, function() {
+			this.refresh(true);
+		});
+	}
+	$(window).resize(handleWindowResize);
+
+	$.Poshytip = function(elm, options) {
+		this.$elm = $(elm);
+		this.opts = $.extend({}, $.fn.poshytip.defaults, options);
+		this.$tip = $(['<div class="',this.opts.className,'">',
+				'<div class="tip-inner tip-bg-image"></div>',
+				'<div class="tip-arrow tip-arrow-top tip-arrow-right tip-arrow-bottom tip-arrow-left"></div>',
+			'</div>'].join('')).appendTo(document.body);
+		this.$arrow = this.$tip.find('div.tip-arrow');
+		this.$inner = this.$tip.find('div.tip-inner');
+		this.disabled = false;
+		this.content = null;
+		this.init();
+	};
+
+	$.Poshytip.prototype = {
+		init: function() {
+			tips.push(this);
+
+			// save the original title and a reference to the Poshytip object
+			var title = this.$elm.attr('title');
+			this.$elm.data('title.poshytip', title !== undefined ? title : null)
+				.data('poshytip', this);
+
+			// hook element events
+			if (this.opts.showOn != 'none') {
+				this.$elm.bind({
+					'mouseenter.poshytip': $.proxy(this.mouseenter, this),
+					'mouseleave.poshytip': $.proxy(this.mouseleave, this)
+				});
+				switch (this.opts.showOn) {
+					case 'hover':
+						if (this.opts.alignTo == 'cursor')
+							this.$elm.bind('mousemove.poshytip', $.proxy(this.mousemove, this));
+						if (this.opts.allowTipHover)
+							this.$tip.hover($.proxy(this.clearTimeouts, this), $.proxy(this.mouseleave, this));
+						break;
+					case 'focus':
+						this.$elm.bind({
+							'focus.poshytip': $.proxy(this.show, this),
+							'blur.poshytip': $.proxy(this.hide, this)
+						});
+						break;
+				}
+			}
+		},
+		mouseenter: function(e) {
+			if (this.disabled)
+				return true;
+
+			this.$elm.attr('title', '');
+			if (this.opts.showOn == 'focus')
+				return true;
+
+			this.clearTimeouts();
+			this.showTimeout = setTimeout($.proxy(this.show, this), this.opts.showTimeout);
+		},
+		mouseleave: function(e) {
+			if (this.disabled || this.asyncAnimating && (this.$tip[0] === e.relatedTarget || jQuery.contains(this.$tip[0], e.relatedTarget)))
+				return true;
+
+			var title = this.$elm.data('title.poshytip');
+			if (title !== null)
+				this.$elm.attr('title', title);
+			if (this.opts.showOn == 'focus')
+				return true;
+
+			this.clearTimeouts();
+			this.hideTimeout = setTimeout($.proxy(this.hide, this), this.opts.hideTimeout);
+		},
+		mousemove: function(e) {
+			if (this.disabled)
+				return true;
+
+			this.eventX = e.pageX;
+			this.eventY = e.pageY;
+			if (this.opts.followCursor && this.$tip.data('active')) {
+				this.calcPos();
+				this.$tip.css({left: this.pos.l, top: this.pos.t});
+				if (this.pos.arrow)
+					this.$arrow[0].className = 'tip-arrow tip-arrow-' + this.pos.arrow;
+			}
+		},
+		show: function() {
+			if (this.disabled || this.$tip.data('active'))
+				return;
+
+			this.reset();
+			this.update();
+			this.display();
+			if (this.opts.timeOnScreen)
+				setTimeout($.proxy(this.hide, this), this.opts.timeOnScreen);
+		},
+		hide: function() {
+			if (this.disabled || !this.$tip.data('active'))
+				return;
+
+			this.display(true);
+		},
+		reset: function() {
+			this.$tip.queue([]).detach().css('visibility', 'hidden').data('active', false);
+			this.$inner.find('*').poshytip('hide');
+			if (this.opts.fade)
+				this.$tip.css('opacity', this.opacity);
+			this.$arrow[0].className = 'tip-arrow tip-arrow-top tip-arrow-right tip-arrow-bottom tip-arrow-left';
+			this.asyncAnimating = false;
+		},
+		update: function(content, dontOverwriteOption) {
+			if (this.disabled)
+				return;
+
+			var async = content !== undefined;
+			if (async) {
+				if (!dontOverwriteOption)
+					this.opts.content = content;
+				if (!this.$tip.data('active'))
+					return;
+			} else {
+				content = this.opts.content;
+			}
+
+			// update content only if it has been changed since last time
+			var self = this,
+				newContent = typeof content == 'function' ?
+					content.call(this.$elm[0], function(newContent) {
+						self.update(newContent);
+					}) :
+					content == '[title]' ? this.$elm.data('title.poshytip') : content;
+			if (this.content !== newContent) {
+				this.$inner.empty().append(newContent);
+				this.content = newContent;
+			}
+
+			this.refresh(async);
+		},
+		refresh: function(async) {
+			if (this.disabled)
+				return;
+
+			if (async) {
+				if (!this.$tip.data('active'))
+					return;
+				// save current position as we will need to animate
+				var currPos = {left: this.$tip.css('left'), top: this.$tip.css('top')};
+			}
+
+			// reset position to avoid text wrapping, etc.
+			this.$tip.css({left: 0, top: 0}).appendTo(document.body);
+
+			// save default opacity
+			if (this.opacity === undefined)
+				this.opacity = this.$tip.css('opacity');
+
+			// check for images - this code is here (i.e. executed each time we show the tip and not on init) due to some browser inconsistencies
+			var bgImage = this.$tip.css('background-image').match(reBgImage),
+				arrow = this.$arrow.css('background-image').match(reBgImage);
+
+			if (bgImage) {
+				var bgImagePNG = rePNG.test(bgImage[1]);
+				// fallback to background-color/padding/border in IE6 if a PNG is used
+				if (ie6 && bgImagePNG) {
+					this.$tip.css('background-image', 'none');
+					this.$inner.css({margin: 0, border: 0, padding: 0});
+					bgImage = bgImagePNG = false;
+				} else {
+					this.$tip.prepend('<table border="0" cellpadding="0" cellspacing="0"><tr><td class="tip-top tip-bg-image" colspan="2"><span></span></td><td class="tip-right tip-bg-image" rowspan="2"><span></span></td></tr><tr><td class="tip-left tip-bg-image" rowspan="2"><span></span></td><td></td></tr><tr><td class="tip-bottom tip-bg-image" colspan="2"><span></span></td></tr></table>')
+						.css({border: 0, padding: 0, 'background-image': 'none', 'background-color': 'transparent'})
+						.find('.tip-bg-image').css('background-image', 'url("' + bgImage[1] +'")').end()
+						.find('td').eq(3).append(this.$inner);
+				}
+				// disable fade effect in IE due to Alpha filter + translucent PNG issue
+				if (bgImagePNG && !$.support.opacity)
+					this.opts.fade = false;
+			}
+			// IE arrow fixes
+			if (arrow && !$.support.opacity) {
+				// disable arrow in IE6 if using a PNG
+				if (ie6 && rePNG.test(arrow[1])) {
+					arrow = false;
+					this.$arrow.css('background-image', 'none');
+				}
+				// disable fade effect in IE due to Alpha filter + translucent PNG issue
+				this.opts.fade = false;
+			}
+
+			var $table = this.$tip.find('table');
+			if (ie6) {
+				// fix min/max-width in IE6
+				this.$tip[0].style.width = '';
+				$table.width('auto').find('td').eq(3).width('auto');
+				var tipW = this.$tip.width(),
+					minW = parseInt(this.$tip.css('min-width')),
+					maxW = parseInt(this.$tip.css('max-width'));
+				if (!isNaN(minW) && tipW < minW)
+					tipW = minW;
+				else if (!isNaN(maxW) && tipW > maxW)
+					tipW = maxW;
+				this.$tip.add($table).width(tipW).eq(0).find('td').eq(3).width('100%');
+			} else if ($table[0]) {
+				// fix the table width if we are using a background image
+				// IE9, FF4 use float numbers for width/height so use getComputedStyle for them to avoid text wrapping
+				// for details look at: http://vadikom.com/dailies/offsetwidth-offsetheight-useless-in-ie9-firefox4/
+				$table.width('auto').find('td').eq(3).width('auto').end().end().width(document.defaultView && document.defaultView.getComputedStyle && parseFloat(document.defaultView.getComputedStyle(this.$tip[0], null).width) || this.$tip.width()).find('td').eq(3).width('100%');
+			}
+			this.tipOuterW = this.$tip.outerWidth();
+			this.tipOuterH = this.$tip.outerHeight();
+
+			this.calcPos();
+
+			// position and show the arrow image
+			if (arrow && this.pos.arrow) {
+				this.$arrow[0].className = 'tip-arrow tip-arrow-' + this.pos.arrow;
+				this.$arrow.css('visibility', 'inherit');
+			}
+
+			if (async) {
+				this.asyncAnimating = true;
+				var self = this;
+				this.$tip.css(currPos).animate({left: this.pos.l, top: this.pos.t}, 200, function() { self.asyncAnimating = false; });
+			} else {
+				this.$tip.css({left: this.pos.l, top: this.pos.t});
+			}
+		},
+		display: function(hide) {
+			var active = this.$tip.data('active');
+			if (active && !hide || !active && hide)
+				return;
+
+			this.$tip.stop();
+			if ((this.opts.slide && this.pos.arrow || this.opts.fade) && (hide && this.opts.hideAniDuration || !hide && this.opts.showAniDuration)) {
+				var from = {}, to = {};
+				// this.pos.arrow is only undefined when alignX == alignY == 'center' and we don't need to slide in that rare case
+				if (this.opts.slide && this.pos.arrow) {
+					var prop, arr;
+					if (this.pos.arrow == 'bottom' || this.pos.arrow == 'top') {
+						prop = 'top';
+						arr = 'bottom';
+					} else {
+						prop = 'left';
+						arr = 'right';
+					}
+					var val = parseInt(this.$tip.css(prop));
+					from[prop] = val + (hide ? 0 : (this.pos.arrow == arr ? -this.opts.slideOffset : this.opts.slideOffset));
+					to[prop] = val + (hide ? (this.pos.arrow == arr ? this.opts.slideOffset : -this.opts.slideOffset) : 0) + 'px';
+				}
+				if (this.opts.fade) {
+					from.opacity = hide ? this.$tip.css('opacity') : 0;
+					to.opacity = hide ? 0 : this.opacity;
+				}
+				this.$tip.css(from).animate(to, this.opts[hide ? 'hideAniDuration' : 'showAniDuration']);
+			}
+			hide ? this.$tip.queue($.proxy(this.reset, this)) : this.$tip.css('visibility', 'inherit');
+			this.$tip.data('active', !active);
+		},
+		disable: function() {
+			this.reset();
+			this.disabled = true;
+		},
+		enable: function() {
+			this.disabled = false;
+		},
+		destroy: function() {
+			this.reset();
+			this.$tip.remove();
+			delete this.$tip;
+			this.content = null;
+			this.$elm.unbind('.poshytip').removeData('title.poshytip').removeData('poshytip');
+			tips.splice($.inArray(this, tips), 1);
+		},
+		clearTimeouts: function() {
+			if (this.showTimeout) {
+				clearTimeout(this.showTimeout);
+				this.showTimeout = 0;
+			}
+			if (this.hideTimeout) {
+				clearTimeout(this.hideTimeout);
+				this.hideTimeout = 0;
+			}
+		},
+		calcPos: function() {
+			var pos = {l: 0, t: 0, arrow: ''},
+				$win = $(window),
+				win = {
+					l: $win.scrollLeft(),
+					t: $win.scrollTop(),
+					w: $win.width(),
+					h: $win.height()
+				}, xL, xC, xR, yT, yC, yB;
+			if (this.opts.alignTo == 'cursor') {
+				xL = xC = xR = this.eventX;
+				yT = yC = yB = this.eventY;
+			} else { // this.opts.alignTo == 'target'
+				var elmOffset = this.$elm.offset(),
+					elm = {
+						l: elmOffset.left,
+						t: elmOffset.top,
+						w: this.$elm.outerWidth(),
+						h: this.$elm.outerHeight()
+					};
+				xL = elm.l + (this.opts.alignX != 'inner-right' ? 0 : elm.w);	// left edge
+				xC = xL + Math.floor(elm.w / 2);				// h center
+				xR = xL + (this.opts.alignX != 'inner-left' ? elm.w : 0);	// right edge
+				yT = elm.t + (this.opts.alignY != 'inner-bottom' ? 0 : elm.h);	// top edge
+				yC = yT + Math.floor(elm.h / 2);				// v center
+				yB = yT + (this.opts.alignY != 'inner-top' ? elm.h : 0);	// bottom edge
+			}
+
+			// keep in viewport and calc arrow position
+			switch (this.opts.alignX) {
+				case 'right':
+				case 'inner-left':
+					pos.l = xR + this.opts.offsetX;
+					if (pos.l + this.tipOuterW > win.l + win.w)
+						pos.l = win.l + win.w - this.tipOuterW;
+					if (this.opts.alignX == 'right' || this.opts.alignY == 'center')
+						pos.arrow = 'left';
+					break;
+				case 'center':
+					pos.l = xC - Math.floor(this.tipOuterW / 2);
+					if (pos.l + this.tipOuterW > win.l + win.w)
+						pos.l = win.l + win.w - this.tipOuterW;
+					else if (pos.l < win.l)
+						pos.l = win.l;
+					break;
+				default: // 'left' || 'inner-right'
+					pos.l = xL - this.tipOuterW - this.opts.offsetX;
+					if (pos.l < win.l)
+						pos.l = win.l;
+					if (this.opts.alignX == 'left' || this.opts.alignY == 'center')
+						pos.arrow = 'right';
+			}
+			switch (this.opts.alignY) {
+				case 'bottom':
+				case 'inner-top':
+					pos.t = yB + this.opts.offsetY;
+					// 'left' and 'right' need priority for 'target'
+					if (!pos.arrow || this.opts.alignTo == 'cursor')
+						pos.arrow = 'top';
+					if (pos.t + this.tipOuterH > win.t + win.h) {
+						pos.t = yT - this.tipOuterH - this.opts.offsetY;
+						if (pos.arrow == 'top')
+							pos.arrow = 'bottom';
+					}
+					break;
+				case 'center':
+					pos.t = yC - Math.floor(this.tipOuterH / 2);
+					if (pos.t + this.tipOuterH > win.t + win.h)
+						pos.t = win.t + win.h - this.tipOuterH;
+					else if (pos.t < win.t)
+						pos.t = win.t;
+					break;
+				default: // 'top' || 'inner-bottom'
+					pos.t = yT - this.tipOuterH - this.opts.offsetY;
+					// 'left' and 'right' need priority for 'target'
+					if (!pos.arrow || this.opts.alignTo == 'cursor')
+						pos.arrow = 'bottom';
+					if (pos.t < win.t) {
+						pos.t = yB + this.opts.offsetY;
+						if (pos.arrow == 'bottom')
+							pos.arrow = 'top';
+					}
+			}
+			this.pos = pos;
+		}
+	};
+
+	$.fn.poshytip = function(options) {
+		if (typeof options == 'string') {
+			var args = arguments,
+				method = options;
+			Array.prototype.shift.call(args);
+			// unhook live events if 'destroy' is called
+			if (method == 'destroy')
+				this.die('mouseenter.poshytip').die('focus.poshytip');
+			return this.each(function() {
+				var poshytip = $(this).data('poshytip');
+				if (poshytip && poshytip[method])
+					poshytip[method].apply(poshytip, args);
+			});
+		}
+
+		var opts = $.extend({}, $.fn.poshytip.defaults, options);
+
+		// generate CSS for this tip class if not already generated
+		if (!$('#poshytip-css-' + opts.className)[0])
+			$(['<style id="poshytip-css-',opts.className,'" type="text/css">',
+				'div.',opts.className,'{visibility:hidden;position:absolute;top:0;left:0;}',
+				'div.',opts.className,' table, div.',opts.className,' td{margin:0;font-family:inherit;font-size:inherit;font-weight:inherit;font-style:inherit;font-variant:inherit;}',
+				'div.',opts.className,' td.tip-bg-image span{display:block;font:1px/1px sans-serif;height:',opts.bgImageFrameSize,'px;width:',opts.bgImageFrameSize,'px;overflow:hidden;}',
+				'div.',opts.className,' td.tip-right{background-position:100% 0;}',
+				'div.',opts.className,' td.tip-bottom{background-position:100% 100%;}',
+				'div.',opts.className,' td.tip-left{background-position:0 100%;}',
+				'div.',opts.className,' div.tip-inner{background-position:-',opts.bgImageFrameSize,'px -',opts.bgImageFrameSize,'px;}',
+				'div.',opts.className,' div.tip-arrow{visibility:hidden;position:absolute;overflow:hidden;font:1px/1px sans-serif;}',
+			'</style>'].join('')).appendTo('head');
+
+		// check if we need to hook live events
+		if (opts.liveEvents && opts.showOn != 'none') {
+			var deadOpts = $.extend({}, opts, { liveEvents: false });
+			switch (opts.showOn) {
+				case 'hover':
+					this.live('mouseenter.poshytip', function() {
+						var $this = $(this);
+						if (!$this.data('poshytip'))
+							$this.poshytip(deadOpts).poshytip('mouseenter');
+					});
+					break;
+				case 'focus':
+					this.live('focus.poshytip', function() {
+						var $this = $(this);
+						if (!$this.data('poshytip'))
+							$this.poshytip(deadOpts).poshytip('show');
+					});
+					break;
+			}
+			return this;
+		}
+
+		return this.each(function() {
+			new $.Poshytip(this, opts);
+		});
+	}
+
+	// default settings
+	$.fn.poshytip.defaults = {
+		content: 		'[title]',	// content to display ('[title]', 'string', element, function(updateCallback){...}, jQuery)
+		className:		'tip-yellow',	// class for the tips
+		bgImageFrameSize:	10,		// size in pixels for the background-image (if set in CSS) frame around the inner content of the tip
+		showTimeout:		500,		// timeout before showing the tip (in milliseconds 1000 == 1 second)
+		hideTimeout:		100,		// timeout before hiding the tip
+		timeOnScreen:		0,		// timeout before automatically hiding the tip after showing it (set to > 0 in order to activate)
+		showOn:			'hover',	// handler for showing the tip ('hover', 'focus', 'none') - use 'none' to trigger it manually
+		liveEvents:		false,		// use live events
+		alignTo:		'cursor',	// align/position the tip relative to ('cursor', 'target')
+		alignX:			'right',	// horizontal alignment for the tip relative to the mouse cursor or the target element
+							// ('right', 'center', 'left', 'inner-left', 'inner-right') - 'inner-*' matter if alignTo:'target'
+		alignY:			'top',		// vertical alignment for the tip relative to the mouse cursor or the target element
+							// ('bottom', 'center', 'top', 'inner-bottom', 'inner-top') - 'inner-*' matter if alignTo:'target'
+		offsetX:		-22,		// offset X pixels from the default position - doesn't matter if alignX:'center'
+		offsetY:		18,		// offset Y pixels from the default position - doesn't matter if alignY:'center'
+		allowTipHover:		true,		// allow hovering the tip without hiding it onmouseout of the target - matters only if showOn:'hover'
+		followCursor:		false,		// if the tip should follow the cursor - matters only if showOn:'hover' and alignTo:'cursor'
+		fade: 			true,		// use fade animation
+		slide: 			true,		// use slide animation
+		slideOffset: 		8,		// slide animation offset
+		showAniDuration: 	300,		// show animation duration - set to 0 if you don't want show animation
+		hideAniDuration: 	300		// hide animation duration - set to 0 if you don't want hide animation
+	};
+
+})(jQuery);