prime-rails 0.0.3

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZWUyODlmNmZkMTA1ZWFlODFiNDY1NWMzNjQ2ODdmNDFkMGFkMTc5MQ==
+  data.tar.gz: !binary |-
+    N2RmYWVhYjJmMzhjZjdmNWVjZGNhOTYyZGIxOTRiMDBiODhkZmMzMA==
+SHA512:
+  metadata.gz: !binary |-
+    ZDVlM2QyNmVmOGFiZTYzZDY2MzI1M2Y3MjYxNzlkOTMzNTY0NWEzZDRkMTU2
+    MDgxMGZhNjI2MjI4OWU2OTBlZDI0ZDg4MjU2ZmRkNWRmMWIwMjVhNjU3ZGYz
+    ZDlkOTI5MzkxNzY3MGFjNTNlZTlmOTk2YmJjNTA2MjJhMzY3NmQ=
+  data.tar.gz: !binary |-
+    NjRlMjYyYjA2NmY1NTAzMzM0ZjcyOGU5OTQ5NzU2NDQ2MTIxNDE1NGU2ZDJi
+    YjQxZTU4ODRhYjIzNGZmYWQ3NDJmOWJhZGQ3ZTgwYTNkNTk1OGZhOGZlODg4
+    NmQ0YTVlMGEwNjIxM2JhZmMyMjVlMjlkNDNhMTg3MDUxMzc0OTc=

data/app/assets/javascripts/js/accordion/accordion.js

@@ -0,0 +1,134 @@
+/**
+ * PrimeUI Accordion widget
+ */
+$(function() {
+
+    $.widget("primeui.puiaccordion", {
+       
+        options: {
+             activeIndex: 0,
+             multiple: false
+        },
+        
+        _create: function() {
+            if(this.options.multiple) {
+                this.options.activeIndex = [];
+            }
+        
+            var $this = this;
+            this.element.addClass('pui-accordion ui-widget ui-helper-reset');
+            
+            this.element.children('h3').addClass('pui-accordion-header ui-helper-reset ui-state-default').each(function(i) {
+                var header = $(this),
+                title = header.html(),
+                headerClass = (i == $this.options.activeIndex) ? 'ui-state-active ui-corner-top' : 'ui-corner-all',
+                iconClass = (i == $this.options.activeIndex) ? 'ui-icon ui-icon-triangle-1-s' : 'ui-icon ui-icon-triangle-1-e';
+                                
+                header.addClass(headerClass).html('<span class="' + iconClass + '"></span><a href="#">' + title + '</a>');
+            });
+            
+            this.element.children('div').each(function(i) {
+                var content = $(this);
+                content.addClass('pui-accordion-content ui-helper-reset ui-widget-content');
+                
+                if(i != $this.options.activeIndex) {
+                    content.addClass('ui-helper-hidden');
+                }
+            });
+            
+            this.headers = this.element.children('.pui-accordion-header');
+            this.panels = this.element.children('.pui-accordion-content');
+            this.headers.children('a').disableSelection();
+            
+            this._bindEvents();
+        },
+        
+        _bindEvents: function() {
+            var $this = this;
+
+            this.headers.mouseover(function() {
+                var element = $(this);
+                if(!element.hasClass('ui-state-active')&&!element.hasClass('ui-state-disabled')) {
+                    element.addClass('ui-state-hover');
+                }
+            }).mouseout(function() {
+                var element = $(this);
+                if(!element.hasClass('ui-state-active')&&!element.hasClass('ui-state-disabled')) {
+                    element.removeClass('ui-state-hover');
+                }
+            }).click(function(e) {
+                var element = $(this);
+                if(!element.hasClass('ui-state-disabled')) {
+                    var tabIndex = element.index() / 2;
+
+                    if(element.hasClass('ui-state-active')) {
+                        $this.unselect(tabIndex);
+                    }
+                    else {
+                        $this.select(tabIndex);
+                    }
+                }
+
+                e.preventDefault();
+            });
+        },
+
+        /**
+         *  Activates a tab with given index
+         */
+        select: function(index) {
+            var panel = this.panels.eq(index);
+
+            this._trigger('change', panel);
+            
+            //update state
+            if(this.options.multiple) 
+                this._addToSelection(index);
+            else
+                this.options.activeIndex = index;
+
+            this._show(panel);
+        },
+
+        /**
+         *  Deactivates a tab with given index
+         */
+        unselect: function(index) {
+            var panel = this.panels.eq(index),
+            header = panel.prev();
+
+            header.attr('aria-expanded', false).children('.ui-icon').removeClass('ui-icon-triangle-1-s').addClass('ui-icon-triangle-1-e');
+            header.removeClass('ui-state-active ui-corner-top').addClass('ui-corner-all');
+            panel.attr('aria-hidden', true).slideUp();
+
+            this._removeFromSelection(index);
+        },
+
+        _show: function(panel) {
+            //deactivate current
+            if(!this.options.multiple) {
+                var oldHeader = this.headers.filter('.ui-state-active');
+                oldHeader.children('.ui-icon').removeClass('ui-icon-triangle-1-s').addClass('ui-icon-triangle-1-e');
+                oldHeader.attr('aria-expanded', false).removeClass('ui-state-active ui-corner-top').addClass('ui-corner-all').next().attr('aria-hidden', true).slideUp();
+            }
+
+            //activate selected
+            var newHeader = panel.prev();
+            newHeader.attr('aria-expanded', true).addClass('ui-state-active ui-corner-top').removeClass('ui-state-hover ui-corner-all')
+                    .children('.ui-icon').removeClass('ui-icon-triangle-1-e').addClass('ui-icon-triangle-1-s');
+
+            panel.attr('aria-hidden', false).slideDown('normal');
+        },
+
+        _addToSelection: function(nodeId) {
+            this.options.activeIndex.push(nodeId);
+        },
+
+        _removeFromSelection: function(index) {
+            this.options.activeIndex = $.grep(this.options.activeIndex, function(r) {
+                return r != index;
+            });
+        }
+        
+    });
+});

data/app/assets/javascripts/js/autocomplete/autocomplete.js

@@ -0,0 +1,439 @@
+/**
+ * PrimeUI autocomplete widget
+ */
+$(function() {
+
+    $.widget("primeui.puiautocomplete", {
+       
+        options: {
+            delay: 300,
+            minQueryLength: 1,
+            multiple: false,
+            dropdown: false,
+            scrollHeight: 200,
+            forceSelection: false,
+            effect:null,
+            effectOptions: {},
+            effectSpeed: 'normal',
+            content: null,
+            caseSensitive: false
+        },
+
+        _create: function() {
+            this.element.puiinputtext();
+            this.panel = $('<div class="pui-autocomplete-panel ui-widget-content ui-corner-all ui-helper-hidden pui-shadow"></div>').appendTo('body');
+            
+            if(this.options.multiple) {
+                this.element.wrap('<ul class="pui-autocomplete-multiple ui-widget pui-inputtext ui-state-default ui-corner-all">' + 
+                                        '<li class="pui-autocomplete-input-token"></li></ul>');
+                this.inputContainer = this.element.parent();
+                this.multiContainer = this.inputContainer.parent();
+            }
+            else {
+                if(this.options.dropdown) {
+                    this.dropdown = $('<button type="button" class="pui-button ui-widget ui-state-default ui-corner-right pui-button-icon-only">' +
+                        '<span class="pui-button-icon-primary ui-icon ui-icon-triangle-1-s"></span><span class="pui-button-text">&nbsp;</span></button>')
+                        .insertAfter(this.element);
+                    this.element.removeClass('ui-corner-all').addClass('ui-corner-left');
+                }
+            }
+
+            this._bindEvents();
+        },
+                
+        _bindEvents: function() {
+            var $this = this;
+ 
+            this._bindKeyEvents();
+            
+            if(this.options.dropdown) {
+                this.dropdown.on('hover.puiautocomplete', function() {
+                    if(!$this.element.prop('disabled')) {
+                        $this.dropdown.toggleClass('ui-state-hover');
+                    }
+                })
+                .on('mousedown.puiautocomplete', function() {
+                    if(!$this.element.prop('disabled')) {
+                        $this.dropdown.addClass('ui-state-active');
+                    }
+                })
+                .on('mouseup.puiautocomplete', function() {
+                    if(!$this.element.prop('disabled')) {
+                        $this.dropdown.removeClass('ui-state-active');
+                        $this.search('');
+                        $this.element.focus();
+                    }
+                })
+                .on('focus.puiautocomplete', function() {
+                    $this.dropdown.addClass('ui-state-focus');
+                })
+                .on('blur.puiautocomplete', function() {
+                    $this.dropdown.removeClass('ui-state-focus');
+                })
+                .on('keydown.puiautocomplete', function(e) {
+                    var keyCode = $.ui.keyCode;
+
+                    if(e.which == keyCode.ENTER || e.which == keyCode.NUMPAD_ENTER) {
+                        $this.search('');
+                        $this.input.focus();
+
+                        e.preventDefault();
+                    }
+                });
+            }
+            
+            if(this.options.multiple) {
+                this.multiContainer.on('hover.puiautocomplete', function() {
+                    $(this).toggleClass('ui-state-hover');
+                })
+                .on('click.puiautocomplete', function() {
+                    $this.element.trigger('focus');
+                });
+
+                this.element.on('focus.pui-autocomplete', function() {
+                    $this.multiContainer.addClass('ui-state-focus');
+                })
+                .on('blur.pui-autocomplete', function(e) {
+                    $this.multiContainer.removeClass('ui-state-focus');
+                });
+            }
+            
+            if(this.options.forceSelection) {
+                this.cachedResults = [this.element.val()];
+                this.element.on('blur.puiautocomplete', function() {
+                    var value = $this.element.val(),
+                    valid = false;
+
+                    for(var i = 0; i < $this.cachedResults.length; i++) {
+                        if($this.cachedResults[i] == value) {
+                            valid = true;
+                            break;
+                        }
+                    }
+
+                    if(!valid) {
+                        $this.element.val('');
+                    }
+                });
+            }
+
+            $(document.body).bind('mousedown.puiautocomplete', function (e) {
+                if($this.panel.is(":hidden")) {
+                    return;
+                }
+                
+                if(e.target === $this.element.get(0)) {
+                    return;
+                }
+                
+                var offset = $this.panel.offset();
+                if (e.pageX < offset.left ||
+                    e.pageX > offset.left + $this.panel.width() ||
+                    e.pageY < offset.top ||
+                    e.pageY > offset.top + $this.panel.height()) {
+                    $this.hide();
+                }
+            });
+
+            $(window).bind('resize.' + this.element.id, function() {
+                if($this.panel.is(':visible')) {
+                    $this._alignPanel();
+                }
+            });
+        },
+        
+        _bindKeyEvents: function() {
+            var $this = this;
+
+            this.element.on('keyup.puiautocomplete', function(e) {
+                var keyCode = $.ui.keyCode,
+                key = e.which,
+                shouldSearch = true;
+
+                if(key == keyCode.UP 
+                    || key == keyCode.LEFT 
+                    || key == keyCode.DOWN 
+                    || key == keyCode.RIGHT 
+                    || key == keyCode.TAB 
+                    || key == keyCode.SHIFT 
+                    || key == keyCode.ENTER
+                    || key == keyCode.NUMPAD_ENTER) {
+                    shouldSearch = false;
+                } 
+
+                if(shouldSearch) {
+                    var value = $this.element.val();
+
+                    if(!value.length) {
+                        $this.hide();
+                    }
+
+                    if(value.length >= $this.options.minQueryLength) {
+                        if($this.timeout) {
+                            clearTimeout($this.timeout);
+                        }
+
+                        $this.timeout = setTimeout(function() {
+                            $this.search(value);
+                        }, 
+                        $this.options.delay);
+                    }
+                }
+
+            }).on('keydown.puiautocomplete', function(e) {
+                if($this.panel.is(':visible')) {
+                    var keyCode = $.ui.keyCode,
+                    highlightedItem = $this.items.filter('.ui-state-highlight');
+
+                    switch(e.which) {
+                        case keyCode.UP:
+                        case keyCode.LEFT:
+                            var prev = highlightedItem.prev();
+
+                            if(prev.length == 1) {
+                                highlightedItem.removeClass('ui-state-highlight');
+                                prev.addClass('ui-state-highlight');
+
+                                if($this.options.scrollHeight) {
+                                    PUI.scrollInView($this.panel, prev);
+                                }
+                            }
+
+                            e.preventDefault();
+                            break;
+
+                        case keyCode.DOWN:
+                        case keyCode.RIGHT:
+                            var next = highlightedItem.next();
+
+                            if(next.length == 1) {
+                                highlightedItem.removeClass('ui-state-highlight');
+                                next.addClass('ui-state-highlight');
+
+                                if($this.options.scrollHeight) {
+                                    PUI.scrollInView($this.panel, next);
+                                }
+                            }
+
+                            e.preventDefault();
+                            break;
+
+                        case keyCode.ENTER:
+                        case keyCode.NUMPAD_ENTER:
+                            highlightedItem.trigger('click');
+
+                            e.preventDefault();
+                            break;
+
+                        case keyCode.ALT: 
+                        case 224:
+                            break;
+
+                        case keyCode.TAB:
+                            highlightedItem.trigger('click');
+                            $this.hide();
+                            break;
+                    }
+                }
+
+            });
+        },
+
+        _bindDynamicEvents: function() {
+            var $this = this;
+
+            this.items.on('mouseover.puiautocomplete', function() {
+                var item = $(this);
+
+                if(!item.hasClass('ui-state-highlight')) {
+                    $this.items.filter('.ui-state-highlight').removeClass('ui-state-highlight');
+                    item.addClass('ui-state-highlight');
+                }
+            })
+            .on('click.puiautocomplete', function(event) {
+                var item = $(this);
+                
+                if($this.options.multiple) {
+                    var tokenMarkup = '<li class="pui-autocomplete-token ui-state-active ui-corner-all ui-helper-hidden">';
+                    tokenMarkup += '<span class="pui-autocomplete-token-icon ui-icon ui-icon-close" />';
+                    tokenMarkup += '<span class="pui-autocomplete-token-label">' + item.data('label') + '</span></li>';
+
+                    $(tokenMarkup).data(item.data())
+                        .insertBefore($this.inputContainer).fadeIn()
+                        .children('.pui-autocomplete-token-icon').on('click.pui-autocomplete', function(e) {
+                            var token = $(this).parent();
+                            $this._removeItem(token);
+                            $this._trigger('unselect', e, token);
+                    });
+                    
+                    $this.element.val('').trigger('focus');
+                }
+                else {
+                    $this.element.val(item.data('label')).focus();
+                }
+
+                $this._trigger('select', event, item);
+                $this.hide();
+            });
+        },
+        
+        search: function(q) {            
+            this.query = this.options.caseSensitive ? q : q.toLowerCase();
+
+            var request = {
+                query: this.query
+            };
+
+            if(this.options.completeSource) {
+                if($.isArray(this.options.completeSource)) {
+                    var sourceArr = this.options.completeSource,
+                    data = [],
+                    emptyQuery = ($.trim(q) === '');
+                    
+                    for(var i = 0 ; i < sourceArr.length; i++) {
+                        var item = sourceArr[i],
+                        itemLabel = item.label||item;
+                        
+                        if(!this.options.caseSensitive) {
+                            itemLabel = itemLabel.toLowerCase();
+                        }
+
+                        if(emptyQuery||itemLabel.indexOf(this.query) === 0) {
+                            data.push({label:sourceArr[i], value: item});
+                        }
+                    }
+
+                    this._handleData(data);
+                }
+                else {
+                    this.options.completeSource.call(this, request, this._handleData);
+                }
+            }
+        },
+
+        _handleData: function(data) {
+            var $this = this;
+            this.panel.html('');
+            this.listContainer = $('<ul class="pui-autocomplete-items pui-autocomplete-list ui-widget-content ui-widget ui-corner-all ui-helper-reset"></ul>').appendTo(this.panel);
+
+            for(var i = 0; i < data.length; i++) {
+                var item = $('<li class="pui-autocomplete-item pui-autocomplete-list-item ui-corner-all"></li>');
+                item.data(data[i]);
+                
+                if(this.options.content)
+                    item.html(this.options.content.call(this, data[i]));
+                else
+                    item.text(data[i].label);
+                
+                this.listContainer.append(item);
+            }
+            
+            this.items = this.listContainer.children('.pui-autocomplete-item');
+            
+            this._bindDynamicEvents();
+
+            if(this.items.length > 0) {
+                var firstItem = $this.items.eq(0),
+                hidden = this.panel.is(':hidden');
+                firstItem.addClass('ui-state-highlight');
+
+                if($this.query.length > 0 && !$this.options.content) {
+                    $this.items.each(function() {
+                        var item = $(this),
+                        text = item.html(),
+                        re = new RegExp(PUI.escapeRegExp($this.query), 'gi'),
+                        highlighedText = text.replace(re, '<span class="pui-autocomplete-query">$&</span>');
+
+                        item.html(highlighedText);
+                    });
+                }
+
+                if(this.options.forceSelection) {
+                    this.cachedResults = [];
+                    this.data.each(function(i, item) {
+                        $this.cachedResults.push(item.label);
+                    });
+                }
+
+                //adjust height
+                if($this.options.scrollHeight) {
+                    var heightConstraint = hidden ? $this.panel.height() : $this.panel.children().height();
+
+                    if(heightConstraint > $this.options.scrollHeight)
+                        $this.panel.height($this.options.scrollHeight);
+                    else
+                        $this.panel.css('height', 'auto');                              
+
+                }
+
+                if(hidden) {
+                    $this.show();
+                }
+                else {
+                    $this._alignPanel();
+                }
+            }
+            else {
+                this.panel.hide();
+            }
+        },
+
+        show: function() {
+            this._alignPanel();
+
+            if(this.options.effect)
+                this.panel.show(this.options.effect, {}, this.options.effectSpeed);
+            else
+                this.panel.show();
+        },
+
+        hide: function() {        
+            this.panel.hide();
+            this.panel.css('height', 'auto');
+        },
+        
+        _removeItem: function(item) {
+            item.fadeOut('fast', function() {
+                var token = $(this);
+
+                token.remove();
+            });
+        },
+        
+        _alignPanel: function() {
+            var panelWidth = null;
+
+            if(this.options.multiple) {
+                panelWidth = this.multiContainer.innerWidth() - (this.element.position().left - this.multiContainer.position().left);
+            }
+            else {
+                if(this.panel.is(':visible')) {
+                    panelWidth = this.panel.children('.pui-autocomplete-items').outerWidth();
+                }
+                else {
+                    this.panel.css({'visibility':'hidden','display':'block'});
+                    panelWidth = this.panel.children('.pui-autocomplete-items').outerWidth();
+                    this.panel.css({'visibility':'visible','display':'none'});
+                }
+
+                var inputWidth = this.element.outerWidth();
+                if(panelWidth < inputWidth) {
+                    panelWidth = inputWidth;
+                }
+            }
+
+            this.panel.css({
+                            'left':'',
+                            'top':'',
+                            'width': panelWidth,
+                            'z-index': ++PUI.zindex
+                    })
+                    .position({
+                        my: 'left top'
+                        ,at: 'left bottom'
+                        ,of: this.element
+                    });
+        }
+    });
+    
+});

data/app/assets/javascripts/js/button/button.js

@@ -0,0 +1,98 @@
+/**
+ * PrimeFaces Growl Widget
+ */
+$(function() {
+
+    $.widget("primeui.puibutton", {
+       
+        options: {
+            icon: null
+            ,iconPos : 'left'
+        },
+        
+        _create: function() {
+            var element = this.element,
+            text = element.text()||'pui-button',
+            disabled = element.prop('disabled'),
+            styleClass = null;
+            
+            if(this.options.icon) {
+                styleClass = (text === 'pui-button') ? 'pui-button-icon-only' : 'pui-button-text-icon-' + this.options.iconPos;
+            }
+            else {
+                styleClass = 'pui-button-text-only';
+            }
+        
+            if(disabled) {
+                styleClass += ' ui-state-disabled';
+            }
+            
+            this.element.addClass('pui-button ui-widget ui-state-default ui-corner-all ' + styleClass).text('');
+            
+            if(this.options.icon) {
+                this.element.append('<span class="pui-button-icon-' + this.options.iconPos + ' ui-icon ' + this.options.icon + '" />');
+            }
+            
+            this.element.append('<span class="pui-button-text">' + text + '</span>');
+            
+            //aria
+            element.attr('role', 'button').attr('aria-disabled', disabled);    
+            
+            if(!disabled) {
+                this._bindEvents();
+            }
+        },
+        
+        _bindEvents: function() {
+            var element = this.element,
+            $this = this;
+            
+            element.on('mouseover.puibutton', function(){
+                if(!element.prop('disabled')) {
+                    element.addClass('ui-state-hover');
+                }
+            }).on('mouseout.puibutton', function() {
+                $(this).removeClass('ui-state-active ui-state-hover');
+            }).on('mousedown.puibutton', function() {
+                if(!element.hasClass('ui-state-disabled')) {
+                    element.addClass('ui-state-active').removeClass('ui-state-hover');
+                }
+            }).on('mouseup.puibutton', function(e) {
+                element.removeClass('ui-state-active').addClass('ui-state-hover');
+                
+                $this._trigger('click', e);
+            }).on('focus.puibutton', function() {
+                element.addClass('ui-state-focus');
+            }).on('blur.puibutton', function() {
+                element.removeClass('ui-state-focus');
+            }).on('keydown.puibutton',function(e) {
+                if(e.keyCode == $.ui.keyCode.SPACE || e.keyCode == $.ui.keyCode.ENTER || e.keyCode == $.ui.keyCode.NUMPAD_ENTER) {
+                    element.addClass('ui-state-active');
+                }
+            }).on('keyup.puibutton', function() {
+                element.removeClass('ui-state-active');
+            });
+
+            return this;
+        },
+        
+        _unbindEvents: function() {
+            this.element.off('mouseover.puibutton mouseout.puibutton mousedown.puibutton mouseup.puibutton focus.puibutton blur.puibutton keydown.puibutton keyup.puibutton');
+        },
+        
+        disable: function() {
+            this._unbindEvents();
+            
+            this.element.attr({
+                'disabled':'disabled',
+                'aria-disabled': true
+            }).addClass('ui-state-disabled');
+        },
+        
+        enable: function() {
+            this._bindEvents();
+            
+            this.element.removeAttr('disabled').attr('aria-disabled', false).removeClass('ui-state-disabled');
+        }
+    });
+});