prime-rails 0.0.3

data/app/assets/javascripts/js/terminal/terminal.js

@@ -0,0 +1,91 @@
+/**
+ * PrimeUI Terminal widget
+ */
+$(function() {
+
+    $.widget("primeui.puiterminal", {
+       
+        options: {
+            welcomeMessage: '',
+            prompt:'prime $',
+            handler: null
+        },
+        
+        _create: function() {
+            this.element.addClass('pui-terminal ui-widget ui-widget-content ui-corner-all')
+                        .append('<div>' + this.options.welcomeMessage + '</div>')
+                        .append('<div class="pui-terminal-content"></div>')
+                        .append('<div><span class="pui-terminal-prompt">' + this.options.prompt + '</span>' +
+                                 '<input type="text" class="pui-terminal-input" autocomplete="off"></div>' );
+                         
+            this.promptContainer = this.element.find('> div:last-child > span.pui-terminal-prompt');
+            this.content = this.element.children('.pui-terminal-content');
+            this.input = this.promptContainer.next();
+            this.commands = [];
+            this.commandIndex = 0;
+            
+            this._bindEvents();
+        },
+                
+        _bindEvents: function() {
+            var $this = this;
+
+            this.input.on('keydown.terminal', function(e) {
+                var keyCode = $.ui.keyCode;
+
+                switch(e.which) {
+                    case keyCode.UP:
+                        if($this.commandIndex > 0) {
+                            $this.input.val($this.commands[--$this.commandIndex]);
+                        }
+
+                        e.preventDefault();
+                    break;
+
+                    case keyCode.DOWN:
+                        if($this.commandIndex < ($this.commands.length - 1)) {
+                            $this.input.val($this.commands[++$this.commandIndex]);
+                        }
+                        else {
+                            $this.commandIndex = $this.commands.length;
+                            $this.input.val('');
+                        }
+
+                        e.preventDefault();
+                    break;
+
+                    case keyCode.ENTER:
+                    case keyCode.NUMPAD_ENTER:
+                        $this._processCommand();
+
+                        e.preventDefault();
+                    break;
+                }
+            });        
+        },
+                
+        _processCommand: function() {
+            var command = this.input.val();
+            this.commands.push();
+            this.commandIndex++;
+
+            if(this.options.handler && $.type(this.options.handler) === 'function') {
+                this.options.handler.call(this, command, this._updateContent); 
+            }
+        },
+
+        _updateContent: function(content) {
+            var commandResponseContainer = $('<div></div>');
+            commandResponseContainer.append('<span>' + this.options.prompt + '</span><span class="pui-terminal-command">' +  this.input.val() + '</span>')
+                                    .append('<div>' + content + '</div>').appendTo(this.content);
+
+            this.input.val('');
+            this.element.scrollTop(this.content.height());
+        },
+
+        clear: function() {
+            this.content.html('');
+            this.input.val('');
+        }                       
+    });
+});

data/app/assets/javascripts/js/tooltip/tooltip.js

@@ -0,0 +1,124 @@
+/**
+ * PrimeFaces Tooltip Widget
+ */
+$(function() {
+
+    $.widget("primeui.puitooltip", {
+       
+        options: {
+            showEvent: 'mouseover',
+            hideEvent: 'mouseout',
+            showEffect: 'fade',
+            hideEffect: null,
+            showEffectSpeed: 'normal',
+            hideEffectSpeed: 'normal',
+            my: 'left top',
+            at: 'right bottom',
+            showDelay: 150
+        },
+        
+        _create: function() {
+            this.options.showEvent = this.options.showEvent + '.puitooltip';
+            this.options.hideEvent = this.options.hideEvent + '.puitooltip';
+            
+            if(this.element.get(0) === document) {
+                this._bindGlobal();
+            }
+            else {
+                this._bindTarget();
+            }
+        },
+        
+        _bindGlobal: function() {
+            this.container = $('<div class="pui-tooltip pui-tooltip-global ui-widget ui-widget-content ui-corner-all pui-shadow" />').appendTo(document.body);
+            this.globalSelector = 'a,:input,:button,img';
+            var $this = this;
+
+            $(document).off(this.options.showEvent + ' ' + this.options.hideEvent, this.globalSelector)
+                        .on(this.options.showEvent, this.globalSelector, null, function() {
+                            var target = $(this),
+                            title = target.attr('title');
+
+                            if(title) {
+                                $this.container.text(title);
+                                $this.globalTitle = title;
+                                $this.target = target;
+                                target.attr('title', '');
+                                $this.show();
+                            }
+                        })
+                        .on(this.options.hideEvent, this.globalSelector, null, function() {
+                            var target = $(this);
+
+                            if($this.globalTitle) {
+                                $this.container.hide();
+                                target.attr('title', $this.globalTitle);
+                                $this.globalTitle = null;
+                                $this.target = null;
+                            }
+                        });
+
+            var resizeNS = 'resize.puitooltip';
+            $(window).unbind(resizeNS).bind(resizeNS, function() {
+                if($this.container.is(':visible')) {
+                    $this._align();
+                }
+            });
+        },
+        
+        _bindTarget: function() {
+            this.container = $('<div class="pui-tooltip ui-widget ui-widget-content ui-corner-all pui-shadow" />').appendTo(document.body);
+
+            var $this = this;
+            this.element.off(this.options.showEvent + ' ' + this.options.hideEvent)
+                        .on(this.options.showEvent, function() {
+                            $this.show();
+                        })
+                        .on(this.options.hideEvent, function() {
+                            $this.hide();
+                        });
+
+            this.container.html(this.options.content);
+
+            this.element.removeAttr('title');
+            this.target = this.element;
+
+            var resizeNS = 'resize.' + this.element.attr('id');
+            $(window).unbind(resizeNS).bind(resizeNS, function() {
+                if($this.container.is(':visible')) {
+                    $this._align();
+                }
+            });
+        },
+        
+        _align: function() {
+            this.container.css({
+                left:'', 
+                top:'',
+                'z-index': ++PUI.zindex
+            })
+            .position({
+                my: this.options.my,
+                at: this.options.at,
+                of: this.target
+            });
+        },
+
+        show: function() {
+            var $this = this;
+
+            this.timeout = setTimeout(function() {
+                $this._align();
+                $this.container.show($this.options.showEffect, {}, $this.options.showEffectSpeed);
+            }, this.options.showDelay);
+        },
+
+        hide: function() {
+            clearTimeout(this.timeout);
+
+            this.container.hide(this.options.hideEffect, {}, this.options.hideEffectSpeed, function() {
+                $(this).css('z-index', '');
+            });
+        }
+    });
+});

data/app/assets/javascripts/plugins/cursorposition.js

@@ -0,0 +1,138 @@
+/**
+ * jQuery plugin for getting position of cursor in textarea
+ *
+ * @author Bevis Zhao (i@bevis.me, http://bevis.me)
+ */
+$(function() {
+
+	var calculator = {
+		// key styles
+		primaryStyles: ['fontFamily', 'fontSize', 'fontWeight', 'fontVariant', 'fontStyle',
+			'paddingLeft', 'paddingTop', 'paddingBottom', 'paddingRight',
+			'marginLeft', 'marginTop', 'marginBottom', 'marginRight',
+			'borderLeftColor', 'borderTopColor', 'borderBottomColor', 'borderRightColor',  
+			'borderLeftStyle', 'borderTopStyle', 'borderBottomStyle', 'borderRightStyle', 
+			'borderLeftWidth', 'borderTopWidth', 'borderBottomWidth', 'borderRightWidth',
+			'line-height', 'outline'],
+
+		specificStyle: {
+			'word-wrap': 'break-word',
+			'overflow-x': 'hidden',
+			'overflow-y': 'auto'
+		},
+		
+		simulator : $('<div id="textarea_simulator"/>').css({
+				position: 'absolute',
+				top: 0,
+				left: 0,
+				visibility: 'hidden'
+			}).appendTo(document.body),
+
+		toHtml : function(text) {
+			return text.replace(/\n/g, '<br>')
+				.split(' ').join('<span style="white-space:prev-wrap">&nbsp;</span>');
+		},
+		// calculate position 
+		getCaretPosition: function() {
+			var cal = calculator, self = this, element = self[0], elementOffset = self.offset();
+
+			// IE has easy way to get caret offset position
+			if ($.browser.msie) {
+				// must get focus first
+				element.focus();
+			    var range = document.selection.createRange();  
+			    $('#hskeywords').val(element.scrollTop);
+			    return {  
+			        left: range.boundingLeft - elementOffset.left,
+			        top: parseInt(range.boundingTop) - elementOffset.top + element.scrollTop 
+						+ document.documentElement.scrollTop + parseInt(self.getComputedStyle("fontSize")) 
+			    };  
+			}  
+			cal.simulator.empty();
+			// clone primary styles to imitate textarea
+			$.each(cal.primaryStyles, function(index, styleName) {
+				self.cloneStyle(cal.simulator, styleName);
+			});
+
+			// caculate width and height
+			cal.simulator.css($.extend({
+				'width': self.width(),
+				'height': self.height()
+			}, cal.specificStyle));
+
+			var value = self.val(), cursorPosition = self.getCursorPosition();
+			var beforeText = value.substring(0, cursorPosition),
+				afterText = value.substring(cursorPosition);
+
+			var before = $('<span class="before"/>').html(cal.toHtml(beforeText)),
+				focus = $('<span class="focus"/>'),
+				after = $('<span class="after"/>').html(cal.toHtml(afterText));
+
+			cal.simulator.append(before).append(focus).append(after);
+			var focusOffset = focus.offset(), simulatorOffset = cal.simulator.offset();
+			// alert(focusOffset.left  + ',' +  simulatorOffset.left + ',' + element.scrollLeft);
+			return { 
+				top: focusOffset.top - simulatorOffset.top - element.scrollTop 
+					// calculate and add the font height except Firefox
+					+ ($.browser.mozilla ? 0 : parseInt(self.getComputedStyle("fontSize"))), 
+				left: focus[0].offsetLeft -  cal.simulator[0].offsetLeft - element.scrollLeft
+			};
+		}
+	};
+
+	$.fn.extend({
+		getComputedStyle: function(styleName) {
+			if (this.length == 0) return;
+			var thiz = this[0];
+			var result = this.css(styleName);
+			result = result || ($.browser.msie ?
+				thiz.currentStyle[styleName]:
+				document.defaultView.getComputedStyle(thiz, null)[styleName]);
+			return result;			
+		},
+		// easy clone method 
+		cloneStyle: function(target, styleName) {
+			var styleVal = this.getComputedStyle(styleName);
+			if (!!styleVal) {
+				$(target).css(styleName, styleVal);
+			}
+		},
+		cloneAllStyle: function(target, style) {
+			var thiz = this[0];
+			for (var styleName in thiz.style) {
+				var val = thiz.style[styleName];
+				typeof val == 'string' || typeof val == 'number' 
+					? this.cloneStyle(target, styleName)
+					: NaN;
+			}
+		},
+		getCursorPosition : function() {
+	        var thiz = this[0], result = 0;
+	        if ('selectionStart' in thiz) {
+	            result = thiz.selectionStart;
+	        } else if('selection' in document) {
+	        	var range = document.selection.createRange();
+	        	if (parseInt($.browser.version) > 6) {
+		            thiz.focus();
+		            var length = document.selection.createRange().text.length;
+		            range.moveStart('character', - thiz.value.length);
+		            result = range.text.length - length;
+	        	} else {
+	                var bodyRange = document.body.createTextRange();
+	                bodyRange.moveToElementText(thiz);
+	                for (; bodyRange.compareEndPoints("StartToStart", range) < 0; result++)
+	                	bodyRange.moveStart('character', 1);
+	                for (var i = 0; i <= result; i ++){
+	                    if (thiz.value.charAt(i) == '\n')
+	                        result++;
+	                }
+	                var enterCount = thiz.value.split('\n').length - 1;
+					result -= enterCount;
+                    return result;
+	        	}
+	        }
+	        return result;
+	    },
+		getCaretPosition: calculator.getCaretPosition
+	});
+});

data/app/assets/javascripts/plugins/rangyinput.js

@@ -0,0 +1,239 @@
+/**
+ * @license Rangy Text Inputs, a cross-browser textarea and text input library plug-in for jQuery.
+ *
+ * Part of Rangy, a cross-browser JavaScript range and selection library
+ * http://code.google.com/p/rangy/
+ *
+ * Depends on jQuery 1.0 or later.
+ *
+ * Copyright 2010, Tim Down
+ * Licensed under the MIT license.
+ * Version: 0.1.205
+ * Build date: 5 November 2010
+ */
+(function($) {
+    var UNDEF = "undefined";
+    var getSelection, setSelection, deleteSelectedText, deleteText, insertText;
+    var replaceSelectedText, surroundSelectedText, extractSelectedText, collapseSelection;
+
+    // Trio of isHost* functions taken from Peter Michaux's article:
+    // http://peter.michaux.ca/articles/feature-detection-state-of-the-art-browser-scripting
+    function isHostMethod(object, property) {
+        var t = typeof object[property];
+        return t === "function" || (!!(t == "object" && object[property])) || t == "unknown";
+    }
+
+    function isHostProperty(object, property) {
+        return typeof(object[property]) != UNDEF;
+    }
+
+    function isHostObject(object, property) {
+        return !!(typeof(object[property]) == "object" && object[property]);
+    }
+
+    function fail(reason) {
+        if (window.console && window.console.log) {
+            window.console.log("TextInputs module for Rangy not supported in your browser. Reason: " + reason);
+        }
+    }
+
+    function adjustOffsets(el, start, end) {
+        if (start < 0) {
+            start += el.value.length;
+        }
+        if (typeof end == UNDEF) {
+            end = start;
+        }
+        if (end < 0) {
+            end += el.value.length;
+        }
+        return { start: start, end: end };
+    }
+
+    function makeSelection(el, start, end) {
+        return {
+            start: start,
+            end: end,
+            length: end - start,
+            text: el.value.slice(start, end)
+        };
+    }
+
+    function getBody() {
+        return isHostObject(document, "body") ? document.body : document.getElementsByTagName("body")[0];
+    }
+
+    $(document).ready(function() {
+        var testTextArea = document.createElement("textarea");
+
+        getBody().appendChild(testTextArea);
+
+        if (isHostProperty(testTextArea, "selectionStart") && isHostProperty(testTextArea, "selectionEnd")) {
+            getSelection = function(el) {
+                var start = el.selectionStart, end = el.selectionEnd;
+                return makeSelection(el, start, end);
+            };
+
+            setSelection = function(el, startOffset, endOffset) {
+                var offsets = adjustOffsets(el, startOffset, endOffset);
+                el.selectionStart = offsets.start;
+                el.selectionEnd = offsets.end;
+            };
+
+            collapseSelection = function(el, toStart) {
+                if (toStart) {
+                    el.selectionEnd = el.selectionStart;
+                } else {
+                    el.selectionStart = el.selectionEnd;
+                }
+            };
+        } else if (isHostMethod(testTextArea, "createTextRange") && isHostObject(document, "selection") &&
+                   isHostMethod(document.selection, "createRange")) {
+
+            getSelection = function(el) {
+                var start = 0, end = 0, normalizedValue, textInputRange, len, endRange;
+                var range = document.selection.createRange();
+
+                if (range && range.parentElement() == el) {
+                    len = el.value.length;
+
+                    normalizedValue = el.value.replace(/\r\n/g, "\n");
+                    textInputRange = el.createTextRange();
+                    textInputRange.moveToBookmark(range.getBookmark());
+                    endRange = el.createTextRange();
+                    endRange.collapse(false);
+                    if (textInputRange.compareEndPoints("StartToEnd", endRange) > -1) {
+                        start = end = len;
+                    } else {
+                        start = -textInputRange.moveStart("character", -len);
+                        start += normalizedValue.slice(0, start).split("\n").length - 1;
+                        if (textInputRange.compareEndPoints("EndToEnd", endRange) > -1) {
+                            end = len;
+                        } else {
+                            end = -textInputRange.moveEnd("character", -len);
+                            end += normalizedValue.slice(0, end).split("\n").length - 1;
+                        }
+                    }
+                }
+
+                return makeSelection(el, start, end);
+            };
+
+            // Moving across a line break only counts as moving one character in a TextRange, whereas a line break in
+            // the textarea value is two characters. This function corrects for that by converting a text offset into a
+            // range character offset by subtracting one character for every line break in the textarea prior to the
+            // offset
+            var offsetToRangeCharacterMove = function(el, offset) {
+                return offset - (el.value.slice(0, offset).split("\r\n").length - 1);
+            };
+
+            setSelection = function(el, startOffset, endOffset) {
+                var offsets = adjustOffsets(el, startOffset, endOffset);
+                var range = el.createTextRange();
+                var startCharMove = offsetToRangeCharacterMove(el, offsets.start);
+                range.collapse(true);
+                if (offsets.start == offsets.end) {
+                    range.move("character", startCharMove);
+                } else {
+                    range.moveEnd("character", offsetToRangeCharacterMove(el, offsets.end));
+                    range.moveStart("character", startCharMove);
+                }
+                range.select();
+            };
+
+            collapseSelection = function(el, toStart) {
+                var range = document.selection.createRange();
+                range.collapse(toStart);
+                range.select();
+            };
+        } else {
+            getBody().removeChild(testTextArea);
+            fail("No means of finding text input caret position");
+            return;
+        }
+
+        // Clean up
+        getBody().removeChild(testTextArea);
+
+        deleteText = function(el, start, end, moveSelection) {
+            var val;
+            if (start != end) {
+                val = el.value;
+                el.value = val.slice(0, start) + val.slice(end);
+            }
+            if (moveSelection) {
+                setSelection(el, start, start);
+            }
+        };
+
+        deleteSelectedText = function(el) {
+            var sel = getSelection(el);
+            deleteText(el, sel.start, sel.end, true);
+        };
+
+        extractSelectedText = function(el) {
+            var sel = getSelection(el), val;
+            if (sel.start != sel.end) {
+                val = el.value;
+                el.value = val.slice(0, sel.start) + val.slice(sel.end);
+            }
+            setSelection(el, sel.start, sel.start);
+            return sel.text;
+        };
+
+        insertText = function(el, text, index, moveSelection) {
+            var val = el.value, caretIndex;
+            el.value = val.slice(0, index) + text + val.slice(index);
+            if (moveSelection) {
+                caretIndex = index + text.length;
+                setSelection(el, caretIndex, caretIndex);
+            }
+        };
+
+        replaceSelectedText = function(el, text) {
+            var sel = getSelection(el), val = el.value;
+            el.value = val.slice(0, sel.start) + text + val.slice(sel.end);
+            var caretIndex = sel.start + text.length;
+            setSelection(el, caretIndex, caretIndex);
+        };
+
+        surroundSelectedText = function(el, before, after) {
+            var sel = getSelection(el), val = el.value;
+
+            el.value = val.slice(0, sel.start) + before + sel.text + after + val.slice(sel.end);
+            var startIndex = sel.start + before.length;
+            var endIndex = startIndex + sel.length;
+            setSelection(el, startIndex, endIndex);
+        };
+
+        function jQuerify(func, returnThis) {
+            return function() {
+                var el = this.jquery ? this[0] : this;
+                var nodeName = el.nodeName.toLowerCase();
+
+                if (el.nodeType == 1 && (nodeName == "textarea" || (nodeName == "input" && el.type == "text"))) {
+                    var args = [el].concat(Array.prototype.slice.call(arguments));
+                    var result = func.apply(this, args);
+                    if (!returnThis) {
+                        return result;
+                    }
+                }
+                if (returnThis) {
+                    return this;
+                }
+            };
+        }
+
+        $.fn.extend({
+            getSelection: jQuerify(getSelection, false),
+            setSelection: jQuerify(setSelection, true),
+            collapseSelection: jQuerify(collapseSelection, true),
+            deleteSelectedText: jQuerify(deleteSelectedText, true),
+            deleteText: jQuerify(deleteText, true),
+            extractSelectedText: jQuerify(extractSelectedText, false),
+            insertText: jQuerify(insertText, true),
+            replaceSelectedText: jQuerify(replaceSelectedText, true),
+            surroundSelectedText: jQuerify(surroundSelectedText, true)
+        });
+    });
+})(jQuery);