overload view settings from filter-type if nothing is set in this filter-item.
166714
protected function OverloadViewSettings()
    {
        if (empty($this->fieldView)) {
            $oListFilterItemType = $this->GetFieldPkgShopListfilterItemType();
            if (!is_null($oListFilterItemType) && !TGlobal::IsCMSMode()) {
                $this->sqlData['view'] = $oListFilterItemType->fieldView;
                $this->fieldView = $this->sqlData['view'];
                $this->sqlData['view_class_type'] = $oListFilterItemType->fieldViewClassType;
                $this->fieldViewClassType = $this->sqlData['view_class_type'];
            }
        }
    }
1229804
private void processOverdueFilterStatus() {
        overdueBtnClicked = !overdueBtnClicked;
        managementUIState.getTargetTableFilters().setOverdueFilterEnabled(overdueBtnClicked);

        if (overdueBtnClicked) {
            buttonClicked.addStyleName(BTN_CLICKED);
            eventBus.publish(this, TargetFilterEvent.FILTER_BY_STATUS);
        } else {
            buttonClicked.removeStyleName(BTN_CLICKED);
            eventBus.publish(this, TargetFilterEvent.REMOVE_FILTER_BY_STATUS);
        }

    }
951652
function _fnFilterCustom( oSettings )
	{
		var afnFilters = DataTable.ext.search;
		var aiFilterColumns = _fnGetColumns( oSettings, 'bSearchable' );
	
		for ( var i=0, iLen=afnFilters.length ; i<iLen ; i++ )
		{
			var iCorrector = 0;
			for ( var j=0, jLen=oSettings.aiDisplay.length ; j<jLen ; j++ )
			{
				var iDisIndex = oSettings.aiDisplay[j-iCorrector];
				var bTest = afnFilters[i](
					oSettings,
					_fnGetRowData( oSettings, iDisIndex, 'filter', aiFilterColumns ),
					iDisIndex
				);
	
				/* Check if we should use this row based on the filtering function */
				if ( !bTest )
				{
					oSettings.aiDisplay.splice( j-iCorrector, 1 );
					iCorrector++;
				}
			}
		}
	}
678884
def iter_settings(mixed: Settings) -> Iterator[Tuple[str, Any]]:
    
    if isinstance(mixed, types.ModuleType):
        for attr in dir(mixed):
            if not is_setting_key(attr):
                continue
            yield (attr, getattr(mixed, attr))
    else:
        yield from filter(lambda item: is_setting_key(item[0]), mixed.items())
283067
def _apply_filter_settings(self):
        """"""
        # TODO: Allow easy customization of filters
        if self.mipmap:
            gl.glTexParameterf(self.target, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR_MIPMAP_LINEAR)
        else:
            gl.glTexParameterf(self.target, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
        gl.glTexParameterf(self.target, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)

        gl.glTexParameterf(self.target, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE)
        gl.glTexParameterf(self.target, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE)
87914
private void applyFilter(){
        filteredItems.clear();

        Filter<M> filter = getFilter();
        if(filter == null){
            filteredItems.addAll(items);
        }else{
            for (int i = 0; i < items.size(); i++) {
                M item = items.get(i);
                if(filter.filter(item, query)){
                    filteredItems.add(item);
                }
            }
        }

        onFiltered();
    }
942100
def filter(o)
      raise ArgumentError.new('Wrong type supplied to filter') unless Splib.type_of?(o, @type)
      do_filter(o)
    end
821596
def check_views(view_set, max_views=3):
    """"""

    if not isinstance(view_set, Iterable):
        view_set = tuple([view_set, ])

    if len(view_set) > max_views:
        raise ValueError('Can only have {} views'.format(max_views))

    return [check_int(view, 'view', min_value=0, max_value=max_views - 1) for view in view_set]
386749
def is_api_filter(self, filter_field):
        """"""
        if self.filter_type == 'server':
            for choice in self.filter_choices:
                if (choice[0] == filter_field and len(choice) > 2 and
                        choice[2]):
                    return True
        return False
617698
def viewType(self, name):
        
        for view in self._viewTypes:
            if view.viewName() == name:
                return view
        return None
1097150
function(model) {
    for (var i = 0; i < filterFunctions.length; i++) {
      if (!filterFunctions[i](model)) {
        return false;
      }
    }
    return true;
  }
180456
def eventFilter(self, obj, event):
        """"""
        if obj == self.dataTable and event.type() == QEvent.Resize:
            self._resizeVisibleColumnsToContents()
        return False
337606
def enable(self):
        """"""
        with self._lock:
            if self.filter is None:
                self.filter = self._filter_type(self)
925326
function () {
    if (config.filters && config.filters.html && config.filters.html.vars) {
        templateVars = _.clone(config.filters.html.vars);
    } else {
        templateVars = {};
    }
}
1352822
def is_filter_type(target):
    # type: (Any) -> Union[bool, Text]
    
    if not is_class(target):
        return 'not a class'

    if not issubclass(target, BaseFilter):
        return 'does not extend BaseFilter'

    if is_abstract(target):
        return 'abstract class'

    return True
568804
public void filterUpdate(DataSetFilter filter) {
        if (displayerSettings.isFilterEnabled()) {

            DataSetFilter oldFilter = currentFilter;
            this.currentFilter = filter;

            // Notify to those interested parties the selection event.
            if (displayerSettings.isFilterNotificationEnabled()) {
                for (DisplayerListener listener : listenerList) {
                    listener.onFilterUpdate(this, oldFilter, filter);
                }
            }
            // Drill-down support
            if (displayerSettings.isFilterSelfApplyEnabled()) {
                dataSetHandler.unfilter(oldFilter);
                dataSetHandler.filter(filter);
                redraw();
            }
        }
    }
1174955
def get_filter(filetypes, ext):
    """"""
    if not ext:
        return ALL_FILTER
    for title, ftypes in filetypes:
        if ext in ftypes:
            return _create_filter(title, ftypes)
    else:
        return ''