releaf-core 0.2.1

data/app/assets/javascripts/releaf/include/loader.js

@@ -0,0 +1,45 @@
+jQuery(function()
+{
+
+    jQuery('body').on('loadingstart', '.button', function(e)
+    {
+        var button = jQuery(e.target);
+
+        if (button.hasClass('loading'))
+        {
+            return;
+        }
+
+        button.addClass('loading');
+
+        button.data('disabled-before-loading', button.prop('disabled') );
+
+        button.prop('disabled', true);
+
+        var loader = jQuery('<i />').addClass('loader fa fa-spin fa-spinner');
+        button.append( loader );
+    });
+
+
+    jQuery('body').on('loadingend', '.button', function(e)
+    {
+        var button = jQuery(e.target);
+        button.find('.loader').remove();
+
+        var disabled_before_loading = button.data('disabled-before-loading') ;
+
+        if (typeof disabled_before_loading !== 'undefined')
+        {
+            if (!disabled_before_loading)
+            {
+                button.prop('disabled', false);
+            }
+        }
+
+        button.removeClass('loading');
+
+    });
+
+
+
+});

data/app/assets/javascripts/releaf/include/localization.js

@@ -0,0 +1,213 @@
+jQuery(function()
+{
+    var body = jQuery('body');
+
+    var overlay = jQuery('<div />').addClass('localization-menu-overlay').appendTo(body);
+    overlay.bind('click', function()
+    {
+        body.trigger('localizationmenucloseall');
+    });
+
+    body.bind('localizationinit', function(e)
+    {
+        var block = jQuery(e.target);
+
+        e.stopPropagation();
+
+        var fields;
+        if (block.is('.field.i18n'))
+        {
+            fields = block;
+        }
+        else
+        {
+            fields = block.find('.field.i18n');
+        }
+
+        if (fields.length < 1)
+        {
+            return;
+        }
+
+        fields.bind('localizationmenuopen', function()
+        {
+            var field  = jQuery(this);
+
+            // close all other open menus
+            body.trigger('localizationmenucloseall');
+
+            var menu = field.data('localization-menu');
+
+            field.attr('data-localization-menu-open', true);
+
+            menu.appendTo( body );
+
+            field.trigger('localizationmenuposition');
+
+            overlay.show();
+
+            menu.show();
+
+            return;
+        });
+
+        fields.bind('localizationmenuclose', function()
+        {
+            var field   = jQuery(this);
+
+            var menu = field.data('localization-menu');
+
+            var localization_switch = field.data('localization-switch');
+
+            menu.hide().appendTo( localization_switch );
+
+            overlay.hide();
+
+            field.removeAttr('data-localization-menu-open');
+
+            return;
+        });
+
+        fields.bind('localizationmenutoggle', function()
+        {
+            var field  = jQuery(this);
+            var event = (field.attr('data-localization-menu-open')) ? 'localizationmenuclose' : 'localizationmenuopen';
+            field.trigger( event );
+        });
+
+        fields.bind('localizationmenuposition', function()
+        {
+            var field   = jQuery(this);
+            if (!field.attr('data-localization-menu-open'))
+            {
+                return;
+            }
+
+            var menu = field.data('localization-menu');
+
+            var trigger        = field.data('localization-switch-trigger');
+
+            var triggerOffset  = trigger.offset();
+
+            menu.css
+            ({
+                left:  triggerOffset.left + trigger.outerWidth() - menu.outerWidth() ,
+                top :  triggerOffset.top + trigger.outerHeight(),
+            });
+
+        });
+
+        fields.find('.localization-switch .trigger').click(function()
+        {
+            jQuery(this).closest('.field.i18n').trigger('localizationmenutoggle');
+        });
+
+
+        fields.find('.localization-menu-items button').click(function()
+        {
+            var button = jQuery(this);
+            var locale  = button.attr('data-locale');
+            var menu    = button.closest('.localization-menu-items');
+            var field   = menu.data('field');
+            var localization_box = field.find('.localization[data-locale="' + locale + '"]');
+
+            body.trigger('localizationmenucloseall');
+
+            localization_box.trigger('localizationlocaleactivate');
+
+        });
+
+
+        fields.bind('localizationlocaleset', function( e, params )
+        {
+            var field = jQuery(this);
+
+            var locale = params.locale;
+
+            var localization_boxes = field.find('.localization[data-locale]');
+
+            var target_box  = localization_boxes.filter('[data-locale="' + locale + '"]');
+            var other_boxes = localization_boxes.not( target_box );
+
+            target_box.addClass('active');
+            other_boxes.removeClass('active');
+
+            var trigger_label = field.find('.localization-switch .trigger .label');
+
+            trigger_label.text( locale );
+
+
+            jQuery.cookie( 'releaf.i18n.locale', locale, { path: '/' } );
+
+
+        });
+
+
+        fields.find('.localization').bind('localizationlocaleactivate', function()
+        {
+            var localization_box = jQuery(this);
+            var locale = localization_box.attr('data-locale');
+
+            var form   = localization_box.closest('form');
+
+            form.find('.field.i18n').trigger('localizationlocaleset', { locale : locale });
+
+        });
+
+
+        var input_selector = 'input[type!="hidden"],textarea,select';
+        fields.find(input_selector).bind('focusprepare', function(e)
+        {
+            var localization_box = (jQuery(e.target).closest('.localization'));
+            if (localization_box.length < 1)
+            {
+                return;
+            }
+
+            // focus target is inside a i18n localization box
+            if (!localization_box.is('.active'))
+            {
+                localization_box.trigger('localizationlocaleactivate');
+            }
+        });
+
+
+        fields.each(function()
+        {
+            var field = jQuery(this);
+
+            var localization_switch = field.find('.localization-switch').first();
+
+            field.data('localization-switch', localization_switch );
+
+            field.data('localization-switch-trigger', localization_switch.find('.trigger').first() );
+
+            var menu = localization_switch.find('menu').first();
+
+            field.data('localization-menu', menu);
+
+            menu.data('field', field);
+
+        });
+
+
+    });
+
+    body.bind('localizationmenucloseall', function()
+    {
+        body.find('.field.i18n[data-localization-menu-open]').trigger('localizationmenuclose');
+    });
+
+
+
+    // attach localizationinit to all loaded content
+    body.on('contentloaded', function(e)
+    {
+        // reinit localization for all content that gets replaced via ajax
+        jQuery(e.target).trigger('localizationinit');
+
+    });
+
+});
+
+

data/app/assets/javascripts/releaf/include/nested_fields.js

@@ -0,0 +1,295 @@
+jQuery( document ).ready(function()
+{
+    var body = jQuery('body');
+
+    jQuery(document).bind('nestedfieldsinit', function( e )
+    {
+        var target = jQuery(e.target);
+        if (!target.is('section.nested'))
+        {
+            target = target.find('section.nested');
+        }
+
+        target.each(function()
+        {
+            var block = jQuery(this);
+            var list   = block.find('.list').first();
+
+            var block_name               = block.attr('data-name');
+            var item_selector            = '.item[data-name="' + block_name + '"]';
+
+            var new_item_selector        = '.item[data-name="' + block_name + '"].new';
+            var existing_item_selector   = '.item[data-name="' + block_name + '"]:not(.new)';
+
+
+            block.click( function( event, event_params )
+            {
+                var trigger = jQuery( event.target );
+
+                // webkit browsers go beyond button node when setting click target
+                if (!trigger.is('button'))
+                {
+                    trigger = trigger.parents( 'button' ).first();
+                }
+
+                if (!trigger.is('button.add-nested-item') && !trigger.is('button.remove-nested-item'))
+                {
+                    // irrelevant click
+                    return;
+                }
+
+                // skip click on disabled buttons
+                if(trigger.prop("disabled"))
+                {
+                    return;
+                }
+
+                var target_block = trigger.parents('section.nested').first();
+
+                if (target_block.attr('data-name') !== block_name)
+                {
+                    return;   // only react to own clicks
+                }
+
+                if (trigger.is('.add-nested-item'))
+                {
+                    var template = jQuery(target_block.data('releaf-template'));
+                    if (template.length !== 1)
+                    {
+                        return null;
+                    }
+
+
+                    var new_item = template;
+
+                    new_item.addClass('new');
+
+                    new_item.appendTo( list );
+
+                    new_item.trigger( 'nestedfieldsreindex', event_params );
+
+                    if (event_params && event_params.no_animation)
+                    {
+                        new_item.trigger( 'nestedfieldsitemadd', event_params);
+                        new_item.trigger( 'contentloaded', event_params );
+                    }
+                    else
+                    {
+                        if (new_item.is('tr, td') )
+                        {
+                            new_item.css({ opacity: 1 }).hide();
+                            new_item.fadeIn( 'normal', function()
+                            {
+                                new_item.trigger( 'nestedfieldsitemadd', event_params);
+                                new_item.trigger( 'contentloaded', event_params );
+                            });
+                        }
+                        else
+                        {
+                            new_item.css({ opacity: 0 });
+                            new_item.slideDown( 'fast', function()
+                            {
+                                new_item.css({ opacity: 1 }).hide();
+                                new_item.fadeIn( 'fast', function()
+                                {
+                                    new_item.trigger( 'nestedfieldsitemadd', event_params );
+                                    new_item.trigger( 'contentloaded', event_params );
+                                });
+                            });
+                        }
+                    }
+
+                }
+                else if (trigger.is('.remove-nested-item'))
+                {
+                    var item = trigger.parents(item_selector).first();
+
+                    var removeItem = function( item )
+                    {
+                        item.trigger( 'contentbeforeremove', event_params );
+
+                        var parent = item.parent();
+
+                        var destroy_inputs = item.find('input.destroy');
+
+                        if (destroy_inputs.length > 0)
+                        {
+                            // mark as destroyable and hide
+                            destroy_inputs.val( true );
+
+                            item.hide();
+                        }
+                        else
+                        {
+                            item.remove();
+                        }
+
+                        target_block.trigger( 'nestedfieldsreindex', event_params );
+                        parent.trigger( 'contentremoved', event_params );
+                    };
+
+                    item.addClass( 'removed' );
+
+                    item.trigger( 'nestedfieldsitemremove', event_params );
+
+                    if (event_params && event_params.no_animation)
+                    {
+                        removeItem( item );
+                    }
+                    else
+                    {
+                        item.fadeOut( 'fast', function()
+                        {
+                            if (item.is('tr,td'))
+                            {
+                                removeItem( item );
+                            }
+                            else
+                            {
+                                item.css({ opacity: 0 }).show().slideUp( 'fast', function()
+                                {
+                                    removeItem( item );
+                                });
+                            }
+                        });
+                    }
+                }
+
+                return;
+            });
+
+
+            block.on('nestedfieldsreindex', function()
+            {
+                // update data-index attributes and names/ids for all fields inside a block
+
+                // in case of nested blocks, this bubbles up and gets called for each parent block also
+                // so that each block can update it's own index in the names
+
+                // only new items are changed.
+                // existing items always preserve their original indexes
+                // new item indexes start from largest of existing item indexes + 1
+
+                var first_available_new_index = 0;
+
+                var existing_items = block.find( existing_item_selector );
+                existing_items.each(function()
+                {
+                    var index = jQuery(this).attr('data-index');
+                    if (typeof index === 'undefined')
+                    {
+                        return;
+                    }
+                    index = index * 1;
+
+                    if (index >= first_available_new_index)
+                    {
+                        first_available_new_index = index + 1;
+                    }
+                });
+
+                var new_items = block.find(new_item_selector);
+
+                var index = first_available_new_index;
+
+                var changeable_attributes = [];
+                new_items.each(function()
+                {
+                    var item = jQuery(this);
+                    item.attr('data-index', index);
+
+                    // this matches both of these syntaxes in attribute values:
+                    //
+                    //  resource[foo_attributes][0][bar]  /  resource[foo_attributes][_template_][bar]
+                    //  resource_foo_attributes_0_bar     /  resource_foo_attributes__template__bar
+                    //
+
+                    var matchPattern   = new RegExp('(\\[|_)' + block_name + '_attributes(\\]\\[|_)(\\d*|_template_)?(\\]|_)');
+                    var searchPattern  = new RegExp('((\\[|_)' + block_name + '_attributes(\\]\\[|_))(\\d*|_template_)?(\\]|_)', 'g');
+                    var replacePattern = '$1' + index + '$5';
+                    var attrs = ['name', 'id', 'for'];
+
+                    // collect changeable attributes
+                    item.find('input,select,textarea,button,label').each(function()
+                    {
+                        for (var i=0; i<attrs.length; i++)
+                        {
+                            var attr = jQuery(this).attr(attrs[i]);
+                            if (attr && attr.match(matchPattern))
+                            {
+                                var params = {
+                                    element:   this,
+                                    attribute: attrs[i],
+                                    old_value: attr,
+                                    new_value: attr.replace(searchPattern, replacePattern),
+                                };
+                                if (params.old_value === params.new_value)
+                                {
+                                    continue;
+                                }
+                                changeable_attributes.push( params );
+                            }
+                        }
+                    });
+
+                    index++;
+                });
+
+                // perform change in two parts:
+                // at first change all changeable attributes to unique temporary strings for ALL affected items
+                // and then change the attributes to actual values
+
+                // this is needed so that any code in external beforeattributechange / attributechange handlers
+                // does not encounter ID collisions during the process (multiple elements temporarily sharing the same ID)
+
+                // change to temporary values
+                var temp_value_prefix = 'nestedfieldsreindex_temporary_value_';
+                jQuery.each(changeable_attributes, function(attribute_index, params)
+                {
+                    var element = jQuery(params.element);
+                    element.trigger('beforeattributechange', params );
+                    element.attr(params.attribute, temp_value_prefix + attribute_index);
+                });
+
+                // change to actual new values
+                jQuery.each(changeable_attributes, function(attribute_index, params)
+                {
+                    var element = jQuery(params.element);
+                    element.attr(params.attribute, params.new_value);
+                    element.trigger('attributechanged', params );
+                });
+
+
+            });
+
+            block.on('sortableupdate', function()
+            {
+                block.trigger('nestedfieldsreindex');
+            });
+
+            block.on('nestedfieldsitemadd', function( e )
+            {
+                var item = jQuery( e.target );
+
+                if (item.attr('data-name') !== block_name)
+                {
+                    return; // the added item does not belong to this block
+                }
+
+                // focus first visibile field in item
+                item.find( 'input, select, textarea' ).filter(':visible').first().focus();
+
+            });
+
+
+        });
+
+	});
+
+    body.on('contentloaded', function(e, event_params)
+    {
+        jQuery(e.target).trigger('nestedfieldsinit', event_params);
+    });
+
+
+});