<ClCompile Include="..\src\stringfilter.cpp" />

    <ClInclude Include="..\src\stringfilter_type.h" />

    <ClCompile Include="..\src\stringfilter.cpp">

      <Filter>Source Files</Filter>

    </ClCompile>

    <ClInclude Include="..\src\stringfilter_type.h">

      <Filter>Header Files</Filter>

    </ClInclude>

				RelativePath=".\..\src\stringfilter.cpp"

				>

			</File>

			<File

				RelativePath=".\..\src\stringfilter_type.h"

				>

			</File>

			<File

				RelativePath=".\..\src\stringfilter.cpp"

				>

			</File>

			<File

				RelativePath=".\..\src\stringfilter_type.h"

				>

			</File>

			<File

stringfilter.cpp

stringfilter_type.h

#include "../stringfilter_type.h"

	typedef GUIList<const ContentInfo *, StringFilter &> GUIContentList;

	StringFilter string_filter;  ///< Filter for content list

	static bool CDECL TagNameFilter(const ContentInfo * const *a, StringFilter &filter)

		filter.ResetState();

			filter.AddLine((*a)->tags[i]);

		filter.AddLine((*a)->name);

		return filter.GetState();

		if (!this->content.Filter(this->string_filter)) return;

		this->string_filter.SetFilterTerm(this->edit_str_buf);

		this->content.SetFilterState(!this->string_filter.IsEmpty());

#include "stringfilter_type.h"

	typedef GUIList<const GRFConfig *, StringFilter &> GUIGRFConfigList;

	StringFilter string_filter; ///< Filter for available grf.

		string_filter.SetFilterTerm(this->edit_str_buf);

		this->avails.SetFilterState(!string_filter.IsEmpty());

	static bool CDECL TagNameFilter(const GRFConfig * const *a, StringFilter &filter)

		filter.ResetState();

		filter.AddLine((*a)->GetName());

		filter.AddLine((*a)->filename);

		filter.AddLine((*a)->GetDescription());

		return filter.GetState();;

		this->avails.Filter(this->string_filter);

#include "stringfilter_type.h"

	 * A GUIList contains signs and uses a StringFilter for filtering.

	typedef GUIList<const Sign *, StringFilter &> GUISignList;

	StringFilter string_filter;                                       ///< The match string to be used when the GUIList is (re)-sorted.

	SignList() : string_filter(&match_case)

	/** Filter sign list by sign name */

	static bool CDECL SignNameFilter(const Sign * const *a, StringFilter &filter)

		filter.ResetState();

		filter.AddLine(buf1);

		return filter.GetState();

	static bool CDECL OwnerDeityFilter(const Sign * const *a, StringFilter &filter)

	static bool CDECL OwnerVisibilityFilter(const Sign * const *a, StringFilter &filter)

		this->signs.Filter(&SignNameFilter, this->string_filter);

		if (_game_mode != GM_EDITOR) this->signs.Filter(&OwnerDeityFilter, this->string_filter);

			this->signs.Filter(&OwnerVisibilityFilter, this->string_filter);

		this->string_filter.SetFilterTerm(new_filter_string);

		this->SetWidgetDisabledState(WID_SIL_FILTER_CLEAR_BTN, StrEmpty(new_filter_string));

		if (data == 0 || data == -1 || !this->string_filter.IsEmpty()) { // New or deleted sign, changed visibility setting or there is a filter string

/* $Id$ */

/*

 * This file is part of OpenTTD.

 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.

 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

/** @file stringfilter.cpp Searching and filtering using a stringterm. */

#include "stdafx.h"

#include "string_func.h"

#include "stringfilter_type.h"

static const WChar STATE_WHITESPACE = ' ';

static const WChar STATE_WORD = 'w';

static const WChar STATE_QUOTE1 = '\'';

static const WChar STATE_QUOTE2 = '"';

/**

 * Set the term to filter on.

 * @param str Filter term

 */

void StringFilter::SetFilterTerm(const char *str)

{

	this->word_index.Reset();

	this->word_matches = 0;

	free(this->filter_buffer);

	assert(str != NULL);

	char *dest = (char *)malloc(strlen(str) + 1);

	this->filter_buffer = dest;

	WChar state = STATE_WHITESPACE;

	const char *pos = str;

	WordState *word = NULL;

	size_t len;

	for (;; pos += len) {

		WChar c;

		len = Utf8Decode(&c, pos);

		if (c == 0 || (state == STATE_WORD && IsWhitespace(c))) {

			/* Finish word */

			if (word != NULL) {

				*(dest++) = '\0';

				word = NULL;

			}

			state = STATE_WHITESPACE;

			if (c != 0) continue; else break;

		}

		if (state == STATE_WHITESPACE) {

			/* Skip whitespace */

			if (IsWhitespace(c)) continue;

			state = STATE_WORD;

		}

		if (c == STATE_QUOTE1 || c == STATE_QUOTE2) {

			if (state == c) {

				/* Stop quoting */

				state = STATE_WORD;

				continue;

			} else if (state == STATE_WORD) {

				/* Start quoting */

				state = c;

				continue;

			}

		}

		/* Add to word */

		if (word == NULL) {

			word = this->word_index.Append();

			word->start = dest;

			word->match = false;

		}

		memcpy(dest, pos, len);

		dest += len;

	}

}

/**

 * Reset the matching state to process a new item.

 */

void StringFilter::ResetState()

{

	this->word_matches = 0;

	const WordState *end = this->word_index.End();

	for (WordState *it = this->word_index.Begin(); it != end; ++it) {

		it->match = false;

	}

}

/**

 * Pass another text line from the current item to the filter.

 *

 * You can call this multiple times for a single item, if the filter shall apply to multiple things.

 * Before processing the next item you have to call ResetState().

 *

 * @param str Another line from the item.

 */

void StringFilter::AddLine(const char *str)

{

	if (str == NULL) return;

	bool match_case = this->case_sensitive != NULL && *this->case_sensitive;

	const WordState *end = this->word_index.End();

	for (WordState *it = this->word_index.Begin(); it != end; ++it) {

		if (!it->match) {

			if ((match_case ? strstr(str, it->start) : strcasestr(str, it->start)) != NULL) {

				it->match = true;

				this->word_matches++;

			}

		}

	}

}

/* $Id$ */

/*

 * This file is part of OpenTTD.

 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.

 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

/** @file stringfilter_type.h Searching and filtering using a stringterm. */

#ifndef STRINGFILTER_TYPE_H

#define STRINGFILTER_TYPE_H

#include "core/smallvec_type.hpp"

/**

 * String filter and state.

 *

 * The filter takes a stringterm and parses it into words separated by whitespace.

 * The whitespace-separation can be avoided by quoting words in the searchterm using " or '.

 * The quotation characters can be nested or concatenated in a unix-shell style.

 *

 * When filtering an item, all words are checked for matches, and the filter matches if every word

 * matched. So, effectively this is a AND search for all entered words.

 *

 * Once the filter is set up using SetFilterTerm, multiple items can be filtered consecutively.

 *  1. For every item first call ResetState() which resets the matching-state.

 *  2. Pass all lines of the item via AddLine() to the filter.

 *  3. Check the matching-result for the item via GetState().

 */

struct StringFilter {

private:

	/** State of a single filter word */

	struct WordState {

		const char *start;                         ///< Word to filter for.

		bool match;                                ///< Already matched?

	};

	const char *filter_buffer;                     ///< Parsed filter string. Words separated by 0.

	SmallVector<WordState, 4> word_index;          ///< Word index and filter state.

	uint word_matches;                             ///< Summary of filter state: Number of words matched.

	const bool *case_sensitive;                    ///< Match case-sensitively (usually a static variable).

public:

	/**

	 * Constructor for filter.

	 * @param case_sensitive Pointer to a (usually static) variable controlling the case-sensitivity. NULL means always case-insensitive.

	 */

	StringFilter(const bool *case_sensitive = NULL) : filter_buffer(NULL), word_matches(0), case_sensitive(case_sensitive) {}

	~StringFilter() { free(this->filter_buffer); }

	void SetFilterTerm(const char *str);

	/**

	 * Check whether any filter words were entered.

	 * @return true if no words were entered.

	 */

	bool IsEmpty() const { return this->word_index.Length() == 0; }

	void ResetState();

	void AddLine(const char *str);

	/**

	 * Get the matching state of the current item.

	 * @return true if matched.

	 */

	bool GetState() const { return this->word_matches == this->word_index.Length(); }

};

#endif /* STRINGFILTER_TYPE_H */