https://jacarandahealth.org/syssuree/unlimited-elements-for-elemen…/filters/ue_filters.js?ver=2.0.20

1//UE Filters Version 1.27
2
3function UEDynamicFilters(){
4
5	var g_objFilters, g_filtersData, g_urlBase;
6	var g_urlAjax, g_lastGridAjaxCall, g_cache = {}, g_objBody;
7	var g_remote = null, g_lastSyncGrids, g_initFiltersCounter = 0;
8	
9	var t = this;
10	
11	var g_showDebug = false;
12	var g_debugInitMode = false;
13	
14	var g_debugBeforeRefreshMode = false;	//debug filters state before refresh
15	
16	var g_isGutenberg = false;
17	
18	var g_types = {
19		PAGINATION:"pagination",
20		LOADMORE:"loadmore",
21		TERMS_LIST:"terms_list",
22		SEARCH: "search",
23		SELECT: "select",
24		SUMMARY: "summary",
25		GENERAL: "general",
26		GENERAL_MOBILE_DRAWER: "mobilefilters"
27	};
28
29	var g_vars = {
30		CLASS_DIV_DEBUG:"uc-div-ajax-debug",
31		CLASS_GRID:"uc-filterable-grid",
32		CLASS_GRID_NOREFRESH:"uc-grid-norefresh",	//grid that will not refresh
33		DEBUG_AJAX_OPTIONS: false,
34		CLASS_CLICKED:"uc-clicked",
35		CLASS_HIDDEN: "uc-filter-hidden",	//don't refresh with this class
36		CLASS_INITING: "uc-filter-initing",
37		CLASS_INITING_HIDDEN: "uc-initing-filter-hidden",
38		CLASS_SKIP_REFRESH: "uc-filters-norefresh",		//on some grid parent
39		CLASS_REFRESH_SOON: "uc-ajax-refresh-soon",
40		EVENT_SET_HTML_ITEMS: "uc_ajax_sethtml",
41		CLASS_FILTER_INITED:"ucfilters--filter-inited",
42		ATTRIBUTE_URLADD:"ajaxurladd",
43		GRID_DATA_SKIP_HTML: "skip_set_html",
44		
45		//grid events
46
47		EVENT_BEFORE_REFRESH: "uc_before_ajax_refresh",	   //on grid
48		EVENT_AJAX_REFRESHED: "uc_ajax_refreshed",	   //on grid
49		EVENT_AJAX_REFRESHED_BODY: "uc_ajax_refreshed_body",	   //on body
50		EVENT_UPDATE_ACTIVE_FILTER_ITEMS: "update_active_filter_items",	   //on grid
51		EVENT_UNSELECT_FILTER: "uc_unselect_filter",   //on grid
52		EVENT_SILENT_FILTER_CHANGE: "uc_silent_filter_change",   //on grid
53
54		EVENT_DOM_UPDATED: "uc_dom_updated",   //on body
55
56		//events on filters
57
58		EVENT_INIT_FILTER:"init_filter",
59		EVENT_INIT_FILTER_TYPE:"init_filter_type",
60		EVENT_GET_FILTER_DATA:"get_filter_data",
61		EVENT_FILTER_RELOADED: "uc_ajax_reloaded",
62
63		//grid actions
64
65		ACTION_CLEAR_FILTERS: "clear_filters",	   //on grid
66		ACTION_REFRESH_GRID: "uc_refresh",	//listen on grid
67		ACTION_GET_FILTERS_URL: "uc_get_filters_url",	//listen on grid
68		ACTION_FILTER_CHANGE: "uc_filter_change",		//listen on grid
69		ACTION_FILTER_UNSELECT_BY_KEY: "unselect_by_key",	//listen on grid
70		
71		REFRESH_MODE_PAGINATION: "pagination",
72		REFRESH_MODE_LOADMORE: "loadmore",
73		trashold_handle:null,
74		class_widget_wrapper:"elementor-widget",
75		current_postid:null,
76		ucpage_url:null
77	};
78
79	var g_options = {
80		is_cache_enabled:true,
81		urlkey_taxsap:"~"
82	};
83	
84	/**
85	 * console log some string
86	 */
87	function trace(str){
88		console.log(str);
89	}
90
91	function ________GENERAL_______________(){}
92
93
94
95	/**
96	 * add url param
97	 */
98	function addUrlParam(url, param, value){
99
100		if(url){
101			if(url.indexOf("?") == -1)
102				url += "?";
103			else
104				url += "&";
105		}
106
107		if(typeof value == "undefined")
108			url += param;
109		else
110			url += param + "=" + value;
111
112		return(url);
113	}
114
115
116	/**
117	 * get object property
118	 */
119	function getVal(obj, name, defaultValue){
120
121		if(!defaultValue)
122			var defaultValue = "";
123
124		var val = "";
125
126		if(!obj || typeof obj != "object")
127			val = defaultValue;
128		else if(obj.hasOwnProperty(name) == false){
129			val = defaultValue;
130		}else{
131			val = obj[name];
132		}
133
134		return(val);
135	}
136
137	/**
138	 * turn string value ("true", "false") to string
139	 */
140	function strToBool(str){
141
142		switch(typeof str){
143			case "boolean":
144				return(str);
145			break;
146			case "undefined":
147				return(false);
148			break;
149			case "number":
150				if(str == 0)
151					return(false);
152				else
153					return(true);
154			break;
155			case "string":
156				str = str.toLowerCase();
157
158				if(str == "true" || str == "1")
159					return(true);
160				else
161					return(false);
162
163			break;
164		}
165
166		return(false);
167	};
168
169	/**
170	 * get offsets distance
171	 */
172	function getOffsetsDistance(offset1, offset2){
173
174	  var dx = offset2.left-offset1.left;
175	  var dy = offset2.top-offset1.top;
176
177	  return Math.sqrt(dx*dx+dy*dy);
178	}
179
180	/**
181	 * round number to one decimal
182	 */
183	function roundToOneDecimal(num) {
184	    if (num % 1 !== 0) {
185	        return num.toFixed(1); // Round to 1 decimal place
186	    } else {
187	        return num.toFixed(0); // Keep the whole number
188	    }
189	}
190
191
192	/**
193	 * get closest object by offset
194	 */
195	function getClosestByOffset(objParents, objElement, isVertical){
196
197		if(objParents.length == 0){
198			throw new Error("get closest by offset error - grids not found");
199		}
200
201		if(g_showDebug == true){
202
203			trace("get closest grids for");
204			trace(objElement)
205			trace("parents");
206			trace(objParents);
207		}
208
209		var objClosest = null;
210		var minDiff = 1000000;
211
212		var elementOffset = objElement.offset();
213
214		jQuery.each(objParents, function(index, parent){
215
216			var objParent = jQuery(parent);
217
218			var objGrid = jQuery(parent);	//return this one
219
220			var distance = 0;
221
222			var isVisible = objParent.is(":visible");
223			
224			var constantHeight = null;
225
226			if(isVisible == false){
227				objParent = objParent.parent();
228			}
229
230			var parentOffset = objParent.offset();
231
232			if(isVertical == true){
233
234				var offsetY = elementOffset.top;
235				var parentY = parentOffset.top;
236
237				//get bottom of the parent
238
239				if(parentY < offsetY)
240					parentY += objParent.height();
241
242				var distance = Math.abs(offsetY - parentY);
243
244			}else{
245
246				var parentOffset = objParent.offset();
247
248				var distance = getOffsetsDistance(parentOffset, elementOffset);
249			}
250
251			if(g_showDebug == true){
252
253				trace(objParent);
254				trace("distance: " + distance);
255
256				trace("is vertical: " + isVertical);
257			}
258
259			if(distance < minDiff){
260				minDiff = distance;
261				objClosest = objGrid;
262			}
263
264		});
265
266		if(g_showDebug == true){
267
268			trace("filter: ");
269			trace(objElement);
270
271			trace("Closest grid found:");
272			trace(objClosest);
273		}
274
275
276		return(objClosest);
277	}
278
279	/**
280	 * get all grids
281	 */
282	function getAllGrids(type){
283
284		if(type == "loaded_only")
285			var objGrids = jQuery("."+ g_vars.CLASS_GRID).not(".ucfilters--grid-inited");
286		else
287			var objGrids = jQuery("."+ g_vars.CLASS_GRID);
288
289		return(objGrids);
290	}
291
292
293  /**
294   * get grid from parents containers
295   */
296  function getGridFromParentContainers(objSource){
297
298    var objParents = objSource.parents();
299    var objGrid = null;
300
301    if(g_showDebug == true){
302
303		trace("get from parent containers");
304		trace(objParents);
305	}
306
307    objParents.each(function(){
308
309      var objParent = jQuery(this);
310
311      objGrid = objParent.find("."+ g_vars.CLASS_GRID);
312
313      //if grid found return it and exit loop
314      if(objGrid.length >= 1)
315        return(false);
316
317    });
318
319
320    return(objGrid);
321  }
322
323

324	/**
325	 * get closest grid to some object
326	 */
327	function getClosestGrid(objSource){
328
329		//in case there are nothing:
330		var objGrids = getAllGrids();
331
332		if(objGrids.length == 0)
333			return(null);
334
335		if(g_showDebug == true){
336
337			trace("get closest grids");
338			trace(objSource);
339			trace(objGrids);
340		}
341
342		//get grid from parents
343
344		if(objGrids.length == 1)
345			return(objGrids);
346
347		//narrow by group
348		var group = objSource.data("connectgroup");
349
350		if(group){
351			var objGridsGroup = objGrids.filter("[data-filtergroup="+group+"]");
352			
353			if(objGridsGroup.length > 0){
354
355				if(objGridsGroup.length == 1)
356					return(objGridsGroup);
357
358				objGrids = objGridsGroup;
359			}
360
361		}else{
362
363			//get from same container - if group not set
364
365		    var objGrid = getGridFromParentContainers(objSource);
366
367		    if(objGrid && objGrid.length == 1)
368		        return(objGrid);
369		}
370
371
372		//get closest by offset
373
374	    if(objGrid && objGrid.length > 1)
375	    	objGrids = objGrid;
376
377		var objSingleGrid = getClosestByOffset(objGrids, objSource, true);
378
379		if(objSingleGrid && objSingleGrid.length == 1)
380			return(objSingleGrid);
381
382		//return first grid in the list
383
384		var objFirstGrid = jQuery(objGrids[0]);
385
386		return(objFirstGrid);
387	}
388
389	
390	
391	/**
392	 * add filter object to grid
393	 */
394	function bindFilterToGrid(objGrid, objFilter){
395		
396		if(g_showDebug){
397			trace("bind filter to grid");
398			
399			trace(objFilter);
400		}
401		
402		var arrFilters = objGrid.data("filters");
403		var objTypes = objGrid.data("filter_types");
404
405		if(!arrFilters)
406			arrFilters = [];
407
408		if(!objTypes)
409			objTypes = {};
410
411		var type = getFilterType(objFilter);
412
413		//validate double types
414
415		if(objTypes.hasOwnProperty(type)){
416
417			switch(type){
418				case g_types.LOADMORE:
419
420					trace("Double filter not allowed");
421					trace("existing Filters:");
422					trace(arrFilters);
423
424					trace("Second Filter");
425					trace(objFilter);
426
427					trace("Grid:");
428					trace(objGrid);
429
430					showElementError(objFilter, "Double load more button for one grid not allowed")
431					return(false);
432				break;
433			}
434
435		}
436
437		objTypes[type] = true;
438
439		var filterID = objFilter.attr("id");
440
441		//handle sticky
442		
443		var objElementorStickySpacer = objFilter.closest(".elementor-sticky__spacer");
444		if(objElementorStickySpacer.length)
445			return(true);
446		
447		
448		//----- validate existing -----
449		
450		var objExistingFilter = arrFilters.filter(function(objFilterInArray){
451			return objFilterInArray.attr("id") == filterID;
452		});
453		
454		if(objExistingFilter && objExistingFilter.length)
455				throw new Error("Can't bind filter to grid, it's already exists: " + filterID);			
456		
457		arrFilters.push(objFilter);
458
459		//add init after filters
460		var isInitAfter = objFilter.data("initafter");
461				
462		if(!isInitAfter)
463			isInitAfter = isSpecialFilterInitAfter(objFilter, objGrid);
464		
465		if(g_showDebug){
466			trace("init after: "+isInitAfter);
467		}
468				
469		if(isInitAfter === true){
470			addFilterToInitAfter(objFilter, objGrid);
471		}
472		
473		objGrid.data("filters", arrFilters);
474		
475		objGrid.data("filter_types", objTypes);
476
477	}
478
479	/**
480	 *
481	 * get element widget id from parent wrapper
482	 */
483	function getElementWidgetID(objElement){
484		
485		if (!objElement || objElement.length === 0)
486			throw new Error("Element not found");
487				
488		var objWidget = objElement.closest("."+g_vars.class_widget_wrapper);
489
490		if (objWidget.length === 0)
491			throw new Error("Element parent not found with class: "+g_vars.class_widget_wrapper);
492		
493		var widgetID = objWidget.data("id");
494
495		if (!widgetID)
496			throw new Error("widget id not found");
497
498		return widgetID;
499	}
500	
501
502	/**
503	 * get the grid widget object from elementor element id
504	 */
505	function getGridFromElementorElementID(elementID, group, showDebug){
506		
507		var selector = "."+g_vars.class_widget_wrapper+"[data-id='"+elementID+"']";
508		
509		var objElement = g_objBody.find(selector);
510		
511		if(showDebug == true){
512			trace("selector: "+selector);
513			trace("element: ");
514			trace(objElement);
515		}
516		
517		if(objElement.length == 0)
518			return(null);
519		
520		var selectorGrid = "."+g_vars.CLASS_GRID;
521		
522		var objGrid = objElement.find(selectorGrid);
523
524		if(showDebug == true){
525			trace("selector grid: "+selectorGrid);
526			trace("grid: ");
527			trace(objGrid);
528		}
529		
530		if(objGrid.length == 1)
531			return(objGrid);
532		
533		if(objGrid.length == 0)
534			return(null);
535
536		//more then one, filter by group
537		if(group){
538			objGrid = objGrid.filter("[data-filtergroup="+group+"]");
539		}
540
541		if(showDebug == true){
542			trace("after group filter: "+group);
543			trace(objGrid);
544		}
545		
546		if(objGrid.length != 1)
547			return(null);
548		
549		
550		return(objGrid);
551	}
552	
553	
554
555	/**
556	 * get another group widgets
557	 */
558	function getGroupWidgets(arrSyncedGrids, objElement){
559
560		var group = objElement.data("filtergroup");
561
562		if(!group)
563			return(arrSyncedGrids);
564
565		var objGrids = jQuery("."+ g_vars.CLASS_GRID);
566
567		if(objGrids.length < 2)
568			return(arrSyncedGrids);
569
570		var elementID = objElement.attr("id");
571
572		var objDataGrids = objGrids.filter("[data-filtergroup='"+group+"']:not(#" + elementID + ")");
573
574		if(objDataGrids.length == 0)
575			return(arrSyncedGrids);
576
577		jQuery.each(objDataGrids, function(index, grid){
578
579			var objGrid = jQuery(grid);
580
581			arrSyncedGrids.push(objGrid);
582		});
583
584
585
586		return(arrSyncedGrids);
587	}
588
589	/**
590	 * get synced widget IDs
591	 */
592	function getSyncedWidgetData(objElement){
593
594		var arrSyncedGrids = [];
595
596		if(g_remote)
597			arrSyncedGrids = g_remote.getSyncedElements(objElement);
598
599		if(!arrSyncedGrids)
600			arrSyncedGrids = [];
601
602		arrSyncedGrids = getGroupWidgets(arrSyncedGrids, objElement);
603
604		if(!arrSyncedGrids || arrSyncedGrids.length == 0)
605			return(false);
606
607		var arrWidgetIDs = [];
608
609		var objGrids = null;
610
611		for(var index in arrSyncedGrids){
612
613			var objGrid = arrSyncedGrids[index];
614
615			if(objGrid.hasClass(g_vars.CLASS_GRID) == false){
616
617				var message = "Please enable ajax on all synced widgets";
618				var message2 = "Please enable ajax on this synced widget, it's missing class: "+g_vars.CLASS_GRID;
619
620				showElementError(objGrid, message2);
621
622				showAjaxError(message);
623				throw new Error(message);
624				return(false);
625			}
626
627			var objWidgetID = getElementWidgetID(objGrid);
628
629			//add to jquery collection
630
631			if(!objGrids)
632				objGrids = objGrid;
633			else
634				objGrids = objGrids.add(objGrid);
635
636			arrWidgetIDs.push(objWidgetID);
637		}
638
639		var strWidgetIDs = arrWidgetIDs.toString();
640
641		var objOutput = {};
642		objOutput["ids"] = strWidgetIDs;
643		objOutput["grids"] = objGrids;
644
645		return(objOutput);
646	}
647
648
649	/**
650	 * get element layout data
651	 */
652	function getElementLayoutData(objElement, addSyncedGrids){
653		
654		//get widget id
655		var widgetID = getElementWidgetID(objElement);
656		var objWidget = objElement.parents("."+g_vars.class_widget_wrapper);
657
658		//get synced grids
659		var objSyncedData = null;
660

661		//add sync if allowed and available
662
663		if(addSyncedGrids){
664
665			var objSyncedData = getSyncedWidgetData(objElement);
666
667			if(g_showDebug && objSyncedData){
668
669				trace("sync data");
670				trace(objSyncedData);
671			}
672		}else{
673
674			if(g_showDebug)
675				trace("skip sync grid");
676
677		}
678		
679		//get layout id
680		
681		if(g_isGutenberg == false){
682		
683			var objLayout = objWidget.parents(".elementor");
684	
685			if(objLayout.length == 0)
686				throw new Error("layout not found");
687			
688			var layoutID = objLayout.data("elementor-id");
689	
690			if(!layoutID)
691				layoutID = objLayout.data("id");
692			
693		}else{	//gutenberg
694			
695			var layoutID = g_vars.current_postid;			
696		}
697		
698		
699		var output = {};
700
701		output["widgetid"] = widgetID;
702		output["layoutid"] = layoutID;
703
704		if(objSyncedData){
705			output["synced_widgetids"] = objSyncedData["ids"];
706			output["synced_grids"] = objSyncedData["grids"];
707		}
708
709		return(output);
710	}
711
712	/**
713	 * show element error above it
714	 */
715	function showElementError(objElement, error){
716
717		var objParent = objElement.parent();
718		
719		if(g_showDebug == true){
720			trace("Show Error Message for: ");
721			trace(objElement);
722			trace(error);
723		}
724		
725		var objError = objParent.find(".uc-filers-error-message");
726		if(objError.length == 0){
727			objParent.append("<div class='uc-filers-error-message' style='color:red;position:absolute;top:-24px;left:0px;background-color:rgba(230, 230, 230, 0.8);padding:3px;font-size:12px;border:5px solid white;'></div>");
728			var objError = objParent.find(".uc-filers-error-message");
729			objParent.css("border","1px solid red !important");
730		}
731		
732		objError.append(error);
733
734		objError.css("top",-objError.height()-5);
735		
736	}
737
738	/**
739	 * get grid empty message
740	 */
741	function getGridEmptyMessage(objGrid){
742
743		var gridID = objGrid.attr("id");
744
745		if(!gridID)
746			return(null);
747
748		var objEmptyMessage = jQuery("#"+gridID+"_empty_message");
749
750		if(objEmptyMessage.length == 0)
751			return(null);
752
753		return(objEmptyMessage);
754	}
755
756	/**
757	 * get active filter items, if no items - return 0
758	 */
759	function getGridActiveFilterItems(objGrid){
760		
761		var arrActiveItems = objGrid.data("active_filters_items");
762
763		if(!arrActiveItems)
764			return(null);
765
766		if(arrActiveItems.length == 0)
767			return(null);
768
769		return(arrActiveItems);
770	}
771
772
773	/**
774	 * get filters that are selected
775	 */
776	function getSelectedFilters(objFilters, roleArg){
777
778		if(!objFilters)
779			var objFilters = objGrid.data("filters");
780
781		if(!objFilters)
782			return(false);
783
784		var arrSelectedFilters = [];
785
786		jQuery.each(objFilters, function(index, filter){
787
788			var objFilter = jQuery(filter);
789			var isSelected = objFilter.hasClass("uc-has-selected");
790
791			if(!roleArg && isSelected == true){
792				arrSelectedFilters.push(objFilter);
793				return(true);
794			}
795
796			var role = objFilter.data("role");
797
798			if(role == roleArg){
799				var isSelected = objFilter.hasClass("uc-has-selected");
800				if(isSelected)
801					arrSelectedFilters.push(objFilter);
802			}
803
804		});
805
806		return(arrSelectedFilters);
807	}
808
809
810	function ________FILTERS_______________(){}
811
812
813	/**
814	 * get the parent
815	 */
816	function getFiltersParent(objFilters){
817
818		//init the events
819		var objParent = objFilters.parents(".elementor");
820
821		if(objFilters.length > 1 && objParent.length > 1)
822			objParent = objFilters.parents("body");
823
824		if(objParent.length > 1){
825			objParent = jQuery(objParent[0]);
826		}
827
828		if(objParent.length == 0)
829			objParent = objFilters.parents("body");
830
831		return(objParent);
832	}
833	
834	/**
835	 * get filter wrapper
836	 */
837	function getFilterWrapper(objFilter){
838		
839		var objParent = objFilter.parent();		
840		
841		if(objParent.hasClass("uc-checkbox-filter-accordion-container"))
842			objParent = objParent.parent();
843		
844		return(objParent);
845	}
846
847	
848	/**
849	 * get filter type
850	 */
851	function getFilterType(objFilter, getGeneralType){
852		
853		if(objFilter.hasClass("uc-filter-pagination"))
854			return(g_types.PAGINATION);
855
856		if(objFilter.hasClass("uc-filter-load-more"))
857			return(g_types.LOADMORE);
858
859		var filterType = objFilter.data("filtertype")
860
861		if(filterType == g_types.GENERAL && getGeneralType === true){
862			
863			var generalType = objFilter.data("generaltype");
864			return(generalType);
865		}
866		
867		if(filterType)
868			return(filterType);
869		
870		//if not found - throw error
871		
872		trace("Filter type not found: ");
873		trace(objFilter);
874		
875		throw new Error("wrong filter type");
876		
877	}
878
879
880	/**
881	 * clear all filters
882	 */
883	function clearAllFilters(objGrid){
884		

885		clearChildFilters(objGrid, null, true, null, true);
886	}
887
888	/**
889	 * get grid filters or null
890	 */
891	function getGridFilters(objGrid){
892
893		var objFilters = objGrid.data("filters");
894
895		if(!objFilters)
896			return(null);
897
898		if(objFilters.length == 0)
899			return(null);
900
901		return(objFilters);
902	}
903
904
905	/**
906	 * clear non main grid filters
907	 * hide children and just clear the main filters
908	 */
909	function clearChildFilters(objGrid, objCurrentFilter, isHideChildren, termID, isClearAll){
910		
911		var objFilters = getGridFilters(objGrid);
912		
913		if(!objFilters)
914			return(false);
915
916		var currentFilterID = null;
917
918		if(objCurrentFilter)
919			var currentFilterID = objCurrentFilter.attr("id");
920						
921		jQuery.each(objFilters, function(index, filter){
922						
923			var objFilter = jQuery(filter);
924			var filterID = objFilter.attr("id");
925
926			if(filterID == currentFilterID)
927				return(true);
928
929			var role = objFilter.data("role");
930			
931			//clear all others if that option selected
932			
933			if(role != "child" && role != "main" && role != "term_child"){
934				
935				if(isClearAll == true){
936					clearFilter(objFilter);
937				}
938				
939				return(true);
940			}
941
942			var isHide = false;

943			var isShow = false;
944
945			switch(role){
946				case "term_child":
947					if(isHideChildren == true)
948						isHide = true;
949
950					var linkedTermID = objFilter.data("childterm");
951
952					if(linkedTermID == termID){		//show the filter
953
954						objFilter.removeClass(g_vars.CLASS_HIDDEN);
955						objFilter.removeClass(g_vars.CLASS_INITING);
956						objFilter.removeClass(g_vars.CLASS_INITING_HIDDEN);
957					}else{
958						isHide = true;
959					}
960
961				break;
962				case "child":
963
964					if(isHideChildren == true)
965						isHide = true;
966					else{
967						//hide the filters and refresh
968
969						objFilter.removeClass(g_vars.CLASS_HIDDEN);
970
971						objFilter.addClass(g_vars.CLASS_INITING);
972						objFilter.addClass(g_vars.CLASS_INITING_HIDDEN);
973
974					}
975
976				break;
977				default:
978					
979					if(isClearAll == true){
980						clearFilter(objFilter);
981					}
982					
983					return(true);
984				break;
985			}
986
987			//hide the child filters and not refresh
988
989			if(isHide == true)
990				objFilter.addClass(g_vars.CLASS_HIDDEN);
991			
992			clearFilter(objFilter);
993
994		});
995
996	}
997
998	/**
999	 * clear some filter
1000	 */
1001	function clearFilter(objFilter){
1002		
1003		var type = getFilterType(objFilter);
1004
1005		switch(type){
1006			case g_types.TERMS_LIST:
1007				var objSelectedItems = objFilter.find(".ue_taxonomy_item.uc-selected");
1008				objSelectedItems.removeClass("uc-selected");
1009
1010				var objAll = objFilter.find(".ue_taxonomy_item.uc-item-all");
1011				objAll.addClass("uc-selected");
1012
1013			break;
1014			case g_types.SELECT:
1015				
1016				var objSelect = objFilter.find("select");
1017				objSelect.val("");
1018				
1019				//must leave one selected
1020				var objSelected = objFilter.find("option:selected");
1021				
1022				if(objSelected.length == 0)
1023					objFilter.find("option:first-child").prop("selected","selected");
1024				
1025			break;
1026			default:
1027			case g_types.SEARCH:
1028			case g_types.GENERAL:
1029				objFilter.trigger("clear_filter");
1030			break;
1031		}
1032
1033	}
1034
1035	/**
1036	 * unselect filter item
1037	 */
1038	function unselectFilterItem(objGrid, key){
1039
1040		var objFilters = getGridFilters(objGrid);
1041
1042		if(!objFilters)
1043			return(false);
1044		
1045		jQuery.each(objFilters, function(index, filter){
1046
1047			var objFilter = jQuery(filter);
1048			
1049			objFilter.trigger(g_vars.ACTION_FILTER_UNSELECT_BY_KEY, [key]);
1050			
1051		});
1052
1053	}
1054
1055	/**
1056	 * return true if the filter skip's it's action - like under mobile drawer
1057	 */
1058	function isFilterSkipAction(objFilter){
1059
1060		var objParentSkipRefresh = objFilter.parents("." + g_vars.CLASS_SKIP_REFRESH);
1061		
1062		if(objParentSkipRefresh.length)
1063			return(true);
1064
1065		return(false);
1066	}
1067	
1068	/**
1069	 * return if the grid has some child filters
1070	 */
1071	function hasChildFilters(objGrid){
1072		
1073		var objFilters = getGridFilters(objGrid);
1074		
1075		if(!objFilters)
1076			return(false);
1077		
1078		for(var index in objFilters){
1079			
1080			var objFilter = objFilters[index];
1081			var role = objFilter.data("role");
1082			if(role == "child")
1083				return(true);
1084		}
1085		
1086		return(false);
1087	}
1088	
1089	/**
1090	 * check and trigger skip action to the grid if needed 
1091	 * run before the refresh on some filter click
1092	 * for the mobile drawer (off canvas)
1093	 */
1094	function checkTriggerSkipAction(objFilter, objGrid){
1095		
1096		var isSkipAction = isFilterSkipAction(objFilter);
1097		if(isSkipAction == false)
1098			return(false);
1099		
1100		if(g_showDebug == true)
1101			trace("skip refresh - silent change triggered");
1102		
1103		var filterRole = objFilter.data("role");
1104		
1105		objGrid.trigger(g_vars.EVENT_SILENT_FILTER_CHANGE);
1106		
1107		initGrid_setActiveFiltersData(objGrid);
1108		
1109		//refresh children only main / children available
1110		if(filterRole == "main" && hasChildFilters(objGrid)){
1111			
1112			if(g_showDebug == true)
1113				trace("refresh children only");
1114			
1115			objGrid.data(g_vars.GRID_DATA_SKIP_HTML, true);
1116			refreshAjaxGrid(objGrid);
1117		}
1118		
1119		
1120		return(true);
1121	}
1122	
1123	function ________PAGINATION_FILTER______(){}
1124
1125
1126	/**
1127	 * get pagination selected url or null if is current
1128	 */
1129	function getPaginationSelectedData(objPagination){
1130				
1131		var objCurrentLink = objPagination.find("a.current,span.current");
1132			
1133		if(objCurrentLink.length == 0)
1134			return(null);
1135
1136		var url = objCurrentLink.attr("href");
1137				
1138		var numPage = objCurrentLink.text();
1139		
1140		if(jQuery.isNumeric(numPage) == false)
1141			numPage = null;
1142
1143		numPage = Number(numPage);
1144
1145		if(numPage === 1)
1146			numPage = null;
1147
1148		var output = {};
1149		output["url"] = url;
1150		output["page"] = numPage;
1151
1152		return(output);
1153	}
1154
1155
1156	/**
1157	 * on ajax pagination click
1158	 */
1159	function onAjaxPaginationLinkClick(event){
1160		
1161		var objLink = jQuery(this);
1162		
1163		//if no grid attached - act like a regular link
1164		
1165		var objPagination = objLink.parents(".uc-filter-pagination");
1166		
1167		var objGrid = objPagination.data("grid");
1168		
1169		if(!objGrid || objGrid.length == 0 || objPagination.hasClass("uc-no-ajax")){
1170						
1171			return(true);
1172		}
1173		

1174		//run the ajax, prevent default
1175		event.preventDefault();
1176		
1177		var objLinkCurrent = objPagination.find(".current");
1178
1179		
1180		//on next button click
1181
1182		if(objLink.hasClass("next")){
1183
1184			var nextLink = objLinkCurrent.next();
1185
1186			var objNextLink = jQuery(nextLink);
1187
1188			objNextLink.trigger("click");
1189
1190			return(false);
1191		}
1192
1193
1194		//on prev button click
1195
1196		if(objLink.hasClass("prev")){
1197
1198			var prevLink = objLinkCurrent.prev();
1199
1200			var objPrevLink = jQuery(prevLink);
1201
1202			objPrevLink.trigger("click");
1203
1204			return(false);
1205		}
1206
1207		objLinkCurrent.removeClass("current");
1208
1209		objLink.addClass("current");
1210
1211		var objGrid = objPagination.data("grid");
1212		
1213		objPagination.addClass(g_vars.CLASS_CLICKED);
1214
1215		if(g_showDebug == true){
1216
1217			trace("click on pagination!!!, no grid refresh");
1218			trace(objLink);
1219
1220		}else{
1221
1222			refreshAjaxGrid(objGrid, g_vars.REFRESH_MODE_PAGINATION);
1223
1224		}
1225
1226		return(false);
1227	}
1228
1229
1230	function ________LOAD_MORE_______________(){}
1231
1232
1233	/**
1234	 * get current load more page
1235	 */
1236	function getLoadMoreUrlData(objFilter){
1237
1238		var objData = objFilter.find(".uc-filter-load-more__data");
1239
1240		var nextOffset = objData.data("nextoffset");
1241		if(!nextOffset)
1242			nextOffset = null;
1243
1244		var numItems = objFilter.data("numitems");
1245
1246		if(!numItems)
1247			numItems = null;
1248
1249		//affect only single grids
1250
1251		var isSingleGridOnly = objFilter.data("affect_single_grid");
1252
1253
1254		var data = {};
1255		data.offset = nextOffset;
1256		data.numItems = numItems;
1257		data.singlegrid = isSingleGridOnly;
1258
1259		return(data);
1260	}
1261
1262
1263	/**
1264	 * do the load more operation
1265	 */
1266	function onLoadMoreClick(){
1267
1268		var objLink = jQuery(this);
1269
1270		var objLoadMore = objLink.parents(".uc-filter-load-more");
1271
1272		var objData = objLoadMore.find(".uc-filter-load-more__data");
1273
1274		var isMore = objData.data("more");
1275
1276		if(isMore == false)
1277			return(false);
1278
1279		var objGrid = objLoadMore.data("grid");
1280
1281		if(!objGrid || objGrid.length == 0)
1282			throw new Error("Grid not found!");
1283
1284		//run the ajax, prevent default
1285
1286		objLoadMore.addClass(g_vars.CLASS_CLICKED);
1287
1288		refreshAjaxGrid(objGrid, g_vars.REFRESH_MODE_LOADMORE);
1289
1290	}
1291
1292	function ________SELECT_______________(){}
1293
1294	/**
1295	 * init select filter, select the selected item (avoid cache)
1296	 */
1297	function initSelectFilter(objFilter){
1298		
1299		var objSelected = objFilter.find(".uc-selected");
1300
1301		if(objSelected.length == 0)
1302			return(false);
1303
1304		var value = objSelected.attr("value");
1305
1306		var objSelect = objFilter.find("select");
1307
1308		objSelect.val(value);
1309
1310	}
1311
1312
1313	function ________TERMS_LIST_______________(){}
1314
1315	/**
1316	 * unselect by key terms list and select
1317	 */
1318	function termsFilterUnselectByKey(event,key){
1319				
1320		var objFilter = jQuery(this);
1321		
1322		var selectedTerm = getTermsListSelectedTerm(objFilter);
1323		
1324		if(!selectedTerm)
1325			return(false);
1326		
1327		var selectedKey = getVal(selectedTerm,"key");
1328		
1329		if(selectedKey != key)
1330			return(false);
1331		
1332		//if key match - clear filter and set no refresh.
1333
1334		clearFilter(objFilter);	
1335		
1336		setNoRefreshFilter(objFilter);
1337	}
1338
1339
1340	/**
1341	 * on terms list click
1342	 */
1343	function onTermsLinkClick(event){
1344		
1345		var className = "uc-selected";
1346
1347		event.preventDefault();
1348
1349		var objLink = jQuery(this);
1350 
1351		if(objLink.hasClass("uc-grid-filter")){
1352
1353			var objTermsFilter = objLink;
1354
1355		}else{
1356
1357			var objTermsFilter = objLink.parents(".uc-grid-filter");
1358		}
1359
1360		var filterType = getFilterType(objTermsFilter);
1361
1362		if(filterType == g_types.SELECT){
1363
1364			var objLink = objTermsFilter.find("option:selected");
1365		}
1366
1367		if(filterType == g_types.TERMS_LIST){
1368
1369			var objActiveLinks = objLink.siblings("."+className).not(objLink);
1370
1371			objActiveLinks.removeClass(className);
1372			objLink.addClass(className);
1373
1374		}
1375
1376		var objGrid = objTermsFilter.data("grid");
1377
1378		if(!objGrid || objGrid.length == 0)
1379			throw new Error("Grid not found");
1380
1381		//if main filter - clear other filters
1382
1383		var filterRole = objTermsFilter.data("role");
1384
1385		var termID = objLink.data("id");
1386
1387		//set refresh - if all and there are hidden items - refresh
1388		var isRefresh = false;
1389
1390		if(!termID){
1391			var objHiddenItems = objTermsFilter.find(".uc-item-hidden");
1392			if(objHiddenItems.length)
1393				isRefresh = true;
1394		}
1395
1396		var isHideChildren = false;

1397		if(!termID)
1398			isHideChildren = true;
1399		
1400		//set not refresh next iteration, because of the clicked
1401		if(isRefresh == false)
1402			setNoRefreshFilter(objTermsFilter);
1403
1404		if(filterRole == "main")
1405			clearChildFilters(objGrid, objTermsFilter, isHideChildren, termID);
1406
1407		//skip action
1408		
1409		var isSkipAction = checkTriggerSkipAction(objTermsFilter, objGrid);
1410		
1411		if(isSkipAction == true)
1412			return(false);
1413		
1414		
1415		if(g_showDebug == true){
1416			trace("refresh grid - on term click");
1417		}
1418		
1419		//refresh grid
1420		refreshAjaxGrid(objGrid);
1421
1422	}
1423
1424
1425	/**
1426	 * get terms list term id
1427	 */
1428	function getTermsListSelectedTerm(objFilter){
1429
1430		if(!objFilter)
1431			return(null);
1432
1433		var filterType = getFilterType(objFilter);
1434
1435		var objSelected = objFilter.find(".uc-selected");
1436
1437		if(filterType == g_types.SELECT){
1438
1439			var objSelected = objFilter.find("option:selected");
1440
1441		}else{
1442
1443			var objSelected = objFilter.find(".uc-selected");
1444		}
1445
1446		if(objSelected.length == 0){
1447
1448			if(g_showDebug == true){
1449				trace("no selected found, skipping...");
1450			}
1451
1452			return(null);
1453		}
1454
1455		//check for hidden
1456
1457		if(filterType == g_types.TERMS_LIST && objSelected.hasClass("uc-item-hidden") == true){
1458
1459			if(g_showDebug == true){
1460
1461				trace("the selected object");
1462				trace(objSelected);
1463				trace("the term is hidden, skipping...");
1464
1465			}
1466
1467			return(null);
1468		}
1469
1470		if(objSelected.length > 1)
1471			objSelected = jQuery(objSelected[0]);
1472
1473		var objTerm = getFilterElementData(objSelected);
1474
1475		return(objTerm);
1476	}
1477
1478	/**
1479	 * select items in terms list by terms
1480	 */
1481	function termListSelectItems(objFilter, arrTerms){
1482
1483		//deselect
1484		var objSelected = objFilter.find(".uc-selected");
1485
1486		objSelected.removeClass("uc-selected");
1487
1488		//select by term
1489
1490		jQuery.each(arrTerms, function(index, term){
1491
1492			var termID = getVal(term,"id");
1493			var objItem = objFilter.find("a.ue_taxonomy_item[data-id='"+termID+"']");
1494
1495			if(objItem.length == 0)
1496				return(true);
1497
1498			objItem.addClass("uc-selected");
1499		});
1500
1501
1502	}
1503
1504	function ________GENERAL_FILTER_______________(){}
1505
1506	/**
1507	 * init general filter
1508	 */
1509	function initGeneralFilter(objFilter){
1510		
1511		objFilter.on(g_vars.ACTION_FILTER_CHANGE, onGeneralFilterChange);
1512
1513	}
1514
1515
1516
1517	/**
1518	 * on general filter change
1519	 */
1520	function onGeneralFilterChange(event, params){
1521			
1522		event.stopPropagation();
1523
1524		var isRefresh = getVal(params, "refresh");
1525
1526		var objFilter = jQuery(this);
1527		
1528		var filterType = objFilter.data("filtertype");
1529
1530		if(filterType != "general"){
1531			
1532			trace(objFilter);
1533
1534			throw new Error("Not a general filter on action: " + g_vars.ACTION_FILTER_CHANGE);
1535			return(false);
1536		}
1537				
1538		if(isRefresh !== true)
1539			setNoRefreshFilter(objFilter);
1540
1541		var objGrid = objFilter.data("grid");
1542
1543		if(!objGrid || objGrid.length == 0){
1544
1545			trace(objGrid);
1546
1547			throw new Error("Wrong filter change");
1548			return(false);
1549		}
1550		
1551		var filterRole = objFilter.data("role");
1552		
1553		if(filterRole == "main"){
1554			
1555			var isHideChildren = false;
1556			
1557			//if no items selected - hide all children			
1558			var objData = getGeneralFilterData(objFilter);
1559			if(!objData)
1560				isHideChildren = true;
1561			
1562			clearChildFilters(objGrid, objFilter, isHideChildren);
1563		}
1564		
1565		//check for skip action
1566
1567		var isSkipAction = checkTriggerSkipAction(objFilter, objGrid);
1568		
1569		if(isSkipAction == true)
1570			return(false);
1571
1572
1573		if(g_showDebug == true){
1574
1575			trace("refresh grid - on general filter change");
1576			trace(objFilter);
1577
1578		}
1579		
1580		refreshAjaxGrid(objGrid);
1581
1582		return(false);
1583	}
1584
1585
1586	/**
1587	 * select filter items by terms, without refresh, just set selected
1588	 */
1589	function selectFilterItemsByTerms(objFilters, arrTerms){
1590
1591		if(!objFilters || objFilters.length == 0)
1592			return(false);
1593
1594		if(!arrTerms || arrTerms.length == 0)
1595			return(false);
1596		
1597		jQuery.each(objFilters,function(index, filter){
1598
1599			var objFilter = jQuery(filter);
1600
1601			selectFilterItems(objFilter, arrTerms);
1602
1603		});
1604
1605	}
1606
1607	/**
1608	 * select filter items
1609	 */
1610	function selectFilterItems(objFilter, arrTerms){
1611
1612		var type = getFilterType(objFilter);
1613
1614		switch(type){
1615			//case g_types.SELECT:
1616			case g_types.TERMS_LIST:
1617
1618				termListSelectItems(objFilter, arrTerms);
1619
1620			break;
1621			case g_types.GENERAL:
1622
1623				objFilter.trigger("uc_select_items", arrTerms);
1624
1625			break;
1626		}
1627
1628	}
1629

1630	/**
1631	 * get filter data
1632	 */
1633	function getGeneralFilterData(objFilter){
1634		
1635		var filterDataObj = {};
1636		objFilter.trigger(g_vars.EVENT_GET_FILTER_DATA, filterDataObj);
1637		
1638		var filterData = getVal(filterDataObj, "output");
1639		
1640		return(filterData);
1641	}
1642
1643
1644	function ________INIT_FILTERS_______________(){}
1645
1646	/**
1647	 * init terms related filer (terms list and select)
1648	 */
1649	function initTermsRelatedFilter(objFilter){
1650		
1651		objFilter.on(g_vars.ACTION_FILTER_UNSELECT_BY_KEY, termsFilterUnselectByKey);
1652
1653	}
1654
1655
1656	/**
1657	 * get filter taxonomy id's
1658	 */
1659	function getFilterTaxIDs(objFilter, objIDs){
1660
1661		var type = getFilterType(objFilter);
1662
1663		//skip the if
1664		if(type == g_types.SELECT)
1665			var objItems = objFilter.find(".uc-select-filter__option");
1666		else
1667			var objItems = objFilter.find(".ue_taxonomy_item");
1668
1669		if(objItems.length == 0)
1670			return(objIDs);
1671
1672		jQuery.each(objItems, function(index, item){
1673
1674			var objItem = jQuery(item);
1675			var taxID = objItem.data("id");
1676
1677			if(!taxID)
1678				return(true);
1679
1680			objIDs[taxID] = true;
1681		});
1682
1683
1684		return(objIDs);
1685	}
1686
1687	/**
1688	 * get tax id's list string from assoc object
1689	 */
1690	function getTermDsList(objIDs){
1691
1692		var strIDs = "";
1693		for(var id in objIDs){
1694
1695			if(jQuery.isNumeric(id) == false)
1696				continue;
1697
1698			if(strIDs)
1699				strIDs += ",";
1700
1701			strIDs += id;
1702		}
1703
1704		return(strIDs);
1705	}
1706
1707
1708	function ________DATA_______________(){}
1709
1710
1711	/**
1712	 * map meta compare operator to URL word, empty for equals
1713	 */
1714	function getMetaCompareUrlWord(compare){
1715
1716		if(!compare || compare === "=" || compare === "equals")
1717			return("");
1718
1719		var map = {
1720			"!=": "notequals",
1721			">": "greater",
1722			"<": "less",
1723			">=": "greaterequal",
1724			"<=": "lessequal",
1725			"LIKE": "like",
1726			"NOT LIKE": "notlike",
1727			"IN": "in",
1728			"NOT IN": "notin",
1729			"BETWEEN": "between",
1730			"NOT BETWEEN": "notbetween",
1731			"EXISTS": "exists",
1732			"NOT EXISTS": "notexists"
1733		};
1734
1735		if(map[compare])
1736			return(map[compare]);
1737
1738		var lower = ("" + compare).toLowerCase();
1739
1740		for(var op in map){
1741			if(map[op] === lower)
1742				return(map[op]);
1743		}
1744
1745		return("");
1746	}
1747
1748
1749	/**
1750	 * selected meta pair for init mode: key:value[:compare]
1751	 */
1752	function getMetaSelectedPair(objMeta){
1753
1754		var metaKey = getVal(objMeta, "meta_key");
1755
1756		if(!metaKey)
1757			metaKey = getVal(objMeta, "slug");
1758
1759		if(!metaKey)
1760			return("");
1761
1762		var metaValue = getVal(objMeta, "meta_value");
1763
1764		if(!metaValue)
1765			metaValue = "";
1766
1767		var metaPair = metaKey + g_options.urlkey_taxsap + metaValue;
1768		var compareWord = getMetaCompareUrlWord(getVal(objMeta, "compare"));
1769
1770		if(compareWord)
1771			metaPair += g_options.urlkey_taxsap + compareWord;
1772
1773		return(metaPair);
1774	}
1775
1776
1777	/**
1778	 * grouping key for meta items: key, or key + compare word
1779	 */
1780	function getMetaGroupedQueryKey(objItem, keyName, extraName){
1781
1782		var key = objItem[keyName];
1783
1784		if(!key || !extraName)
1785			return(key);
1786
1787		var word = getMetaCompareUrlWord(objItem[extraName]);
1788
1789		if(!word)
1790			return(key);
1791
1792		return(key + "\x1e" + word);
1793	}
1794
1795
1796	/**
1797	 * handle item, add to key->values map
1798	 * keyName/valueName: "taxonomy"/"slug" for terms, "meta_key"/"meta_value" for meta
1799	 * extraName: optional, groups meta by compare as well
1800	 */
1801	function buildGroupedValuesQuery_handleItem(objItem, arrGrouped, keyName, valueName, extraName){
1802
1803		var key = getMetaGroupedQueryKey(objItem, keyName, extraName);
1804		var value = objItem[valueName];
1805
1806		if(!key)
1807			return(arrGrouped);
1808
1809		if(value === null || typeof value === "undefined")
1810			value = "";
1811
1812		var objValues = getVal(arrGrouped, key);
1813		if(!objValues)
1814			objValues = {};
1815
1816		objValues[value] = true;
1817		arrGrouped[key] = objValues;
1818
1819		return(arrGrouped);
1820	}
1821
1822	/**
1823	 * get values string (dot separated)
1824	 * adds .* for AND relation when multiple values
1825	 */
1826	function buildGroupedValuesQuery_getStrValues(objValues, isGroup){
1827		
1828		var isDebug = false;
1829		
1830		if(isDebug == true){
1831			trace("get str values");
1832			trace(objValues);
1833			trace("is group:" + isGroup);
1834		}
1835		
1836		var strValues = "";
1837
1838		var moreThenOne = false;

1839		var isEndSlugFound = false;
1840		var isOrSlugFound = false;
1841		
1842		for (var value in objValues){
1843				
1844			if(value === "__ucand__"){
1845				isEndSlugFound = true;
1846				continue
1847			}
1848			
1849			if(value === "__ucor__"){
1850				isOrSlugFound = true;
1851				continue
1852			}
1853
1854			if(strValues){
1855				moreThenOne = true;
1856				strValues += ".";
1857			}
1858
1859			strValues += value;
1860		}
1861
1862		if(isDebug == true){
1863			trace("more then one: "+moreThenOne);
1864			trace("is end found: "+isEndSlugFound);
1865		}
1866		
1867		var addAnd = (moreThenOne == true && isGroup !== true || isEndSlugFound);
1868		
1869		if(isOrSlugFound === true)
1870			addAnd = false;
1871		
1872		if(addAnd)
1873			strValues += ".*";
1874
1875		if(isDebug)
1876			trace("str values: "+strValues);
1877		
1878		return(strValues);
1879	}
1880
1881
1882	/**
1883	 * build grouped values query string
1884	 * format: key:value1.value2.*;key2:value3
1885	 * used for ucterms (taxonomy:slugs) and ucmeta (meta_key:values[:compare])
1886	 */
1887	function buildGroupedValuesQuery(arrItems, keyName, valueName, extraName){
1888		
1889		var isDebug = false;
1890
1891		if(!keyName)
1892			keyName = "taxonomy";
1893
1894		if(!valueName)
1895			valueName = "slug";
1896
1897		var query = "";
1898
1899		var arrGrouped = {};
1900		var arrGroupItems = [];
1901
1902		if(isDebug == true){
1903			trace("arr items");
1904			trace(arrItems);
1905		}
1906		
1907		jQuery.each(arrItems, function(index, objItem){
1908
1909			//group
1910			if(jQuery.isArray(objItem) && objItem.length != 0){
1911				
1912				if(objItem.length == 1){
1913					arrGrouped = buildGroupedValuesQuery_handleItem(objItem[0], arrGrouped, keyName, valueName, extraName);
1914					return;
1915				}
1916
1917				var arrGroupMap = {};
1918				
1919				jQuery.each(objItem, function(index, groupItem){
1920					
1921					arrGroupMap = buildGroupedValuesQuery_handleItem(groupItem, arrGroupMap, keyName, valueName, extraName);
1922				});
1923
1924				arrGroupItems.push(arrGroupMap);
1925
1926			}else{	//single
1927
1928				arrGrouped = buildGroupedValuesQuery_handleItem(objItem, arrGrouped, keyName, valueName, extraName);
1929			}
1930
1931		});
1932		
1933		if(isDebug == true){
1934			trace("first arr grouped");
1935			trace(arrGrouped);
1936		}
1937
1938		if(jQuery.isEmptyObject(arrGrouped) && jQuery.isEmptyObject(arrGroupItems))
1939			return(null);
1940
1941		if(isDebug == true){
1942			trace("group items");
1943			trace(arrGroupItems);
1944		}
1945		
1946		var isMultipleGroups = (arrGroupItems.length > 1);
1947		
1948		jQuery.each(arrGroupItems, function(index, objGroupKeys){
1949			
1950			jQuery.each(objGroupKeys, function(key, objValues){
1951				
1952			var strValues = buildGroupedValuesQuery_getStrValues(objValues, true);
1953			
1954			var strAdd = strValues;
1955			if(isMultipleGroups === true && strValues.indexOf(".") !== -1){
1956				strAdd = "|"+strValues+"|";	//OR inside the group - only when multiple groups
1957			}
1958				
1959				var objKeyValues = getVal(arrGrouped, key);
1960				if(!objKeyValues)
1961					objKeyValues = {};
1962		
1963				objKeyValues[strAdd] = true;
1964		
1965				arrGrouped[key] = objKeyValues;
1966			});
1967
1968		});
1969
1970		
1971		if(isDebug == true){
1972			trace("The result after grouping");
1973			trace(arrGrouped);
1974		}
1975
1976		jQuery.each(arrGrouped, function(groupKey, objValues){
1977			
1978			var strValues = buildGroupedValuesQuery_getStrValues(objValues);
1979
1980			var key = groupKey;
1981			var compareWord = "";
1982			var sepIndex = groupKey.indexOf("\x1e");
1983
1984			if(sepIndex !== -1){
1985				key = groupKey.substring(0, sepIndex);
1986				compareWord = groupKey.substring(sepIndex + 1);
1987			}
1988				
1989			var strPart = key + g_options.urlkey_taxsap + strValues;
1990
1991			if(compareWord)
1992				strPart += g_options.urlkey_taxsap + compareWord;
1993			
1994			if(query)
1995				query += ";";
1996
1997			query += strPart;
1998
1999		});
2000
2001		if(isDebug == true){
2002			trace("query");
2003			trace(query);
2004		}
2005
2006		return(query);
2007	}
2008
2009	/**
2010	 * build terms query
2011	 * ucterms=category:blog.cocktails.design.*
2012	 */
2013	function buildTermsQuery(arrTerms){
2014
2015		return buildGroupedValuesQuery(arrTerms, "taxonomy", "slug");
2016	}
2017
2018	/**
2019	 * build meta query - same format as terms, optional compare word
2020	 * ucmeta=meta_key:value1.value2;meta_key:value:notequals
2021	 */
2022	function buildMetaQuery(arrMeta){
2023
2024		//normalize: ensure meta_key exists (fallback from slug)
2025		var arrNormalized = [];
2026
2027		jQuery.each(arrMeta, function(index, item){
2028
2029			if(jQuery.isArray(item)){
2030
2031				var arrGroup = [];
2032
2033				jQuery.each(item, function(groupIndex, groupItem){
2034
2035					if(!groupItem)
2036						return(true);
2037
2038					if(!groupItem.meta_key && groupItem.slug)
2039						groupItem.meta_key = groupItem.slug;
2040
2041					if(typeof groupItem.meta_value === "undefined" || groupItem.meta_value === null)
2042						groupItem.meta_value = "";
2043
2044					if(!groupItem.compare)
2045						groupItem.compare = "=";
2046
2047					arrGroup.push(groupItem);
2048				});
2049
2050				arrNormalized.push(arrGroup);
2051
2052			}else{
2053
2054				if(!item)
2055					return(true);
2056
2057				if(!item.meta_key && item.slug)
2058					item.meta_key = item.slug;
2059
2060				if(typeof item.meta_value === "undefined" || item.meta_value === null)
2061					item.meta_value = "";
2062
2063				if(!item.compare)
2064					item.compare = "=";
2065
2066				arrNormalized.push(item);
2067			}
2068
2069		});
2070
2071		return buildGroupedValuesQuery(arrNormalized, "meta_key", "meta_value", "compare");
2072	}
2073
2074	/**
2075	 * get selected filter element data
2076	 */
2077	function getFilterElementData(objElement){
2078				
2079		var id = objElement.data("id");
2080		var title = objElement.data("title");
2081		var key = objElement.data("key");
2082		var type = objElement.data("type");
2083		

2084		if(!id && !key)
2085			return(null);
2086		
2087		
2088		switch(type){
2089		case "taxonomy":
2090		default:
2091			var slug = objElement.data("slug");
2092			var taxonomy = objElement.data("taxonomy");
2093			
2094			var objTerm = {
2095				"type": type,
2096				"id": id,
2097				"slug": slug,
2098				"taxonomy": taxonomy,
2099				"title": title,
2100				"key": key
2101			};
2102			return(objTerm);
2103			
2104		break;
2105		case "author":
2106			
2107			var username = objElement.data("username");
2108			
2109			var objAuthor = {
2110					"type": type,
2111					"id": id,
2112					"username": username,
2113					"title": title,
2114					"key": key
2115				};
2116				return(objAuthor);
2117			
2118		break;
2119		case "meta":
2120
2121			var slug = objElement.data("slug");
2122			var metaKey = objElement.data("metakey");
2123			var metaValue = objElement.data("metavalue");
2124			var compare = objElement.data("compare");
2125
2126			if(!metaKey)
2127				metaKey = slug;
2128
2129			if(!metaValue)
2130				metaValue = "";
2131
2132			if(!compare)
2133				compare = "=";
2134
2135			var objMeta = {
2136				"type": type,
2137				"id": id,
2138				"slug": slug,
2139				"meta_key": metaKey,
2140				"meta_value": metaValue,
2141				"compare": compare,
2142				"title": title,
2143				"key": key
2144			};
2145			return(objMeta);
2146
2147		break;
2148		}
2149		
2150	}
2151
2152
2153	function ________AJAX_CACHE_________(){}
2154
2155	/**
2156	 * get ajax url
2157	 */
2158	function getAjaxCacheKeyFromUrl(ajaxUrl){
2159
2160		var key = ajaxUrl;
2161
2162		key = key.replace(g_urlAjax, "");
2163		key = key.replace(g_urlBase, "");
2164
2165		//replace special signs
2166		key = replaceAll(key, "/","");
2167		key = replaceAll(key, "?","_");
2168		key = replaceAll(key, "&","_");
2169		key = replaceAll(key, "=","_");
2170
2171		return(key);
2172	}
2173
2174	/**
2175	 * get ajax cache key
2176	 */
2177	function getAjaxCacheKey(ajaxUrl, action, objData){
2178
2179	    if(g_options.is_cache_enabled == false)
2180	    	return(false);
2181
2182	    //cache only by url meanwhile
2183
2184	    if(jQuery.isEmptyObject(objData) == false)
2185	    	return(false);
2186
2187	    if(action)
2188	    	return(false);
2189
2190	    var cacheKey = getAjaxCacheKeyFromUrl(ajaxUrl);
2191
2192	    if(!cacheKey)
2193	    	return(false);
2194
2195	    return(cacheKey);
2196	}
2197
2198
2199	/**
2200	 * cache ajax response
2201	 */
2202	function cacheAjaxResponse(ajaxUrl, action, objData, response){
2203
2204	    var cacheKey = getAjaxCacheKey(ajaxUrl, action, objData);
2205
2206	    if(!cacheKey)
2207	    	return(false);
2208
2209	    //some precoutions for overload
2210	    if(g_cache.length > 100)
2211	    	return(false);
2212
2213	    g_cache[cacheKey] = response;
2214
2215	}
2216
2217
2218	function ________AJAX_RESPONSE_______________(){}
2219
2220	/**
2221	 * replace the grid debug
2222	 */
2223	function operateAjax_setHtmlDebug(response, objGrid){
2224
2225		//replace the debug
2226		var htmlDebug = getVal(response, "html_debug");
2227
2228		if(!htmlDebug)
2229			return(false);
2230		
2231		var gridParent = objGrid.parents("." + g_vars.class_widget_wrapper);
2232		
2233		var objDebug = gridParent.find(".uc-debug-query-wrapper");
2234
2235		if(objDebug.length == 0)
2236			return(false);
2237
2238		objDebug.replaceWith(htmlDebug);
2239	}
2240
2241
2242	/**
2243	 * set html grid from ajax response
2244	 */
2245	function operateAjax_setHtmlGrid(response, objGrid, isLoadMore){
2246		
2247		if(g_showDebug == true){
2248			trace("set html grid, response: ");
2249			trace(response);
2250
2251			trace("obj grid:");
2252			trace(objGrid);
2253		}
2254
2255		if(objGrid.length == 0)
2256			return(false);
2257		
2258		//skip set html if exists
2259		if(objGrid.data(g_vars.GRID_DATA_SKIP_HTML) === true){
2260			
2261			if(g_showDebug == true)
2262				trace("skip set html");
2263			
2264			objGrid.data(g_vars.GRID_DATA_SKIP_HTML,false);
2265			return(false);
2266		}
2267		
2268		var objItemsWrapper = getGridItemsWrapper(objGrid);
2269		var objItemsWrapper2 = getGridItemsWrapper(objGrid, true);
2270
2271		if(g_showDebug == true){
2272			trace("items wrapper 1: ");
2273			trace(objItemsWrapper);
2274
2275			trace("items wrapper 2:");
2276			trace(objItemsWrapper2);
2277		}
2278
2279
2280		if(!objItemsWrapper || objItemsWrapper.length == 0)
2281			throw new Error("Missing items wrapper: .uc-items-wrapper");
2282
2283		operateAjax_setHtmlDebug(response, objGrid);
2284
2285		//set grid items
2286
2287		//if init filters mode, and no items response - don't set
2288		if(response.hasOwnProperty("html_items") == false)
2289			return(false);
2290		
2291		var htmlItems = getVal(response, "html_items");
2292				
2293		var htmlItems2 = null;
2294
2295		if(objItemsWrapper2)
2296			htmlItems2 = getVal(response, "html_items2");
2297
2298		//replace widget id
2299		var gridID = objGrid.attr("id");
2300
2301		htmlItems = replaceAll(htmlItems, "%uc_widget_id%", gridID);
2302		
2303		if(htmlItems2)
2304			htmlItems2 = replaceAll(htmlItems2, "%uc_widget_id%", gridID);
2305
2306		var isCustomRefresh = objGrid.data("custom-sethtml");
2307
2308		//show / hide empty message if available and empty response
2309		var objEmptyMessage = getGridEmptyMessage(objGrid);
2310
2311		if(objEmptyMessage){
2312			if(htmlItems == "")
2313				objEmptyMessage.show();
2314			else
2315				objEmptyMessage.hide();
2316		}
2317
2318		//set the query data

2319		var queryDataOriginal = getVal(response, "query_data");
2320		var queryIDs = getVal(response,"query_ids");
2321
2322		var queryData = jQuery.extend({}, queryDataOriginal);
2323
2324		//add to old data
2325
2326		if(isLoadMore == true){
2327
2328			var currentQueryData = objGrid.attr("querydata");
2329
2330			var objCurrentData = jQuery.parseJSON(currentQueryData);
2331			var currentNumPosts = getVal(objCurrentData, "count_posts");
2332
2333			queryData.count_posts += currentNumPosts;
2334
2335			var currentQueryIDs = objGrid.data("postids");
2336
2337			if(queryIDs && currentQueryIDs)
2338				queryIDs = currentQueryIDs + "," + queryIDs;
2339		}
2340
2341		//query data replace
2342
2343		if(queryData){
2344
2345			objGrid.removeAttr("querydata");
2346
2347			var jsonData = JSON.stringify(queryData);
2348			objGrid.attr("querydata", jsonData);
2349
2350			objGrid.data("querydata", queryData);
2351		}
2352
2353		//post id's replace
2354
2355		objGrid.removeAttr("data-postids");
2356		objGrid.attr("data-postids", queryIDs);
2357		objGrid.data("postids", queryIDs);
2358
2359
2360		//if custom refresh - just save the new html in data
2361		if(isCustomRefresh == true){
2362
2363			objGrid.trigger(g_vars.EVENT_SET_HTML_ITEMS,[htmlItems, isLoadMore, htmlItems2]);
2364			return(false);
2365		}
2366
2367
2368		if(!htmlItems2)
2369			htmlItems2 = "";
2370
2371		if(isLoadMore === true){
2372
2373			if(g_showDebug == true){
2374				trace("append load more");
2375			}
2376
2377			objItemsWrapper.append(htmlItems);
2378
2379			if(objItemsWrapper)
2380				objItemsWrapper.append(htmlItems2);
2381
2382		}else{
2383						
2384			objItemsWrapper.html(htmlItems);
2385
2386			if(objItemsWrapper2 && objItemsWrapper2.length)
2387				objItemsWrapper2.html(htmlItems2);
2388
2389		}
2390		
2391		
2392		return(true);
2393	}
2394
2395
2396	/**
2397	 * refresh synced grids
2398	 */
2399	function operateAjax_setHtmlSyngGrids(response, objGrid, isLoadMore){
2400		
2401		var objSyncWidgetsResponse = getVal(response, "html_sync_widgets");
2402
2403		if(g_showDebug == true){
2404			trace("set html sync grids");
2405			trace(objSyncWidgetsResponse);
2406		}
2407
2408		var queryData = getVal(response,"query_data");
2409
2410		if(!objSyncWidgetsResponse){
2411			
2412			if(g_showDebug == true){
2413				trace("no sync widgets response");
2414			}
2415			
2416			return(false);
2417		}
2418		
2419		var group = objGrid.data("filtergroup");
2420		
2421		jQuery.each(objSyncWidgetsResponse, function(elementID, childResponse){
2422			
2423			var objGridWidget = getGridFromElementorElementID(elementID, group);
2424			
2425			if(!objGridWidget){
2426				
2427				if(g_showDebug == true){
2428					trace("no grid widget found: "+elementID);
2429					
2430					getGridFromElementorElementID(elementID,group,true);	//for debug
2431				}
2432				
2433				return(true);
2434			}
2435
2436			if(g_showDebug == true){
2437				trace("set sync grid!");
2438				trace(objGridWidget);
2439				trace(childResponse);
2440			}
2441			
2442			
2443			objGridWidget.removeClass(g_vars.CLASS_REFRESH_SOON);
2444			
2445			childResponse.query_data = queryData;
2446			
2447			operateAjax_setHtmlGrid(childResponse, objGridWidget, isLoadMore);
2448			
2449			objGridWidget.trigger(g_vars.EVENT_AJAX_REFRESHED);
2450			g_objBody.trigger(g_vars.EVENT_AJAX_REFRESHED_BODY, [objGridWidget]);
2451
2452		});
2453
2454	}
2455
2456
2457	/**
2458	 * replace filters html
2459	 */
2460	function operateAjax_setHtmlWidgets(response, objFilters){
2461
2462		if(!objFilters)
2463			return(false);
2464
2465		if(objFilters.length == 0)
2466			return(false);
2467
2468		var objHtmlWidgets = getVal(response, "html_widgets");
2469
2470		if(!objHtmlWidgets)
2471			return(false);
2472
2473		if(objHtmlWidgets.length == 0)
2474			return(false);
2475
2476		var objHtmlDebug = getVal(response, "html_widgets_debug");
2477
2478		jQuery.each(objFilters, function(index, objFilter){
2479
2480			var widgetID = getElementWidgetID(objFilter);
2481
2482			if(!widgetID)
2483				return(true);
2484
2485			var html = getVal(objHtmlWidgets, widgetID);
2486
2487			if(!html)
2488				return(true);
2489
2490			var objHtml = jQuery(html);
2491
2492			var htmlInner = objHtml.html();
2493
2494			//set the class
2495
2496			var filterClassName = objHtml.attr("class");
2497
2498			filterClassName += " "+g_vars.CLASS_FILTER_INITED;
2499
2500			objFilter.attr("class", filterClassName);
2501
2502			objFilter.removeClass(g_vars.CLASS_INITING);
2503			objFilter.removeClass(g_vars.CLASS_REFRESH_SOON);
2504
2505			objFilter.html(htmlInner);
2506
2507
2508
2509			//---- put the debug if exists
2510
2511			var htmlDebug = null;
2512
2513			if(objHtmlDebug)
2514				var htmlDebug = getVal(objHtmlDebug, widgetID);
2515
2516			if(htmlDebug){
2517				var objParent = objFilter.parents("." + g_vars.class_widget_wrapper);
2518				var objDebug = objParent.find(".uc-div-ajax-debug");
2519
2520				if(objDebug.length)
2521					objDebug.replaceWith(htmlDebug);
2522			}
2523			
2524			objFilter.trigger(g_vars.EVENT_FILTER_RELOADED);
2525
2526		});
2527
2528	}
2529

2530	/**
2531	 * scroll to grid top
2532	 */
2533	function scrollToGridTop(objGrid){
2534
2535		var gapTop = 150;
2536
2537		var gridOffset = objGrid.offset().top;
2538
2539		var gridTop = gridOffset - gapTop;
2540
2541		if(gridTop < 0)
2542			gridTop = 0;
2543
2544		//check if the grid top is visible
2545
2546		var currentPos = jQuery(window).scrollTop();
2547
2548		if(currentPos <= gridOffset)
2549			return(false);
2550
2551		window.scrollTo({ top: gridTop, behavior: 'smooth' });
2552
2553	}
2554
2555
2556	/**
2557	 * operate the response
2558	 */
2559	function operateAjaxRefreshResponse(response, objGrid, objFilters, isLoadMore, isNoScroll){
2560		
2561		var isGridRefreshed = operateAjax_setHtmlGrid(response, objGrid, isLoadMore);
2562		
2563		operateAjax_setHtmlWidgets(response, objFilters);
2564		
2565		operateAjax_setHtmlSyngGrids(response, objGrid, isLoadMore);
2566		
2567		objGrid.trigger(g_vars.EVENT_AJAX_REFRESHED,[{isLoadMore:isLoadMore}]);
2568		g_objBody.trigger(g_vars.EVENT_AJAX_REFRESHED_BODY, [objGrid]);
2569		
2570		//trigger body as well
2571
2572		//scroll to grid top
2573		if(isLoadMore == false && isGridRefreshed == true && isNoScroll !== true){
2574						
2575			setTimeout(function(){
2576				
2577				scrollToGridTop(objGrid);
2578					
2579			},200);
2580
2581		}
2582
2583	}
2584
2585
2586	/**
2587	 * replace all occurances
2588	 */
2589	function replaceAll(text, from, to){
2590
2591		return text.split(from).join(to);
2592	};
2593
2594
2595
2596
2597	/**
2598	 * get response from ajax cache
2599	 */
2600	function getResponseFromAjaxCache(ajaxUrl, action, objData){
2601
2602	    var cacheKey = getAjaxCacheKey(ajaxUrl, action, objData);
2603
2604	    if(!cacheKey)
2605	    	return(false);
2606
2607	    var response = getVal(g_cache, cacheKey);
2608
2609	    return(response);
2610	}
2611
2612
2613	function ________AJAX_______________(){}
2614
2615	/**
2616	 * set this filter not to refresh next time
2617	 */
2618	function setNoRefreshFilter(objFilter){
2619
2620		objFilter.data("uc_norefresh",true);
2621
2622	}
2623
2624	/**
2625	 * show ajax error, should be something visible
2626	 */
2627	function showAjaxError(message){
2628
2629		alert(message);
2630
2631	}
2632
2633	/**
2634	 * get the debug object
2635	 */
2636	function getDebugObject(){
2637
2638		var objGrid = g_lastGridAjaxCall;
2639
2640		if(!objGrid)
2641			return(null);
2642
2643		var objDebug = objGrid.find("."+g_vars.CLASS_DIV_DEBUG);
2644
2645		if(objDebug.length)
2646			return(objDebug);
2647
2648		//insert if not exists
2649
2650		objGrid.after("<div class='"+g_vars.CLASS_DIV_DEBUG+"' style='padding:10px;display:none;background-color:#D8FCC6'></div>");
2651
2652		var objDebug = jQuery("body").find("."+g_vars.CLASS_DIV_DEBUG);
2653
2654		return(objDebug);
2655	}
2656
2657
2658	/**
2659	 * show ajax debug
2660	 */
2661	function showAjaxDebug(str){
2662
2663		trace("Ajax Error! - Check the debug");
2664
2665		str = jQuery.trim(str);
2666
2667		if(!str || str.length == 0)
2668			return(false);
2669
2670		var objStr = jQuery(str);
2671
2672		if(objStr.find("header").length || objStr.find("body").length){
2673			str = "Wrong ajax response!";
2674		}
2675
2676		var objDebug = getDebugObject();
2677
2678		if(!objDebug || objDebug.length == 0){
2679
2680			alert(str);
2681
2682			throw new Error("debug not found");
2683		}
2684
2685		objDebug.show();
2686		objDebug.html(str);
2687
2688	}
2689
2690
2691	/**
2692	 * small ajax request
2693	 */
2694	function ajaxRequest(ajaxUrl, action, objData, onSuccess){
2695				
2696		if(g_debugInitMode === true){
2697
2698			trace("debug init mode - skip request");
2699			return(false);
2700		}
2701
2702		if(g_showDebug == true){
2703			trace("ajax request");
2704			trace(ajaxUrl);
2705		}
2706
2707		if(!objData)
2708			var objData = {};
2709
2710		if(typeof objData != "object")
2711			throw new Error("wrong ajax param");
2712
2713		//check response from cache
2714		var responseFromCache = getResponseFromAjaxCache(ajaxUrl, action, objData);
2715
2716		if(responseFromCache){
2717
2718			//simulate ajax request
2719			setTimeout(function(){
2720				onSuccess(responseFromCache);
2721			}, 300);
2722
2723			return(false);
2724		}
2725
2726		var ajaxData = {};
2727		ajaxData["action"] = "unlimitedelements_ajax_action";
2728		ajaxData["client_action"] = action;
2729
2730		var ajaxtype = "get";
2731
2732		if(jQuery.isEmptyObject(objData) == false){
2733			ajaxData["data"] = objData;
2734			ajaxtype = "post";
2735		}
2736
2737
2738		var ajaxOptions = {
2739				type:ajaxtype,
2740				url:ajaxUrl,
2741				success:function(response){
2742
2743					if(!response){
2744						showAjaxError("Empty ajax response!");
2745						return(false);
2746					}
2747
2748					if(typeof response != "object"){
2749
2750						try{
2751
2752							response = jQuery.parseJSON(response);
2753
2754						}catch(e){
2755
2756							showAjaxDebug(response);
2757
2758							showAjaxError("Ajax Error!!! not ajax response");
2759							return(false);
2760						}
2761					}
2762
2763					if(response == -1){
2764						showAjaxError("ajax error!!!");
2765						return(false);
2766					}
2767
2768					if(response == 0){
2769						showAjaxError("ajax error, action: <b>"+action+"</b> not found");
2770						return(false);
2771					}
2772
2773					if(response.success == undefined){
2774						showAjaxError("The 'success' param is a must!");
2775						return(false);
2776					}
2777
2778
2779					if(response.success == false){
2780						showAjaxError(response.message);
2781						return(false);
2782					}
2783
2784					cacheAjaxResponse(ajaxUrl, action, objData, response);
2785
2786					if(typeof onSuccess == "function"){
2787
2788						onSuccess(response);
2789					}
2790
2791				},
2792				error:function(jqXHR, textStatus, errorThrown){
2793
2794					switch(textStatus){
2795						case "parsererror":
2796						case "error":
2797
2798							//showAjaxError("parse error");
2799
2800							showAjaxDebug(jqXHR.responseText);
2801
2802						break;
2803					}
2804				}
2805		}
2806
2807		if(ajaxtype == "post"){
2808			ajaxOptions.dataType = 'json';
2809			ajaxOptions.data = ajaxData
2810		}
2811
2812		var handle = jQuery.ajax(ajaxOptions);
2813
2814		return(handle);
2815	}
2816
2817
2818
2819	/**
2820	 * get grid items wrapper
2821	 */
2822	function getGridItemsWrapper(objGrid, isSecond){
2823
2824		var classItems = "uc-items-wrapper";
2825
2826		if(isSecond == true)
2827			classItems = "uc-items-wrapper2";
2828
2829		if(objGrid.hasClass(classItems))
2830			return(objGrid);
2831
2832		var objItemsWrapper = objGrid.find("."+classItems);
2833
2834		if(objItemsWrapper.length == 0 && isSecond == false)
2835			throw new Error("Missing items wrapper - with class: uc-items-wrapper");
2836
2837		if(objItemsWrapper.length == 0)
2838			return(null);
2839
2840		return(objItemsWrapper);
2841	}
2842
2843
2844	/**
2845	 * set ajax loader
2846	 */
2847	function showAjaxLoader(objElement){
2848
2849		objElement.addClass("uc-ajax-loading");
2850	}
2851
2852	/**
2853	 * hide ajax loader
2854	 */
2855	function hideAjaxLoader(objElement){
2856
2857		objElement.removeClass("uc-ajax-loading");
2858	}
2859
2860
2861	/**
2862	 * show multiple ajax loader
2863	 */
2864	function showMultipleAjaxLoaders(objElements, isShow){
2865
2866		if(!objElements)
2867			return(false);
2868
2869		if(objElements.length == 0)
2870			return(false);
2871
2872		jQuery.each(objElements,function(index, objElement){
2873
2874			objElement = jQuery(objElement);
2875
2876			if(isShow == true){
2877
2878				showAjaxLoader(objElement);
2879			}
2880			else
2881				hideAjaxLoader(objElement);
2882		});
2883
2884	}
2885
2886
2887	/**
2888	 * refresh ajax grid
2889	 */
2890	function refreshAjaxGrid(objGrid, refreshType){
2891				
2892		var isLoadMore = (refreshType == g_vars.REFRESH_MODE_LOADMORE);	 //for the output
2893		var isFiltersInit = (refreshType == "filters" || refreshType == "filters_children");
2894		
2895		//for the options - not refresh other filters
2896		var isLoadMoreMode = (refreshType == g_vars.REFRESH_MODE_LOADMORE || refreshType == g_vars.REFRESH_MODE_PAGINATION);
2897		
2898		//get all grid filters
2899		var objFilters = objGrid.data("filters");
2900
2901		if(!objFilters)
2902			return(false);
2903
2904		if(objFilters.length == 0)
2905			return(false);
2906
2907		if(objGrid.hasClass(g_vars.CLASS_GRID_NOREFRESH))
2908			return(false);
2909
2910		var params = {};
2911		if(refreshType == "filters_children")
2912			params["filters_init_type"] = "children";
2913		
2914		params["refresh_type"] = refreshType;
2915		
2916		var objAjaxOptions = getGridAjaxOptions(objFilters, objGrid, isFiltersInit, isLoadMoreMode, params);
2917		
2918		if(!objAjaxOptions){
2919
2920			trace("ajax options are null");
2921			return(false);
2922		}
2923
2924		var ajaxUrl = objAjaxOptions["ajax_url"];
2925		var urlReplace = objAjaxOptions["url_replace"];
2926		var arrTerms = objAjaxOptions["terms"];
2927
2928		if(g_vars.DEBUG_AJAX_OPTIONS == true){
2929
2930			trace("DEBUG AJAX OPTIONS");