gridx-rails 1.2.1 → 1.3.0.pre.alpha

data/app/assets/javascripts/gridx/modules/Edit.js

@@ -14,14 +14,17 @@ define([
 	"dojo/dom-geometry",
 	"dojo/dom-construct",
 	"dojo/keys",
+	"dojox/gesture/tap",
 	"dijit/a11y",
 	"../core/_Module",
 	"dojo/date/locale",
 	'../core/model/extensions/Modify',
 	'dojo/_base/event',
+	"dijit/form/Button",
+	"dijit/Toolbar",
 	"dijit/form/TextBox"
 //    "dojo/NodeList-traverse"
-], function(/*=====Column, Cell, =====*/declare, lang, query, json, Deferred, has, array, DeferredList, domClass, domStyle, domGeo, domConstruct, keys, a11y, _Module, locale, Modify, event){
+], function(/*=====Column, Cell, =====*/declare, lang, query, json, Deferred, has, array, DeferredList, domClass, domStyle, domGeo, domConstruct, keys, tap, a11y, _Module, locale, Modify, event){
 
 /*=====
 	Cell.beginEdit = function(){
@@ -195,14 +198,14 @@ define([
 		//		so editor.set('value', ...) can do the job.
 		valueField: 'value',
 
-		toEditor: function(storeData, gridData){
+		toEditor: function(storeData, gridData, cell){
 			// summary:
 			//		By default the dijit used in an editing cell will use store value.
 			//		If this default behavior can not meet the requirement (for example, store data is freely formatted date string,
 			//		while the dijit is dijit.form.DateTextBox, which requires a Date object), this function can be used.
 		},
 
-		fromEditor: function(valueInEditor){
+		fromEditor: function(valueInEditor, cell){
 			// summary:
 			//		By default when applying an editing cell, the value of the editor dijit will be retreived by get('value') and
 			//		directly set back to the store. If this can not meet the requirement, this getEditorValue function can be used
@@ -302,7 +305,9 @@ define([
 			editorArgs = cell.column.editorArgs;
 			editor.set(editorArgs && editorArgs.valueField || 'value', toEditor(storeData, gridData, cell, editor));
 		};
-	}	
+	}
+
+
 
 	return declare(_Module, {
 		name: 'edit',
@@ -358,28 +363,24 @@ define([
 								leftToMove = node.clientWidth - cellPadding - 5,
 								
 								html = [
-								"<div rowid='" + rowId + "' ",
-								"colid='" + colId + "' ",
-								"class='gridxCellEditedBg'><span>◥</span></div>"
+									"<div class='gridxCellEditedBgWrapper'>",
+										"<div	rowid='" + rowId + "' ",
+												"colid='" + colId + "' ",
+												"class='gridxCellEditedBg'><span>◥</span>",
+										"</div>",
+									"</div>"
 							].join('');
 							
-							cellBgNode = domConstruct.toDom(html);
-							domConstruct.place(cellBgNode, cell.node(), 'first');
+							wrapper= domConstruct.toDom(html);
+							cellBgNode = wrapper.firstChild;
+							domConstruct.place(wrapper, cell.node(), 'first');
 							
-							currentLeft = cellBgNode.offsetLeft;
-							currentLeft += leftToMove;
+							wrapperPosition= domGeo.position(cellBgNode);
+							nodePosition = domGeo.position(node);
 							
-							var upperRows = query('.gridxRow[visualIndex]', g.bodyNode),
-								top = 0;
-							array.forEach(upperRows, function(row){
-								var vi = parseInt(row.getAttribute('visualIndex'), 10);
-								if(vi < visualIndex){
-									top += row.clientHeight;
-								}
-							});
+							wrapper.style.top = nodePosition.y - wrapperPosition. y + 'px';
+							wrapper.style.left = cellPadding + 'px';
 							
-							domStyle.set(cellBgNode, 'left', currentLeft + 'px');
-							domStyle.set(cellBgNode, 'top', top+ 'px');
 						}
 				};
 				
@@ -415,33 +416,54 @@ define([
 				t.connect(g.body, 'onAfterCell', _onAftercell);
 			}
 			g.domNode.removeAttribute('aria-readonly');
-			t.connect(g, 'onCellDblClick', function(evt){
-				if(!domClass.contains(evt.target, 'gridxTreeExpandoIcon') &&
-					!domClass.contains(evt.target, 'gridxTreeExpandoInner')){
-					t._onUIBegin(evt);
-				}
-			});
-			t.connect(g.cellWidget, 'onCellWidgetCreated', '_onCellWidgetCreated');
-			t.connect(g.cellWidget, 'initializeCellWidget', function(widget, cell){
+			if(g.touch){
+				t.connect(g.bodyNode, tap.doubletap, function(evt){
+					var cellNode = query(evt.target).closest('.gridxCell', g.bodyNode);
+					var rowNode = cellNode.closest('.gridxRow', g.bodyNode)[0];
+					cellNode = cellNode[0];
+					if(rowNode && cellNode){
+						t._onUIBegin({
+							rowId: rowNode.getAttribute('rowid'),
+							columnId: cellNode.getAttribute('colid')
+						});
+					}
+				});
+				t.aspect(g, 'onCellTouchEnd', function(evt){
+					var col = g._columnsById[evt.columnId];
+					query('.gridxEditFocus', g.bodyNode).removeClass('gridxEditFocus');
+					if(col.alwaysEditing){
+						t._showButtons(evt.rowId, evt.columnId);
+					}
+				});
+			}else{
+				t.aspect(g, 'onCellDblClick', function(evt){
+					if(!domClass.contains(evt.target, 'gridxTreeExpandoIcon') &&
+						!domClass.contains(evt.target, 'gridxTreeExpandoInner')){
+						t._onUIBegin(evt);
+					}
+				});
+			}
+			t.aspect(g.cellWidget, 'onCellWidgetCreated', '_onCellWidgetCreated');
+			t.aspect(g.cellWidget, 'initializeCellWidget', function(widget, cell){
 				var column = cell.column;
 				if(column.initializeEditor && widget.gridCellEditField){
 					column.initializeEditor(widget.gridCellEditField, cell);
 				}
 			});
-			t.connect(g.cellWidget, 'uninitializeCellWidget', function(widget, cell){
+			t.aspect(g.cellWidget, 'uninitializeCellWidget', function(widget, cell){
 				var column = cell.column;
 				if(column.uninitializeEditor && widget.gridCellEditField){
 					column.uninitializeEditor(widget.gridCellEditField, cell);
 				}
 			});
-			t.connect(g.cellWidget, 'collectCellWidgetConnects', function(widget, output){
+			t.aspect(g.cellWidget, 'collectCellWidgetConnects', function(widget, output){
 				var column = widget.cell.column;
 				if(column.getEditorConnects){
 					var cnnts = column.getEditorConnects(widget, widget.cell);
 					output.push.apply(output, cnnts);
 				}
 			});
-			t.connect(g.body, 'onAfterRow', function(row){
+			t.aspect(g.body, 'onAfterRow', function(row){
 				query('.gridxCell', row.node()).forEach(function(node){
 					// var colid = node.getAttribute('colid');
 					if(g._columnsById[node.getAttribute('colid')].editable){
@@ -450,9 +472,11 @@ define([
 				});
 			});
 		},
-		
+
 		lazySave: false,
-		
+
+		//buttons: false,
+
 		load: function(){
 			//Must init focus after navigable cell, so that "edit" focus area will be on top of the "navigablecell" focus area.
 			this._initFocus();
@@ -604,6 +628,7 @@ define([
 							}
 						};
 					try{
+						v = (isNaN(v) && typeof v === 'number')? '' : v;
 						if(editorArgs && editorArgs.fromEditor){
 							v = editorArgs.fromEditor(v, widget.cell);
 						}else if(cell.column.storePattern){
@@ -768,23 +793,38 @@ define([
 			var t = this,
 				editor = widget.gridCellEditField;
 			if(editor){
-				if(column.alwaysEditing){
+				if(widget.btns){
+					function onOK(evt){
+						evt.stopPropagation();
+						widget.cell.applyEdit().then(function(success){
+							if(success){
+								domClass.remove(widget.btns, 'gridxEditFocus');
+								t.grid.body.onRender();
+								t._blur();
+							}
+						});
+					}
+					function onCancel(evt){
+						evt.stopPropagation();
+						widget.cell.cancelEdit().then(function(){
+							domClass.remove(widget.btns, 'gridxEditFocus');
+							t.grid.body.onRender();
+							t._blur();
+						});
+					}
+					widget.connect(widget.btnOK, 'onclick', onOK);
+					widget.connect(widget.btnOK, 'ontouchend', onOK);
+					widget.connect(widget.btnCancel, 'onclick', onCancel);
+					widget.connect(widget.btnCancel, 'ontouchend', onCancel);
+				}else if(column.alwaysEditing){
 					widget.connect(editor, 'onChange', function(){
-						var rn = widget.domNode.parentNode;
-						while(rn && !domClass.contains(rn, 'gridxRow')){
-							rn = rn.parentNode;
-						}
-						if(rn){
-							//TODO: is 500ms okay?
-							var delay = column.editorArgs && column.editorArgs.applyDelay || 500;
-							clearTimeout(editor._timeoutApply);
-							editor._timeoutApply = setTimeout(function(){
-								var rowId = rn.getAttribute('rowid');
-								t.apply(rowId, column.id).then(function(){
-									t._focusEditor(rowId, column.id);
-								});
-							}, delay);
-						}
+						var rowId = widget.cell.row.id;
+						//TODO: is 500ms okay?
+						var delay = column.editorArgs && column.editorArgs.applyDelay || 500;
+						clearTimeout(editor._timeoutApply);
+						editor._timeoutApply = setTimeout(function(){
+							t.apply(rowId, column.id);
+						}, delay);
 					});
 				}
 				if(column.onEditorCreated){
@@ -801,6 +841,24 @@ define([
 			}
 		},
 
+		_showButtons: function(rowId, colId){
+			var g = this.grid;
+			var alwaysEditing = g._columnsById[colId].alwaysEditing;
+			if(alwaysEditing){
+				query('.gridxEditFocus', g.bodyNode).removeClass('gridxEditFocus');
+				var cw = g.cellWidget.getCellWidget(rowId, colId);
+				if(cw && cw.btns){
+					domClass.add(cw.btns, 'gridxEditFocus');
+				}
+				g.body.onRender();
+			}
+		},
+
+		_hideButtons: function(){
+			query('.gridxEditFocus', this.grid.bodyNode).removeClass('gridxEditFocus');
+			this.grid.body.onRender();
+		},
+
 		_getDecorator: function(colId){
 			var className = this._getColumnEditor(colId),
 				p, properties,
@@ -824,15 +882,23 @@ define([
 			}else if(props && constraints){
 				props += ', ';
 			}
+			var t = this;
 			return function(){
-				return ["<div data-dojo-type='", className, "' ",
-						"data-dojo-attach-point='gridCellEditField' ",
-						"class='gridxCellEditor gridxHasGridCellValue ",
-						useGridData ? "" : "gridxUseStoreData",
-						"' data-dojo-props='",
-						props, constraints,
-						"'></div>"
-					].join('');
+				return [
+					t.arg('buttons') ?  ["<div class='gridxEditButtons ",
+						col.alwaysEditing ? 'gridxAlwaysEdit' : '',
+						"' data-dojo-attach-point='btns'>",
+						"<div tabindex='0' class='gridxEditOK' data-dojo-attach-point='btnOK'></div>",
+						"<div tabindex='0' class='gridxEditCancel' data-dojo-attach-point='btnCancel'></div>",
+					"</div>"].join('') : '',
+					"<div data-dojo-type='", className, "' ",
+					"data-dojo-attach-point='gridCellEditField' ",
+					"class='gridxCellEditor gridxHasGridCellValue ",
+					useGridData ? "" : "gridxUseStoreData",
+					"' data-dojo-props='",
+					props, constraints,
+					"'></div>"
+				].join('');
 			};
 		},
 
@@ -883,13 +949,23 @@ define([
 					onFocus: t._onFocus,
 					onBlur: t._onBlur,
 					connects: [
-						t.connect(g, 'onCellKeyDown', '_onKey'),
-						t.connect(t, '_focusEditor', '_focus')
+						t.aspect(g, 'onCellKeyDown', '_onKey'),
+						t.aspect(t, '_focusEditor', '_focus'),
+						t.aspect(g.focus, 'onFocusArea', function(area){
+							if(area == 'navigablecell'){
+								t._showButtons(g.navigableCell._focusRowId, g.navigableCell._focusColId);
+							}
+						}),
+						t.aspect(g.focus, 'onBlurArea', function(area){
+							if(area == 'navigablecell'){
+								t._hideButtons();
+							}
+						})
 					]
 				});
 			}else{
 				//If not keyboard support, at least single clicking on other cells should apply the changes.
-				t.connect(g, 'onCellMouseDown', function(e){
+				t.aspect(g, 'onCellMouseDown', function(e){
 					var cells = t._editingCells;
 					if(!cells[e.rowId] || !cells[e.rowId][e.columnId]){
 						t._applyAll();
@@ -928,7 +1004,7 @@ define([
 					colId: t._focusCellCol
 				});
 				var elems = a11y._getTabNavigable(cellNode);
-				if(evt && evt.target == (step < 0 ? elems.first : elems.last)){
+				if(evt && ((!elems.first && !elems.last) || evt.target == (step < 0 ? elems.first : elems.last))){
 					g.focus.stopEvent(evt);
 					var rowIndex = view.getRowInfo({
 							parentId: t.model.parentId(t._focusCellRow),
@@ -987,11 +1063,11 @@ define([
 				if(e.keyCode == keys.ENTER){
 					if(editing){
 						t.apply(e.rowId, e.columnId).then(function(success){
-							if(success){
-								t._blur();
-							}
 							if(col.alwaysEditing){
 								t._focusEditor(e.rowId, e.columnId);
+								t._showButtons(e.rowId, e.columnId);
+							}else if(success){
+								t._blur();
 							}
 						});
 					}else if(g.focus.currentArea() == 'body'){
@@ -1000,7 +1076,9 @@ define([
 						t._onUIBegin(e);
 					}
 				}else if(e.keyCode == keys.ESCAPE && editing){
+					g.focus.stopEvent(e);
 					t.cancel(e.rowId, e.columnId).then(lang.hitch(t, t._blur)).then(function(){
+						t._hideButtons();
 						g.focus.focusArea('body');
 					});
 				}else if(e.keyCode == 'Z'.charCodeAt(0) && ctrlKey){
@@ -1018,9 +1096,6 @@ define([
 					}
 				}
 			}
-//            if(t._editing && e.keyCode !== keys.TAB){
-//                e.stopPropagation();
-//            }
 		}
 		
 	});

data/app/assets/javascripts/gridx/modules/ExpandableColumn.js

@@ -0,0 +1,292 @@
+define([
+	"dojo/_base/declare",
+	"dojo/_base/array",
+	"dojo/_base/lang",
+	"dojo/_base/event",
+	"dojo/keys",
+	"dojo/aspect",
+	"dojo/query",
+	"dojo/string",
+	"dojo/dom-class",
+	"dojo/dom-construct",
+	"dojo/keys",
+	"../core/_Module",
+	"./HiddenColumns"
+], function(declare, array, lang, event, keys, aspect, query, string, domClass, domConstruct, keys, _Module, HiddenColumns, Sort, nls){
+
+	return declare(HiddenColumns, {
+		name: 'expandedColumn',
+		_parentCols: null,
+
+		required: ['header'],
+
+		preload: function(){
+			this.inherited(arguments);
+		},
+
+		load: function(args, startup){
+			var t = this,
+				g = t.grid;
+			t._cols = g._columns.slice();
+			t._parentCols = {};
+
+			var toHide = [];
+			array.forEach(t._cols, function(col){
+				if(col.expanded){
+					toHide.push(col.id);
+				}else if(col._parentColumn){
+					t._parentCols[col._parentColumn] = 1;
+					var parentCol = this._colById(col._parentColumn);
+
+					if(!parentCol.expanded){
+						toHide.push(col.id);
+						parentCol.expanded = false;	//Force expanded false for later use.
+					}else{
+					}
+				}
+			}, this);
+
+			this.expandoBar = domConstruct.create('div', {className: 'gridxColumnExpandoBar'});
+
+			this.connect(g.columnWidth, 'onUpdate', '_updateUI');
+			this.grid.vLayout.register(this, 'expandoBar', 'headerNode', 1);
+
+			this.connect(g, 'onHeaderCellMouseOver', function(evt){
+				domClass.add(this._expandoCellByColumnId(evt.columnId), 'gridxColumnExpandoHighlight');
+			}, this);
+
+			this.connect(g, 'onHeaderCellMouseOut', function(evt){
+				domClass.remove(this._expandoCellByColumnId(evt.columnId), 'gridxColumnExpandoHighlight');
+			}, this);
+
+			this.connect(this.expandoBar, 'onmouseover', function(evt){
+				var expandoCell = null;
+				if(/td/i.test(evt.target.tagName)){
+					expandoCell = evt.target;
+				}else if(domClass.contains(evt.target, 'gridxColumnExpando')){
+					expandoCell = evt.target.parentNode;
+				}
+				if(expandoCell){
+					var colId = expandoCell.getAttribute('data-column-id');
+					domClass.add(expandoCell, 'gridxColumnExpandoHighlight');
+					domClass.add(this._headerCellByColumnId(colId), 'gridxCellHighlight');
+				}
+			}, this);
+
+			this.connect(this.expandoBar, 'onmouseout', function(evt){
+				var expandoCell = null;
+				if(/td/i.test(evt.target.tagName)){
+					expandoCell = evt.target;
+				}else if(domClass.contains(evt.target, 'gridxColumnExpando')){
+					expandoCell = evt.target.parentNode;
+				}
+				if(expandoCell){
+					var colId = expandoCell.getAttribute('data-column-id');
+					domClass.remove(expandoCell, 'gridxColumnExpandoHighlight');
+					domClass.remove(this._headerCellByColumnId(colId), 'gridxCellHighlight');
+				}
+			}, this);
+
+			this.connect(this.expandBar, 'onclick', function(evt){
+				if(domClass.contains(evt.target, 'gridxColumnExpando')){
+					var colId = evt.target.parentNode.getAttribute('data-column-id');
+					this.expand(colId);
+				}
+			}, this);
+
+			this.connect(this.grid.header.innerNode, 'onkeyup', function(evt){
+				//Bind short cut key to expand/coallapse the column: shift + ctrl + e
+
+				if(evt.keyCode == 77 && evt.ctrlKey){
+					var node = evt.target;
+					if(domClass.contains(node, 'gridxGroupHeader')){
+						var colId = node.getAttribute('groupid').split('-').pop();
+						colId = this._colById(colId)._parentColumn;
+						this.collapse(colId);
+						this._focusById(colId);
+
+					}else if(domClass.contains(node, 'gridxCell')){
+						var colId = node.getAttribute('colid');
+						if(this._parentCols[colId]){
+							//expandable
+							this.expand(colId);
+							this._focusById(colId);
+						}
+					}
+					event.stop(evt);
+				}
+			}, this);
+
+			this.connect(this.grid, 'onHScroll', function(left){
+				this.expandoBar.scrollLeft = left;
+			}, this);
+
+			if(toHide.length){
+				startup.then(function(){
+					t.add.apply(t, toHide);
+					t._refreshHeader();
+					t.loaded.callback();
+				});
+			}else{
+				t.loaded.callback();
+			}
+		},
+
+		expand: function(colId){
+			var children = array.filter(this._cols, function(col){
+				return col._parentColumn == colId;
+			});
+			
+			this.add(colId);
+			this.remove.apply(this, children);
+			this._colById(colId).expanded = true;
+			this._refreshHeader();
+
+		},
+
+		collapse: function(colId){
+			var children = array.filter(this._cols, function(col){
+				return col._parentColumn == colId;
+			});
+
+			this.remove(colId);
+			this.add.apply(this, children);
+			this._colById(colId).expanded = false;
+			this._refreshHeader();
+		},
+
+		_updateUI: function(){
+			// summary:
+			//	Called when the header is changed, need to sync expando bar.
+
+			console.log('rebuilding column expando bar');
+			//Build expando bar
+			var sb = ['<table role="presentation" border="0" cellpadding="0" cellspacing="0"><tr>'];
+			array.forEach(this.grid._columns, function(col){
+				sb.push('<td data-column-id="', col.id,'" aria-readonly="true" tabindex="-1" class="gridxColumnExpandoCell">');
+				if(this._parentCols[col.id]){
+					//expandable
+					sb.push('<span class="gridxColumnExpando"></span>');
+				}
+				sb.push('</td>');
+			}, this);
+
+			sb.push('</tr></table>');
+			this.expandoBar.innerHTML = sb.join('');
+			this.expandoBar.style.marginRight = this.grid.header.innerNode.style.marginRight;
+			this.expandoBar.style.marginLeft = this.grid.header.innerNode.style.marginLeft;
+			//Adjust width of the expando cells
+			var headerCells = query('table', this.grid.headerNode)[0].rows[0].cells
+				,expandoCells = this.expandoBar.firstChild.rows[0].cells;
+
+			array.forEach(expandoCells, function(cell, i){
+				var colId = cell.getAttribute('data-column-id')
+					,col = this.grid._columnsById[colId];
+				cell.style.width = col.width;
+				cell.style.minWidth = col.width;
+				cell.style.maxWidth = col.width;
+			}, this);
+		},
+
+		_createExpandNode: function(i, col){
+			console.log('creating expand node for:', col.id);
+			var div = domConstruct.create('div', {innerHTML: '', className: 'gridxColumnExpandNode'});
+			if(this._parentCols[col.id]){
+				div.innerHTML = '<span class="gridxColumnExpandNodeIcon"></span>';
+				var self = this;
+				div.onclick = function(){
+					self.expand(col.id);
+				}
+			}else{
+				console.log(col.id, ' is not expandable');
+				div.innerHTML = '';
+			}
+			return div;
+		},
+
+		_headerCellByColumnId: function(colId){
+			var cell = query('td[colid="' + colId + '"]', this.grid.headerNode)[0];
+			if(!cell){
+				cell = query('td[data-map-column-id="' + colId + '"]', this.grid.headerNode)[0];
+			}
+			return cell;
+		},
+
+		_expandoCellByColumnId: function(colId){
+			return query('td[data-column-id="' + colId + '"]', this.expandoBar)[0];
+		},
+
+		_refreshHeader: function(){
+			var headerGroups = [],
+				cols = this.grid._columns,
+				currentGroup = null,
+				c = 0;
+
+			for(var i = 0; i < cols.length; i++){
+				var col = cols[i];
+				if(col._parentColumn){
+					//if column has parent
+					if(c > 0){
+						headerGroups.push(c);
+						c = 0;
+					}
+					if(!currentGroup || currentGroup._colId != col._parentColumn){
+						if(currentGroup && currentGroup._colId != col._parentColumn){
+							headerGroups.push(currentGroup);
+						}
+
+						currentGroup = {
+							_colId: col._parentColumn,
+							name: this._colById(col._parentColumn).name,
+							children: 0
+						};
+					}
+					currentGroup.children++;
+				}else{
+					if(currentGroup){
+						headerGroups.push(currentGroup);
+					}
+					c++;
+					currentGroup = null;
+				}
+			}
+			console.log('headerGroups: ', headerGroups);
+			delete this.grid.header.groups;
+			this.grid.headerGroups = headerGroups;
+			this.grid.header.refresh();
+
+			//add expand arrow the the group header
+			var self = this;
+			query('.gridxGroupHeader', this.grid.headerNode).forEach(function(td){
+				var colId = td.getAttribute('groupid').split('-').pop();
+				colId = self._colById(colId)._parentColumn;
+				td.setAttribute('data-map-column-id', colId);
+
+				var div = domConstruct.create('div', {
+					innerHTML: '<span class="gridxColumnCollapseNodeIcon"></span>', 
+					className: 'gridxColumnCollapseNode'});
+
+				div.onclick = function(){
+					self.collapse(colId);
+				}
+				td.firstChild.insertBefore(div, td.firstChild.firstChild);
+			});
+		},
+
+		_colById: function(id){
+			return this.grid._columnsById[id] || array.filter(this._cols, function(col){
+				return col.id == id;
+			})[0];
+		},
+
+		_focusById: function(colId){
+			// summary:
+			//	Focus the column header cell by column id
+
+			var headerCell = this._headerCellByColumnId(colId);
+			if(headerCell){
+				this.grid.header._focusNode(headerCell);
+			}
+		}
+	});
+});

data/app/assets/javascripts/gridx/modules/Filter.js

@@ -384,6 +384,20 @@ define([
 				}
 			}, "isEmpty", [expr]);
 		},
+		
+		//Is not Empty check
+		//Currently it will only appear in serverMode of filter for string-typed column
+		//It has no NLS, and it is not recommended to use if you need fully nls support
+		isNotEmpty: function(expr, notEmptyValues){
+			return wrap(function(){
+				var v = expr.apply(0, arguments);
+				if(notEmptyValues){
+					return array.indexOf(notEmptyValues, v) >= 0;
+				}else{
+					return v !== "" && v !== null && v !== undefined;
+				}
+			}, "isNotEmpty", [expr]);
+		},	
 
 		//Logic operations
 		and: function(/* filter expressions */){