releaf 0.1.1

data/app/assets/javascripts/releaf/controllers/releaf/content.js

@@ -0,0 +1,90 @@
+//= require ../../lib/request_url
+
+jQuery(document).ready(function() {
+    // var controller_body = jQuery(document.body);
+    var controller_body = jQuery('.controller-releaf-content');
+    if (controller_body.length) {
+
+        jQuery('.secondary_panel .tree_container').delegate('a.create', 'click', function(e) {
+            e.stopPropagation();
+
+            var a = jQuery(e.currentTarget);
+            var p_li = a.parents('li:first');
+
+            var y = p_li.offset().top;
+            var x = p_li.offset().left + p_li.width() + 2;
+
+            var x_offset = [ 'padding-left', 'padding-right', 'margin-left' ]
+            for (var i = 0; i < x_offset.length; i++) {
+                x += parseInt(p_li.css(x_offset[i]));
+            }
+
+
+            var url = new RequestUrl( a.attr('href') ).add({ajax: 1}).getUrl();
+            var new_object_menu_anchor = jQuery('#new_object_menu_anchor')
+            if (new_object_menu_anchor.length === 0) {
+                new_object_menu_anchor = jQuery('<div id="new_object_menu_anchor"><div id="new_object_menu" style="display:none;"></div></div>');
+                controller_body.append(new_object_menu_anchor);
+            }
+
+            new_object_menu = new_object_menu_anchor.find('#new_object_menu').css({top: y, left: x});
+            new_object_menu.html(null).addClass('loading')
+                new_object_menu.show();
+
+
+
+            jQuery.ajax({
+                type:       'GET',
+                dataType:   'html',
+                url:        url,
+                timeout:    3000,
+                success:    function (data, textStatus) {
+                                new_object_menu.html(data).removeClass('loading');
+                            },
+                error:      function (xhr, textStatus, errorThrown) {
+                                new_object_menu.text('Error').removeClass('loading');
+                            }
+            });
+
+            return e.preventDefault();
+        });
+
+
+        $(document).click(function (e) {
+            var container = jQuery('#new_object_menu');
+            if ( container.has(e.target) ) {
+                container.hide();
+            }
+        });
+
+        var name_input = jQuery('#releaf_node_name');
+        if (name_input.length) {
+            var slug_input = jQuery('#releaf_node_slug');
+            var generate_slug_button = jQuery('button.generate_slug');
+
+            var generate_slug = function () {
+                var url = new RequestUrl( generate_slug_button.attr('data-new_slug_url') ).add({name: name_input.attr('value')}).getUrl();
+
+                jQuery.ajax({
+                    type:       'GET',
+                    dataType:   'text',
+                    url:        url,
+                    timeout:    3000,
+                    success:    function (data, textStatus) {
+                                    slug_input.attr('value', data);
+                                },
+                    error:      function (xhr, textStatus, errorThrown) {
+                                    // FIXME
+                                    alert("Failed to generate slug");
+                                }
+                });
+            }
+            generate_slug_button.on('click', generate_slug)
+
+            if (name_input.attr('value').length === 0) {
+                name_input.one('change', generate_slug);
+            }
+        }
+
+    }
+});

data/app/assets/javascripts/releaf/controllers/releaf/translations.js

@@ -0,0 +1,31 @@
+jQuery(function()
+{
+	var controller = jQuery( '.controller-releaf-translations' );
+
+	// adjust translations table head cell width
+
+	var headCells = controller.find( '.translations_table_head .th' );
+	//console.log( headCells );
+	var adjustHeadCellWidth = function()
+	{
+        var row = jQuery( '.module-translations .translations_table thead tr:first th' );
+
+		for( var i = 0; i < headCells.length; i++ )
+		{
+			jQuery( headCells[i] ).width( jQuery( row[i] ).outerWidth() - 2 );
+		}
+	};
+	adjustHeadCellWidth();
+	jQuery( window ).resize( adjustHeadCellWidth );
+
+	// highlight selected entry
+
+	if( location.hash )
+	{
+		jQuery( location.hash ).addClass( 'highlighted' );
+	}
+
+    controller.on('itemadd', function() {
+        controller.find('table.translations tbody tr:last td.translation_name input[type="text"]').focus();
+    });
+});

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

@@ -0,0 +1,321 @@
+jQuery(function()
+{
+	// continuous scrolling //
+	
+	jQuery( document ).on( 'scrollinit', '.releaf_table[data-continuous="1"]', function()
+	{
+		var table = jQuery( this );
+		var container = table.parent();
+		var thead = table.find( '.thead' );
+		var tbody = table.find( '.tbody' );
+		var search_form = table.parents( '.primary_panel' ).find( '.search_form' );
+		
+		var noOfCols  = thead.children().children().length;
+		var rowHeight = tbody.children().first().height();
+		
+		var rowLoadTolerance   = 15; // how many rows outside viewport to pre-load
+		var rowRenderTolerance = 40; // how many rows outside viewport to render (could be loaded)
+		
+		var cachedRowLimit = 400 * 40;
+		
+		var viewportHeight;
+		var noOfVisibleRows;
+		
+		var setupViewport = function()
+		{
+			viewportHeight = container.height();
+			noOfVisibleRows = Math.ceil( viewportHeight / rowHeight );
+		}
+		setupViewport();
+		jQuery( window ).resize(function()
+		{
+			setupViewport();
+			container.scroll();
+		});
+		
+        var total, itemsPerPage, noOfPages;
+        var setupTotals = function()
+        {
+            total = table.attr( 'data-total' );
+            itemsPerPage = table.attr( 'data-items_per_page' );
+            noOfPages = Math.floor( total / itemsPerPage ) + 1;
+        }
+        setupTotals();        
+		
+		var timeout;
+		var requests = {};
+		
+		var abortRequests = function()
+		{
+			for( var i in requests )
+			{
+				requests[i].abort();
+			}
+			requests = {};
+		}
+		
+		var currentTopPageNo    = 1;
+		var currentBottomPageNo = 1;
+		
+		var pages = {};
+		
+		// store current results as page 1
+		pages[ currentTopPageNo ] = tbody.html();
+		
+		var clone;
+		
+		var emptyRowCells = '';
+		var loadingRowCells = '';
+		var thCellWidths = {};
+		
+		// freeze column widths
+		var freeze = function()
+		{
+			// reset header width
+			if( clone )
+			{
+				clone.remove();
+			}
+			thead.children().first().children().each(function()
+			{
+				var cell = jQuery( this );
+				var width = cell.width() + 'px';
+				cell.css( 'width', '' );
+				cell.css( 'min-width', '' );
+				cell.css( 'max-width', '' );
+			});
+			// freeze it
+			thead.children().first().children().each(function()
+			{
+				var cell = jQuery( this );
+				var width = cell.width() + 'px';
+				cell.css( 'width', width );
+				cell.css( 'min-width', width );
+				cell.css( 'max-width', width );
+			});
+			
+			// add fixed header
+			clone = thead.clone().insertAfter( thead ).css({ position: 'fixed', zIndex: 100}).addClass('fixed');
+			clone.css( 'margin-top', '-' + clone.height() + 'px' )
+			
+			emptyRowCells   = '';
+			loadingRowCells = '';
+			thCellWidths    = {};
+			thead.children().children().each(function( i )
+			{
+				thCellWidths[ i ] = jQuery( this ).width();
+			});
+			for( var i = 0; i < noOfCols; i++ )
+			{
+				emptyRowCells += '<span>&nbsp;</span>';
+				if( thCellWidths[i] >= 100 )
+				{
+					loadingRowCells += '<span>' + table.attr( 'data-loading' ) + '</span>';
+				}
+				else
+				{
+					loadingRowCells += '<span>&nbsp;</span>';
+				}
+			}
+			emptyRow   = '<div class="unselectable">' + emptyRowCells + '</div>';
+			loadingRow = '<div class="unselectable" style="height:' + rowHeight + 'px;">' + loadingRowCells + '</div>';
+		}
+		
+		freeze();
+		
+		var getEmptyRows = function( no )
+		{
+			var rows = [];
+			for( var i = 0; i < no; i++ )
+			{
+				rows.push( loadingRow );
+			}
+			return rows.join( '' );
+		}
+		
+		// initial setup
+		var postHeight = total * rowHeight - tbody.children().length * rowHeight;
+		if( postHeight > 0 )
+		{
+			var post = jQuery( emptyRow ).addClass( 'post' ).appendTo( tbody );
+			post.height( postHeight );
+		}
+		
+		container.scroll(function()
+		{
+			clearTimeout( timeout );
+			timeout = setTimeout(function()
+			{
+				var offsets =
+				{
+					visible:
+					{
+						top:    0,
+						bottom: 0
+					},
+					load:
+					{
+						top:    0,
+						bottom: 0
+					},
+					render:
+					{
+						top:    0,
+						bottom: 0
+					}
+				};
+				
+				var pageNumbers =
+				{
+					load:
+					{
+						top:    0,
+						bottom: 0
+					},
+					render:
+					{
+						top:    0,
+						bottom: 0
+					}
+				}
+				
+				offsets.visible.top    = Math.floor( Math.max( 0, container.prop( 'scrollTop' ) - thead.height() ) / rowHeight );
+				offsets.visible.bottom = offsets.visible.top + noOfVisibleRows;
+				
+				// adjust for loading tolerance
+				offsets.load.top    = Math.max( 0, offsets.visible.top - rowLoadTolerance );
+				offsets.load.bottom = Math.min( offsets.visible.bottom + rowLoadTolerance, total );
+				
+				// adjust for rendering tolerance
+				offsets.render.top    = Math.max( 0, offsets.visible.top - rowRenderTolerance );
+				offsets.render.bottom = Math.min( offsets.visible.bottom + rowRenderTolerance, total );
+				
+				pageNumbers.load.top    = Math.floor( offsets.load.top / itemsPerPage ) + 1;
+				pageNumbers.load.bottom = Math.floor( offsets.load.bottom / itemsPerPage ) + 1;
+				
+				pageNumbers.render.top    = Math.floor( offsets.render.top / itemsPerPage ) + 1;
+				pageNumbers.render.bottom = Math.floor( offsets.render.bottom / itemsPerPage ) + 1;
+				
+				var preOffset = ( pageNumbers.render.top - 1 ) * itemsPerPage;
+				var postOffset = Math.max( 0, total - pageNumbers.render.bottom * itemsPerPage );
+				
+				if( pageNumbers.load.top != currentTopPageNo || pageNumbers.load.bottom != currentBottomPageNo )
+				{
+					abortRequests();
+					
+					var no = 0;
+					for( var i in pages )
+					{
+						if( pages[i] )
+						{
+							no++;
+						}
+					}
+					
+					// clear memory
+					if( no * itemsPerPage > cachedRowLimit )
+					{
+						pages = {};
+					}
+					
+					var pagesToLoad = {};
+					for( var i = 0; i <= pageNumbers.load.bottom - pageNumbers.load.top; i++ )
+					{
+						pagesToLoad[ pageNumbers.load.top + i ] = true;
+					}
+					
+					var pagesToRender = {};
+					for( var i = 0; i <= pageNumbers.render.bottom - pageNumbers.render.top; i++ )
+					{
+						pagesToRender[ pageNumbers.render.top + i ] = true;
+					}
+					
+					var inject = function()
+					{
+						var rows = '';
+						for( var i in pagesToRender )
+						{
+							if( pages[ i ] === undefined )
+							{
+								if( i == noOfPages ) // last page is likely to be smaller
+								{
+									rows += getEmptyRows( total - ( noOfPages - 1 ) * itemsPerPage );
+								}
+								else
+								{
+									rows += getEmptyRows( itemsPerPage );
+								}
+							}
+							else
+							{
+								rows += pages[ i ];
+							}
+						}
+						currentTopPageNo    = pageNumbers.load.top;
+						currentBottomPageNo = pageNumbers.load.bottom;
+						
+						var pre = '';
+						if( preOffset > 0 )
+						{
+							var pre = '<div class="unselectable pre" style="height:' + ( preOffset * rowHeight ) + 'px">' + emptyRowCells + '</div>';
+						}
+						var post = '';
+						if( postOffset > 0 )
+						{
+							var post = '<div class="unselectable post" style="height:' + ( postOffset * rowHeight ) + 'px">' + emptyRowCells + '</div>';
+						}
+						tbody.html( pre + rows + post );
+						
+						// check if row width need to be recalculated
+						if
+						(
+							container.prop( 'clientWidth' ) > 0
+							&&
+							container.prop( 'clientWidth' ) < container.prop( 'scrollWidth' )
+						)
+						{
+							freeze();
+						}
+						
+						return true;
+					}
+					
+					for( var i in pagesToLoad )
+					{
+						if( pages[ i ] === undefined )
+						{
+							(function(){
+								var pageNo = i;
+								var key = Math.random() + '';
+                                
+                                var searchUrl = new RequestUrl();
+                                searchUrl.add( search_form.serializeArray() );
+                                searchUrl.add({ ajax: 1, page: pageNo });
+								requests[key] = jQuery.ajax
+								({
+                                    url: searchUrl.getUrl(),
+									success: function( html, status )
+									{
+										delete requests[key];
+										pages[ pageNo ] = jQuery( html ).find( '.releaf_table .tbody' ).html();
+										inject();
+									}
+								});	
+							})();
+						}
+					}
+					inject();
+				}
+			},20);
+		});
+		container.scroll();
+		
+		table.bind( 'flushcache', function()
+		{
+			pages = {};
+            setupTotals();
+		});
+	});
+	
+	jQuery( '.releaf_table[data-continuous="1"]' ).trigger( 'scrollinit' );
+});

data/app/assets/javascripts/releaf/include/field.type_autocomplete.js

@@ -0,0 +1,58 @@
+//= require yui
+//= require ../lib/request_url
+
+YUI().use('node', 'event', 'autocomplete', 'autocomplete-highlighters', function (Y) {
+    var init_autocomplete = function(scope) {
+        Y.all(scope).each(function(element) {
+            element.all('.field.type_autocomplete:not(.initialized)').each(function(field_wrap) {
+                field_wrap.addClass('initialized');
+                var field = field_wrap.one('input[type="text"]');
+                var hidden = field_wrap.one('input[type="hidden"]');
+                var expand_icon = field_wrap.one('.autocomplete_expand_icon');
+
+                field.plug(Y.Plugin.AutoComplete, {
+                    resultHighlighter: 'subWordMatch',
+                    resultListLocator: 'results',
+                    resultTextLocator: 'text',
+                    minQueryLength: 1,
+                    source: new RequestUrl(field.getData('autocomplete-url')).add({'q': '{query}'}).getUrl(),
+                    on: {
+                        select: function (itemNode, object) {
+                            hidden.set('value', itemNode.result.raw.id);
+                        }
+                    }
+                    /*
+                    * after: {
+                    *     resultsChange: function (e) {
+                    *         console.debug(e);
+                    *     }
+                    * }
+                    */
+                });
+
+                field.on('change', function() {
+                    hidden.set('value', null);
+                });
+
+                var autocomplete_click = function() {
+                    if (field.ac.get('visible')) {
+                        field.ac.hide();
+                    }
+                    else {
+                        field.ac.sendRequest(field.value);
+                    }
+                }
+
+                expand_icon.on('click', autocomplete_click);
+                field.on('focus', autocomplete_click);
+            });
+        });
+    }
+
+    Y.on('click', function(e) {
+        init_autocomplete(e.target);
+    }, 'body');
+
+    init_autocomplete('body');
+
+});