[Feature Request]: Making a small popup window in order to search the vault similar to spotlight search.

[vitnetdev]

Checklist

• I am using an up-to-date version.
• I have read the documentation.
• I have searched existing issues.

Description

I am working on a small popup window that will be similar to spotlight search,
This will be used for quick file location.

Shortcut Suggestion

• Mac
  option + space
• Windows + Linux
  alt + space

People should be able to come up with their own shortcuts for this quick search.
I am using a .c file that can be run in the terminal. Going to be working on a mac + linux version.

Solution

Small popup should appear when pressing a shortcut key when in any window, this should allow the person to quickly and effectively search tag studio and bring up files.

Alternatives

No response

[vitnetdev]

Once windows version has been fully tested I will send it as a .c file. The code listed below is just so the community can help me complete this idea and allow me to start working on support for other operating systems.

[vitnetdev]

This is the x64 version, should work with x86 but unsure as have no x86 systems. Still working on the todo's.

// Searcher CLI for WIN x64

// TODO:
////// - Highest Priority : Limit to only searching the Tag Studio enabled files
// x64 so we are not limited to 2gb RAM
// add a -unquote command line option so we can handle powershell, eg: es.exe -unquote case:`"$x`" => es.exe -unquote "case:"abc 123"" => es.exe case:"abc 123"
// export results to environment variables -mostly useful for -n 1
// Use system number formatting (some localizations don't use , for the comma)
// Show the sum of the size.
// add an option to append a path separator for folders.
// add a -no-config command line option to bypass loading of settings.
// would be nice if it had -POSIX and -NUL switches to generate NUL for RG/GREP
// export as TSV to match Everything export.
// -save-db -save database to disk command line option.
// -rebuild -force a rebuild
// inc-run-count/set-run-count should allow -instance
// fix background highlight when a result spans multiple lines, eg: -highlight -highlight-color 0xa0
// es sonic -name -path-column -name-color 13 -highlight // -name-color 13 doesn't work with -highlight !
// improve -pause when the window is resized.
// -v to display everything version?
// -path is not working with -r It is using the <"filter"> (-path is adding brackets and double quotes, neither of which regex understands)
// Gather file information if it is not indexed.
// path ellipsis?
// -get-size <filename> - expand -get-run-count to get other information for a single file? -what happens when the file doesn't exist?
// when in pause:
//		w - wrap
//		n - number
//		/ - search
//		h - help
//		r - write
//		default "prompt", ":".
//		If you want help, :h.
//		Save the stream to a file, :r c:\tmp\out.txt
// Maybe a configurable prompt, so the "current" (bottom-most) line, total count of results. 
// [23/72]:
// emulate LESS
// *shouldn't we use environment variables for storing switches? like MORE? -registry does make it easy. -using ini now
// custom date/time format.

// NOTES:
// ScrollConsoleScreenBuffer is unuseable because it fills invalidated areas, which causes unnecessary flickering.

//#define ES_VERSION L"1.0.0.0" // initial release
//#define ES_VERSION L"1.0.0.1" // fixed command line interpreting '-' as a switch inside text.
//#define ES_VERSION L"1.0.0.2" // convert unicode to same code page as console.
//#define ES_VERSION L"1.0.0.3" // removed es_write console because it has no support for piping.
//#define ES_VERSION L"1.0.0.4" // added ChangeWindowMessageFilterEx (if available) for admin/user support.
//#define ES_VERSION L"1.1.0.1a" // Everything 1.4.1 support for size, dates etc.
//#define ES_VERSION L"1.1.0.2a" // -pause, -more, -hide-empty-search-results, -empty-search-help, -save-settings, -clear-settings, -path, -parent-path, -parent -no-*switches*, localized dates
//#define ES_VERSION L"1.1.0.3a" // error levels added, -timeout
//#define ES_VERSION L"1.1.0.4a" // -pause improvements, -set-run-count, -inc-run-count, -get-run-count, allow -name -size -date to re-order columns even when they are specified in settings, with -more ENTER=show one line, Q=Quit, ESC=Escape., column alignment improvements.
//#define ES_VERSION L"1.1.0.5a" // /a[RASH] attributes added, -more/-pause ignored for no results, -sort-size, -sort-size-ascending and -sort-size-descending.
//#define ES_VERSION L"1.1.0.6a" // added -csv, -efu, -txt, -m3u and -m3u8 to set the display format (no exporting), added -export-m3u and -export-m3u8.
//#define ES_VERSION L"1.1.0.7" // Everything 1.4 release.
//#define ES_VERSION L"1.1.0.8" // removed -highligh-name, -highligh-path and -highligh-full-path-name. fixed date widths, switched to ini settings.
//#define ES_VERSION L"1.1.0.9" // fixed an issue with checking if the database is loaded, exporting as efu only exports indexed information now, use -size, -date-modified, -date-created or -attributes to override., folder size is also exported now.
//#define ES_VERSION L"1.1.0.10" // -r now takes a parameter, and Everything handles escaping quotes.
//#define ES_VERSION L"1.1.0.11" // added -date-format
//#define ES_VERSION L"1.1.0.12" // added -get-result-count
//#define ES_VERSION L"1.1.0.13" // added -cd -removed -cd -added -ipc1 -ipc2 -output errors to std_error
//#define ES_VERSION L"1.1.0.14" // updated help (thanks to NotNull) and fixed -? -h -help errors
//#define ES_VERSION L"1.1.0.15" // updated help (thanks to NotNull) 
//#define ES_VERSION L"1.1.0.16" // added -no-header, added -double-quote, added -version, added -get-everything-version
//#define ES_VERSION L"1.1.0.17" // added -no-result-error
//#define ES_VERSION L"1.1.0.18" // added -get-total-size
//#define ES_VERSION L"1.1.0.19" // inc-run-count/set-run-count allow -instance
//#define ES_VERSION L"1.1.0.20" // fix ALT in pause mode causing page down.
//#define ES_VERSION L"1.1.0.21" // added TSV support.
//#define ES_VERSION L"1.1.0.22" // fixed an issue with WideCharToMultiByte using the wrong buffer size.
//#define ES_VERSION L"1.1.0.23" // fixed an issue with instance name not being initialized.
//#define ES_VERSION L"1.1.0.24" // fixed an issue with converting ini utf-8 to wchar text.
//#define ES_VERSION L"1.1.0.25" // added -exit and -reindex -utf8-bom
//#define ES_VERSION L"1.1.0.26" // fixed an issue with exporting UTF-16 surrogate pairs.
//#define ES_VERSION L"1.1.0.27" // improved WriteFile performance. (added es_buf_t) -added /cp 65001


// *** YOU MUST MANUALLY UPDATE THE RESOURCE FILE WITH THE NEW VERSION ***
// *** YOU MUST MANUALLY UPDATE THE RESOURCE FILE WITH THE NEW VERSION ***
// *** YOU MUST MANUALLY UPDATE THE RESOURCE FILE WITH THE NEW VERSION ***
// *** YOU MUST MANUALLY UPDATE THE RESOURCE FILE WITH THE NEW VERSION ***
// *** YOU MUST MANUALLY UPDATE THE RESOURCE FILE WITH THE NEW VERSION ***
// *** YOU MUST MANUALLY UPDATE THE RESOURCE FILE WITH THE NEW VERSION ***
// *** YOU MUST MANUALLY UPDATE THE RESOURCE FILE WITH THE NEW VERSION ***
#define ES_VERSION L"1.1.0.27" 
// *** YOU MUST MANUALLY UPDATE THE RESOURCE FILE WITH THE NEW VERSION ***
// *** YOU MUST MANUALLY UPDATE THE RESOURCE FILE WITH THE NEW VERSION ***
// *** YOU MUST MANUALLY UPDATE THE RESOURCE FILE WITH THE NEW VERSION ***
// *** YOU MUST MANUALLY UPDATE THE RESOURCE FILE WITH THE NEW VERSION ***
// *** YOU MUST MANUALLY UPDATE THE RESOURCE FILE WITH THE NEW VERSION ***
// *** YOU MUST MANUALLY UPDATE THE RESOURCE FILE WITH THE NEW VERSION ***

// errorlevel returned from ES.
#define ES_ERROR_SUCCESS					0 // no known error, search successful.
#define ES_ERROR_REGISTER_WINDOW_CLASS		1 // failed to register window class
#define ES_ERROR_CREATE_WINDOW				2 // failed to create listening window.
#define ES_ERROR_OUT_OF_MEMORY				3 // out of memory
#define ES_ERROR_EXPECTED_SWITCH_PARAMETER	4 // expected an additional command line option with the specified switch
#define ES_ERROR_CREATE_FILE				5 // failed to create export output file
#define ES_ERROR_UNKNOWN_SWITCH				6 // unknown switch.
#define ES_ERROR_SEND_MESSAGE				7 // failed to send Everything IPC a query.
#define ES_ERROR_IPC						8 // NO Everything IPC window.
#define ES_ERROR_NO_RESULTS					9 // No results found. Only set if -no-result-error is used

#define _DEBUG_STR(x) #x
#define DEBUG_STR(x) _DEBUG_STR(x)
//#define DEBUG_FIXME(x) __pragma(message(__FILE__ "(" DEBUG_STR(__LINE__) ") : FIXME: "x))
#define DEBUG_FIXME(x) __pragma(message(__FILE__ "(" DEBUG_STR(__LINE__) ") : FIXME: "x))

DEBUG_FIXME("___UPDATE YEAR IN RESOURCE___")

// compiler options
#pragma warning(disable : 4996) // deprecation
#pragma warning(disable : 4133) // warning C4133: 'function' : incompatible types - from 'CHAR *' to 'const wchar_t *'

#include <windows.h>
#include <stdio.h>

// IPC Header from the Everything SDK:
#include "..\..\sdk\ipc\everything_ipc.h"
#include "shlwapi.h" // Path functions

#define ES_COPYDATA_IPCTEST_QUERYCOMPLETEW		0
#define ES_COPYDATA_IPCTEST_QUERYCOMPLETE2W		1

#define ES_EXPORT_NONE		0
#define ES_EXPORT_CSV		1
#define ES_EXPORT_EFU		2
#define ES_EXPORT_TXT		3
#define ES_EXPORT_M3U		4
#define ES_EXPORT_M3U8		5
#define ES_EXPORT_TSV		6

#define ES_BUF_SIZE			(MAX_PATH * sizeof(wchar_t))
#define ES_WSTRING_SIZE		MAX_PATH
#define ES_EXPORT_BUF_SIZE	65536
#define ES_SEARCH_BUF_SIZE	(1 * 1024 * 1024)
#define ES_FILTER_BUF_SIZE	(1 * 1024 * 1024)

#define ES_PAUSE_TEXT		"ESC=Quit; Up,Down,Left,Right,Page Up,Page Down,Home,End=Scroll"
#define ES_BLANK_PAUSE_TEXT	"                                                              "

enum
{
	ES_COLUMN_FILENAME,
	ES_COLUMN_NAME,
	ES_COLUMN_PATH,
	ES_COLUMN_HIGHLIGHTED_FILENAME,
	ES_COLUMN_HIGHLIGHTED_NAME,
	ES_COLUMN_HIGHLIGHTED_PATH,
	ES_COLUMN_EXTENSION,
	ES_COLUMN_SIZE,
	ES_COLUMN_DATE_CREATED,
	ES_COLUMN_DATE_MODIFIED,
	ES_COLUMN_DATE_ACCESSED,
	ES_COLUMN_ATTRIBUTES,
	ES_COLUMN_FILE_LIST_FILENAME,
	ES_COLUMN_RUN_COUNT,
	ES_COLUMN_DATE_RUN,
	ES_COLUMN_DATE_RECENTLY_CHANGED,
	ES_COLUMN_TOTAL,
};

const wchar_t *es_column_names[] = 
{
	L"Filename",
	L"Name",
	L"Path",
	L"Filename", // highlighted
	L"Name", // highlighted
	L"Path", // highlighted
	L"Extension",
	L"Size",
	L"Date Created",
	L"Date Modified",
	L"Date Accessed",
	L"Attributes",
	L"File List Filename",
	L"Run Count",
	L"Date Run",
	L"Date Recently Changed",
};

const wchar_t *es_sort_names[] = 
{
	L"name",
	L"path",
	L"size",
	L"extension",
	L"ext",
	L"date-created",
	L"dc",
	L"date-modified",
	L"dm",
	L"attributes",
	L"attribs",
	L"attrib",
	L"file-list-file-name",
	L"run-count",
	L"recent-change",
	L"date-recently-changed",
	L"rc",
	L"drc",
	L"date-accessed",
	L"da",
	L"date-run",
	L"daterun",
};

#define ES_SORT_NAME_COUNT (sizeof(es_sort_names) / sizeof(const wchar_t *))

const DWORD es_sort_names_to_ids[] = 
{
	EVERYTHING_IPC_SORT_NAME_ASCENDING,
	EVERYTHING_IPC_SORT_PATH_ASCENDING,
	EVERYTHING_IPC_SORT_SIZE_DESCENDING,
	EVERYTHING_IPC_SORT_EXTENSION_ASCENDING,
	EVERYTHING_IPC_SORT_EXTENSION_ASCENDING,
	EVERYTHING_IPC_SORT_DATE_CREATED_DESCENDING,
	EVERYTHING_IPC_SORT_DATE_CREATED_DESCENDING,
	EVERYTHING_IPC_SORT_DATE_MODIFIED_DESCENDING,
	EVERYTHING_IPC_SORT_DATE_MODIFIED_DESCENDING,
	EVERYTHING_IPC_SORT_ATTRIBUTES_ASCENDING,
	EVERYTHING_IPC_SORT_ATTRIBUTES_ASCENDING,
	EVERYTHING_IPC_SORT_ATTRIBUTES_ASCENDING,
	EVERYTHING_IPC_SORT_FILE_LIST_FILENAME_ASCENDING,
	EVERYTHING_IPC_SORT_RUN_COUNT_DESCENDING,
	EVERYTHING_IPC_SORT_DATE_RECENTLY_CHANGED_DESCENDING,
	EVERYTHING_IPC_SORT_DATE_RECENTLY_CHANGED_DESCENDING,
	EVERYTHING_IPC_SORT_DATE_RECENTLY_CHANGED_DESCENDING,
	EVERYTHING_IPC_SORT_DATE_RECENTLY_CHANGED_DESCENDING,
	EVERYTHING_IPC_SORT_DATE_ACCESSED_DESCENDING,
	EVERYTHING_IPC_SORT_DATE_ACCESSED_DESCENDING,
	EVERYTHING_IPC_SORT_DATE_RUN_DESCENDING,
	EVERYTHING_IPC_SORT_DATE_RUN_DESCENDING,
};

#define MSGFLT_ALLOW		1

typedef struct tagCHANGEFILTERSTRUCT 
{
	DWORD cbSize;
	DWORD ExtStatus;
}CHANGEFILTERSTRUCT, *PCHANGEFILTERSTRUCT;

typedef unsigned __int64 QWORD;

typedef struct es_buf_s
{
	void *buf;
	BYTE stackbuf[ES_BUF_SIZE];
	
}es_buf_t;

void DECLSPEC_NORETURN es_fatal(int error_code);
void es_write(const wchar_t *text);
void es_fwrite(const wchar_t *text);
void es_fwrite_n(const wchar_t *text,int wlen);
void es_write_highlighted(const wchar_t *text);
void es_write_QWORD(QWORD value);
void es_write_DWORD(DWORD value);
int es_wstring_to_int(const wchar_t *s);
int es_wstring_length(const wchar_t *s);
void es_format_number(wchar_t *buf,QWORD number);
int es_sendquery(HWND hwnd);
int es_sendquery2(HWND hwnd);
int es_compare_list_items(const void *a,const void *b);
void es_write_result_count(DWORD result_count);
void es_listresultsW(EVERYTHING_IPC_LIST *list);
void es_listresults2W(EVERYTHING_IPC_LIST2 *list,int index_start,int count);
void es_write_total_size(EVERYTHING_IPC_LIST2 *list,int count);
LRESULT __stdcall es_window_proc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam);
void es_help(void);
HWND es_find_ipc_window(void);
void es_wstring_copy(wchar_t *buf,const wchar_t *s);
void es_wstring_cat(wchar_t *buf,const wchar_t *s);
int es_check_param(wchar_t *param,const wchar_t *s);
int es_wstring_compare_param(wchar_t *param,const wchar_t *s);
void es_set_sort_ascending(void);
void es_set_sort_descending(void);
int es_find_column(int type);
void es_add_column(int type);
void *es_get_column_data(EVERYTHING_IPC_LIST2 *list,int index,int type);
void es_format_dir(wchar_t *buf);
void es_format_size(wchar_t *buf,QWORD size);
void es_format_filetime(wchar_t *buf,QWORD filetime);
void es_wstring_print_qword(wchar_t *buf,QWORD number);
void es_format_attributes(wchar_t *buf,DWORD attributes);
int es_filetime_to_localtime(SYSTEMTIME *localst,QWORD ft);
void es_format_leading_space(wchar_t *buf,int size,int ch);
void es_space_to_width(wchar_t *buf,int wide);
void es_format_run_count(wchar_t *buf,DWORD run_count);
int es_check_param_param(wchar_t *param,const wchar_t *s);
void es_flush(void);
void *es_alloc(uintptr_t size);
void es_free(void *ptr);
void es_fwrite_csv_string(const wchar_t *s);
const wchar_t *es_get_command_argv(const wchar_t *command_line);
const wchar_t *es_get_argv(const wchar_t *command_line);
const wchar_t *es_skip_ws(const wchar_t *p);
int es_is_ws(const wchar_t c);
void es_set_color(int id);
void es_set_column_wide(int id);
void es_fill(int count,int utf8ch);
void es_wstring_cat_qword(wchar_t *buf,QWORD qw);
int es_is_valid_key(INPUT_RECORD *ir);
void es_ini_write_int(const char *name,int value,const char *filename);
void es_ini_write_string(const char *name,const wchar_t *value,const char *filename);
void es_save_settings(void);
int es_ini_read_int(const char *name,int *pvalue,const char *filename);
int es_ini_read_string(const char *name,wchar_t *pvalue,const char *filename);
void es_load_settings(void);
void es_remove_column(type);
void es_append_filter(const wchar_t *filter);
void es_wbuf_cat(wchar_t *buf,int max,const wchar_t *s);
wchar_t *es_wstring_alloc(const wchar_t *s);
void es_do_run_history_command(void);
int es_check_sorts(void);
int es_get_ini_filename(char *buf);
static void es_wait_for_db_loaded(void);
static void es_wait_for_db_not_busy(void);
static void *es_buf_init(es_buf_t *cbuf,uintptr_t size);
static void es_buf_kill(es_buf_t *cbuf);

int es_sort = EVERYTHING_IPC_SORT_NAME_ASCENDING;
int es_sort_ascending = 0; // 0 = default, >0 = ascending, <0 = descending
EVERYTHING_IPC_LIST *es_sort_list;
HMODULE es_user32_hdll = 0;
wchar_t *es_instance = 0;
BOOL (WINAPI *es_pChangeWindowMessageFilterEx)(HWND hWnd,UINT message,DWORD action,PCHANGEFILTERSTRUCT pChangeFilterStruct) = 0;
int es_highlight_color = FOREGROUND_GREEN|FOREGROUND_INTENSITY;
int es_highlight = 0;
int es_match_whole_word = 0;
int es_match_path = 0;
int es_match_case = 0;
int es_match_diacritics = 0;
int es_exit_everything = 0;
int es_reindex = 0;
int es_save_db = 0;
int es_export = ES_EXPORT_NONE;
HANDLE es_export_file = INVALID_HANDLE_VALUE;
unsigned char *es_export_buf = 0;
unsigned char *es_export_p;
int es_export_remaining = 0;
int es_numcolumns = 0;
int es_columns[ES_COLUMN_TOTAL];
int es_size_leading_zero = 0;
int es_run_count_leading_zero = 0;
int es_digit_grouping = 1;
DWORD es_offset = 0;
DWORD es_max_results = EVERYTHING_IPC_ALLRESULTS;
DWORD es_ret = ES_ERROR_SUCCESS;
wchar_t *es_connect = 0;
wchar_t *es_search = 0;
wchar_t *es_filter = 0;
wchar_t *es_argv = 0;
WORD es_column_color[ES_COLUMN_TOTAL];
WORD es_column_color_is_valid[ES_COLUMN_TOTAL] = {0};
WORD es_last_color;
int es_is_last_color = 0;
int es_size_format = 1; // 0 = auto, 1=bytes, 2=kb
int es_date_format = 0; // 0 = system format, 1=iso-8601 (as local time), 2=filetime in decimal, 3=iso-8601 (in utc)
CHAR_INFO *es_cibuf = 0;
int es_max_wide = 0;
int es_console_wide = 80;
int es_console_high = 25;
int es_console_size_high = 25;
int es_console_window_x = 0;
int es_console_window_y = 0;
int es_pause = 0; 
int es_last_page_start = 0; 
int es_cibuf_attributes = 0x07;
int es_cibuf_hscroll = 0;
int es_cibuf_x = 0;
int es_cibuf_y = 0;
int es_empty_search_help = 0;
int es_hide_empty_search_results = 0;
int es_save = 0;
HWND es_everything_hwnd = 0;
DWORD es_timeout = 0;
int es_get_result_count = 0; // 1 = show result count only
int es_get_total_size = 0; // 1 = calculate total result size, only display this total size and exit.
int es_no_result_error = 0; // 1 = set errorlevel if no results found.
HANDLE es_output_handle = 0;
UINT es_cp = 0; // current code page
int es_output_is_file = 1; // default to file, unless we can get the console mode.
int es_default_attributes = 0x07;
void *es_run_history_data = 0; // run count command
DWORD es_run_history_count = 0; // run count command
int es_run_history_command = 0;
int es_run_history_size = 0;
DWORD es_ipc_version = 0xffffffff;
int es_header = 1;
int es_double_quote = 0; // always use double quotes for filenames.
int es_get_everything_version = 0;
int es_utf8_bom = 0;

int es_column_widths[ES_COLUMN_TOTAL] = 
{
	47, // ES_COLUMN_FILENAME,
	30, // ES_COLUMN_NAME,
	47, // ES_COLUMN_PATH,
	47, // ES_COLUMN_HIGHLIGHTED_FILENAME,
	30, // ES_COLUMN_HIGHLIGHTED_NAME,
	47, // ES_COLUMN_HIGHLIGHTED_PATH,
	4, // ES_COLUMN_EXTENSION,
	14, // ES_COLUMN_SIZE,
	16, // ES_COLUMN_DATE_CREATED,
	16, // ES_COLUMN_DATE_MODIFIED,
	16, // ES_COLUMN_DATE_ACCESSED,
	4, // ES_COLUMN_ATTRIBUTES,
	30, // ES_COLUMN_FILE_LIST_FILENAME,
	6, // ES_COLUMN_RUN_COUNT,
	16, // ES_COLUMN_DATE_RUN,
	16, // ES_COLUMN_DATE_RECENTLY_CHANGED,
};

int es_column_is_right_aligned[ES_COLUMN_TOTAL] = 
{
	0, // ES_COLUMN_FILENAME,
	0, // ES_COLUMN_NAME,
	0, // ES_COLUMN_PATH,
	0, // ES_COLUMN_HIGHLIGHTED_FILENAME,
	0, // ES_COLUMN_HIGHLIGHTED_NAME,
	0, // ES_COLUMN_HIGHLIGHTED_PATH,
	0, // ES_COLUMN_EXTENSION,
	1, // ES_COLUMN_SIZE,
	0, // ES_COLUMN_DATE_CREATED,
	0, // ES_COLUMN_DATE_MODIFIED,
	0, // ES_COLUMN_DATE_ACCESSED,
	0, // ES_COLUMN_ATTRIBUTES,
	0, // ES_COLUMN_FILE_LIST_FILENAME,
	1, // ES_COLUMN_RUN_COUNT,
	0, // ES_COLUMN_DATE_RUN,
	0, // ES_COLUMN_DATE_RECENTLY_CHANGED,
};

// get the length in wchars from a wchar string.
int es_wstring_length(const wchar_t *s)
{
	const wchar_t *p;
	
	p = s;
	while(*p)
	{
		p++;
	}
	
	return (int)(p - s);
}

// get the length in wchars from highlighted string
// skips over the '*' parts
int es_wstring_highlighted_length(const wchar_t *s)
{
	const wchar_t *p;
	int len;
	
	len = 0;
	p = s;
	while(*p)
	{
		if (*p == '*')
		{
			p++;
			
			if (*p == '*')
			{
				len++;
				p++;
			}
		}
		else
		{
			p++;
			len++;
		}
	}
	
	return len;
}

// query everything with search string
int es_sendquery(HWND hwnd)
{
	EVERYTHING_IPC_QUERY *query;
	int len;
	int size;
	COPYDATASTRUCT cds;
	int ret;
	es_buf_t cbuf;
	
	ret = 0;
	
	len = es_wstring_length(es_search);
	
	size = sizeof(EVERYTHING_IPC_QUERY) - sizeof(WCHAR) + len*sizeof(WCHAR) + sizeof(WCHAR);
	
	query = es_buf_init(&cbuf,size);

	if (es_get_result_count)
	{
		es_max_results = 0;
	}
	
	query->max_results = es_max_results;
	query->offset = 0;
	query->reply_copydata_message = ES_COPYDATA_IPCTEST_QUERYCOMPLETEW;
	query->search_flags = (es_match_case?EVERYTHING_IPC_MATCHCASE:0) | (es_match_diacritics?EVERYTHING_IPC_MATCHACCENTS:0) | (es_match_whole_word?EVERYTHING_IPC_MATCHWHOLEWORD:0) | (es_match_path?EVERYTHING_IPC_MATCHPATH:0);
	query->reply_hwnd = (DWORD)(uintptr_t)hwnd;
	CopyMemory(query->search_string,es_search,(len+1)*sizeof(WCHAR));

	cds.cbData = size;
	cds.dwData = EVERYTHING_IPC_COPYDATAQUERY;
	cds.lpData = query;

	if (SendMessage(es_everything_hwnd,WM_COPYDATA,(WPARAM)hwnd,(LPARAM)&cds) == TRUE)
	{
		ret = 1;
	}

	es_buf_kill(&cbuf);

	return ret;
}

// query everything with search string
int es_sendquery2(HWND hwnd)
{
	EVERYTHING_IPC_QUERY2 *query;
	int len;
	int size;
	COPYDATASTRUCT cds;
	int ret;
	DWORD request_flags;
	es_buf_t cbuf;
	
	ret = 0;

	len = es_wstring_length(es_search);
	
	size = sizeof(EVERYTHING_IPC_QUERY2) + ((len + 1) * sizeof(WCHAR));

	query = es_buf_init(&cbuf,size);

	request_flags = 0;
	
	{
		int columni;
		
		for(columni=0;columni<es_numcolumns;columni++)
		{
			switch(es_columns[columni])
			{
				case ES_COLUMN_FILENAME:
					request_flags |= EVERYTHING_IPC_QUERY2_REQUEST_FULL_PATH_AND_NAME;
					break;
					
				case ES_COLUMN_NAME:
					request_flags |= EVERYTHING_IPC_QUERY2_REQUEST_NAME;
					break;
					
				case ES_COLUMN_PATH:
					request_flags |= EVERYTHING_IPC_QUERY2_REQUEST_PATH;
					break;
					
				case ES_COLUMN_HIGHLIGHTED_FILENAME:
					request_flags |= EVERYTHING_IPC_QUERY2_REQUEST_HIGHLIGHTED_FULL_PATH_AND_NAME;
					break;
					
				case ES_COLUMN_HIGHLIGHTED_NAME:
					request_flags |= EVERYTHING_IPC_QUERY2_REQUEST_HIGHLIGHTED_NAME;
					break;
					
				case ES_COLUMN_HIGHLIGHTED_PATH:
					request_flags |= EVERYTHING_IPC_QUERY2_REQUEST_HIGHLIGHTED_PATH;
					break;
					
				case ES_COLUMN_EXTENSION:
					request_flags |= EVERYTHING_IPC_QUERY2_REQUEST_EXTENSION;
					break;

				case ES_COLUMN_SIZE:
					request_flags |= EVERYTHING_IPC_QUERY2_REQUEST_SIZE;
					break;

				case ES_COLUMN_DATE_CREATED:
					request_flags |= EVERYTHING_IPC_QUERY2_REQUEST_DATE_CREATED;
					break;

				case ES_COLUMN_DATE_MODIFIED:
					request_flags |= EVERYTHING_IPC_QUERY2_REQUEST_DATE_MODIFIED;
					break;

				case ES_COLUMN_DATE_ACCESSED:
					request_flags |= EVERYTHING_IPC_QUERY2_REQUEST_DATE_ACCESSED;
					break;

				case ES_COLUMN_ATTRIBUTES:
					request_flags |= EVERYTHING_IPC_QUERY2_REQUEST_ATTRIBUTES;
					break;

				case ES_COLUMN_FILE_LIST_FILENAME:
					request_flags |= EVERYTHING_IPC_QUERY2_REQUEST_FILE_LIST_FILE_NAME;
					break;

				case ES_COLUMN_RUN_COUNT:
					request_flags |= EVERYTHING_IPC_QUERY2_REQUEST_RUN_COUNT;
					break;

				case ES_COLUMN_DATE_RUN:
					request_flags |= EVERYTHING_IPC_QUERY2_REQUEST_DATE_RUN;
					break;

				case ES_COLUMN_DATE_RECENTLY_CHANGED:
					request_flags |= EVERYTHING_IPC_QUERY2_REQUEST_DATE_RECENTLY_CHANGED;
					break;
			}
		}
	}
	
	if (es_get_result_count)
	{
		es_max_results = 0;
		request_flags = 0;
	}
	
	if (es_get_total_size)
	{
		// we only want size.
		request_flags = EVERYTHING_IPC_QUERY2_REQUEST_SIZE;
		es_max_results = EVERYTHING_IPC_ALLRESULTS;
	}
	
	query->max_results = es_max_results;
	query->offset = es_offset;
	query->reply_copydata_message = ES_COPYDATA_IPCTEST_QUERYCOMPLETE2W;
	query->search_flags = (es_match_case?EVERYTHING_IPC_MATCHCASE:0) | (es_match_diacritics?EVERYTHING_IPC_MATCHACCENTS:0) | (es_match_whole_word?EVERYTHING_IPC_MATCHWHOLEWORD:0) | (es_match_path?EVERYTHING_IPC_MATCHPATH:0);
	query->reply_hwnd = (DWORD)(uintptr_t)hwnd;
	query->request_flags = request_flags;
	query->sort_type = es_sort;
	CopyMemory(query+1,es_search,(len + 1) * sizeof(WCHAR));

	cds.cbData = size;
	cds.dwData = EVERYTHING_IPC_COPYDATA_QUERY2;
	cds.lpData = query;

	if (SendMessage(es_everything_hwnd,WM_COPYDATA,(WPARAM)hwnd,(LPARAM)&cds) == TRUE)
	{
		ret = 1;
	}

	es_buf_kill(&cbuf);

	return ret;
}

int es_compare_list_items(const void *a,const void *b)
{
	int i;
	
	i = wcsicmp(EVERYTHING_IPC_ITEMPATH(es_sort_list,a),EVERYTHING_IPC_ITEMPATH(es_sort_list,b));
	
	if (!i)
	{
		return wcsicmp(EVERYTHING_IPC_ITEMFILENAME(es_sort_list,a),EVERYTHING_IPC_ITEMFILENAME(es_sort_list,b));
	}
	else
	if (i > 0)
	{
		return 1;
	}
	else
	{
		return -1;
	}
}

void DECLSPEC_NORETURN es_fatal(int error_code)
{
	const char *msg;
	int show_help;
	
	msg = 0;
	show_help = 0;

	switch(error_code)
	{
		case ES_ERROR_REGISTER_WINDOW_CLASS:
			msg = "Error 1: Failed to register window class.\r\n";
			break;
			
		case ES_ERROR_CREATE_WINDOW:
			msg = "Error 2: Failed to create window.\r\n";
			break;
			
		case ES_ERROR_OUT_OF_MEMORY:
			msg = "Error 3: Out of memory.\r\n";
			break;
			
		case ES_ERROR_EXPECTED_SWITCH_PARAMETER:
			msg = "Error 4: Expected switch parameter.\r\n";
			// this error is permanent, show help:
			show_help = 1;
			break;
			
		case ES_ERROR_CREATE_FILE:
			msg = "Error 5: Failed to create output file.\r\n";
			break;
			
		case ES_ERROR_UNKNOWN_SWITCH:
			msg = "Error 6: Unknown switch.\r\n";
			// this error is permanent, show help:
			show_help = 1;
			break;
			
		case ES_ERROR_SEND_MESSAGE:
			msg = "Error 7: Unable to send IPC message.\r\n";
			break;
			
		case ES_ERROR_IPC:
			msg = "Error 8: Everything IPC window not found. Please make sure Everything is running.\r\n";
			break;
			
		case ES_ERROR_NO_RESULTS:
			msg = "Error 9: No results found.\r\n";
			break;
	}
	
	if (msg)
	{
		DWORD numwritten;
		
		// msg is ASCII only.
		WriteFile(GetStdHandle(STD_ERROR_HANDLE),msg,(int)strlen(msg),&numwritten,0);
	}
	
	if (show_help)
	{
		es_help();
	}

	ExitProcess(error_code);
}

void es_write(const wchar_t *text)
{
	int wlen;
	
	wlen = es_wstring_length(text);
	
	if (es_cibuf)
	{
		int i;
		
		for(i=0;i<wlen;i++)
		{
			if (i + es_cibuf_x >= es_console_wide)
			{
				break;
			}

			if (i + es_cibuf_x >= 0)
			{
				es_cibuf[i+es_cibuf_x].Attributes = es_cibuf_attributes;
				es_cibuf[i+es_cibuf_x].Char.UnicodeChar = text[i];
			}
		}
		
		es_cibuf_x += wlen;
	}
	else
	{
		// pipe?
		if (es_output_is_file)
		{
			int len;
			
			len = WideCharToMultiByte(es_cp,0,text,wlen,0,0,0,0);
			if (len)
			{
				DWORD numwritten;
				es_buf_t cbuf;

				es_buf_init(&cbuf,len);

				WideCharToMultiByte(es_cp,0,text,wlen,cbuf.buf,len,0,0);
				
				WriteFile(es_output_handle,cbuf.buf,len,&numwritten,0);
				
				es_buf_kill(&cbuf);
			}
		}
		else
		{
			DWORD numwritten;
			
			WriteConsoleW(es_output_handle,text,wlen,&numwritten,0);
		}
	}
}

void es_fill(int count,int utf8ch)
{
	if (es_cibuf)
	{
		int i;
		
		for(i=0;i<count;i++)
		{
			if (i + es_cibuf_x >= es_console_wide)
			{
				break;
			}

			if (i + es_cibuf_x >= 0)
			{
				es_cibuf[i+es_cibuf_x].Attributes = es_cibuf_attributes;
				es_cibuf[i+es_cibuf_x].Char.UnicodeChar = utf8ch;
			}
		}
		
		es_cibuf_x += count;
	}
	else
	{
		es_buf_t cbuf;
		unsigned char *p;
		DWORD numwritten;
		int i;
		
		es_buf_init(&cbuf,count);

		p = cbuf.buf;
		
		for(i=0;i<count;i++)
		{
			*p++ = utf8ch;
		}

 		WriteFile(es_output_handle,cbuf.buf,count,&numwritten,0);
		
		es_buf_kill(&cbuf);
	}
}

// set wlen to -1 for null terminated text.
void es_fwrite_n(const wchar_t *text,int wlen)
{
	if (wlen)
	{
		if (es_export_file != INVALID_HANDLE_VALUE)
		{
			int len;
			DWORD numwritten;
			int cp;
			es_buf_t cbuf;
			
			cp = CP_UTF8;

			if (es_export == ES_EXPORT_M3U)		
			{
				cp = CP_ACP;
			}
			
			len = WideCharToMultiByte(cp,0,text,wlen,0,0,0,0);
			
			es_buf_init(&cbuf,len);

			len = WideCharToMultiByte(cp,0,text,wlen,cbuf.buf,len,0,0);
			
			if (wlen < 0)
			{
				// remove null from len.
				if (len) 
				{
					len--;
				}
			}
			
			if (len > es_export_remaining)
			{
				es_flush();
				
				if (len >= ES_EXPORT_BUF_SIZE)
				{
					WriteFile(es_export_file,cbuf.buf,len,&numwritten,0);
					
					goto copied;
				}
			}

			es_export_remaining -= len;
			CopyMemory(es_export_p,cbuf.buf,len);
			es_export_p += len;

	copied:
			
			es_buf_kill(&cbuf);
		}
		else
		{
			es_write(text);
		}
	}
}

void es_fwrite(const wchar_t *text)
{
	es_fwrite_n(text,-1);
}

void es_fwrite_csv_string(const wchar_t *s)
{
	const wchar_t *start;
	const wchar_t *p;
	
	es_fwrite(L"\"");
	
	// escape double quotes with double double quotes.
	start = s;
	p = s;
	
	while(*p)
	{
		if (*p == '"')
		{
			es_fwrite_n(start,(int)(p-start));

			// escape double quotes with double double quotes.
			es_fwrite(L"\"");
			es_fwrite(L"\"");
			
			start = p + 1;
		}
		
		p++;
	}

	es_fwrite_n(start,(int)(p-start));
	
	es_fwrite(L"\"");
}

void es_flush(void)
{
	if (es_export_file != INVALID_HANDLE_VALUE)
	{
		if (es_export_remaining != ES_EXPORT_BUF_SIZE)
		{
			DWORD numwritten;
			
			WriteFile(es_export_file,es_export_buf,ES_EXPORT_BUF_SIZE - es_export_remaining,&numwritten,0);
			
			es_export_p = es_export_buf;
			es_export_remaining = ES_EXPORT_BUF_SIZE;
		}	
	}
}

void es_write_highlighted(const wchar_t *text)
{
	if (es_cibuf)
	{
		const wchar_t *p;
		int highlighted;
		
		highlighted = 0;
		
		p = text;
		while(*p)
		{
			int i;
			const wchar_t *start;
			int toggle_highlight;
			int wlen;
			
			start = p;
			toggle_highlight = 0;
			
			for(;;)
			{
				if (!*p)
				{
					wlen = (int)(p-start);

					break;
				}
				
				if (*p == '*')
				{
					if (p[1] == '*')
					{
						// include one literal *
						wlen = (int)(p+1-start);
						p+=2;
						break;
					}
					
					wlen = (int)(p-start);
					p++;
					toggle_highlight = 1;
					break;
				}
				
				p++;
			}
		
			for(i=0;i<wlen;i++)
			{
				if (i + es_cibuf_x >= es_console_wide)
				{
					break;
				}

				if (i + es_cibuf_x >= 0)
				{
					es_cibuf[i+es_cibuf_x].Attributes = es_cibuf_attributes;
					es_cibuf[i+es_cibuf_x].Char.UnicodeChar = start[i];
				}
			}
			
			es_cibuf_x += wlen;

			// skip *				
			if (toggle_highlight)
			{
				highlighted = !highlighted;

				if (highlighted)
				{
					es_cibuf_attributes = es_highlight_color;
				}
				else
				{
					if (es_is_last_color)
					{
						es_cibuf_attributes = es_last_color;
					}
					else
					{
						es_cibuf_attributes = es_default_attributes;
					}
				}				
			}			
		}
	}
	else
	{
		const wchar_t *p;
		int highlighted;
		int attributes;
		
		if (es_is_last_color)
		{
			attributes = es_last_color;
		}
		else
		{
			attributes = es_default_attributes;
		}
		
		highlighted = 0;
		
		p = text;
		while(*p)
		{
			const wchar_t *start;
			int toggle_highlight;
			int wlen;
			
			start = p;
			toggle_highlight = 0;
			
			for(;;)
			{
				if (!*p)
				{
					wlen = (int)(p-start);

					break;
				}
				
				if (*p == '*')
				{
					if (p[1] == '*')
					{
						// include one literal *
						wlen = (int)(p+1-start);
						p+=2;
						break;
					}
					
					wlen = (int)(p-start);
					p++;
					toggle_highlight = 1;
					break;
				}
				
				p++;
			}
		
			if (es_output_is_file)
			{
				int mblen;
				
				mblen = WideCharToMultiByte(es_cp,0,start,wlen,0,0,0,0);
				if (mblen)
				{
					DWORD numwritten;
					es_buf_t cbuf;
					
					es_buf_init(&cbuf,mblen);
					
					WideCharToMultiByte(es_cp,0,start,wlen,cbuf.buf,mblen,0,0);
					
					WriteFile(es_output_handle,cbuf.buf,mblen,&numwritten,0);
					
					es_buf_kill(&cbuf);
				}			
			}
			else
			{
				DWORD numwritten;
				
				WriteConsoleW(es_output_handle,start,wlen,&numwritten,0);
			}
			
			if (toggle_highlight)
			{
				highlighted = !highlighted;

				if (highlighted)
				{
					es_cibuf_attributes = es_highlight_color;
					SetConsoleTextAttribute(es_output_handle,es_highlight_color);
				}
				else
				{
					es_cibuf_attributes = attributes;
					SetConsoleTextAttribute(es_output_handle,attributes);
				}
			}
		}
	}
}

void es_write_QWORD(QWORD value)
{
	wchar_t buf[ES_WSTRING_SIZE];
	wchar_t *d;
	
	d = buf + ES_WSTRING_SIZE;
	*--d = 0;

	if (value)
	{
		QWORD i;
		
		i = value;
		
		while(i)
		{
			*--d = (wchar_t)('0' + (i % 10));
			
			i /= 10;
		}
	}
	else
	{
		*--d = '0';
	}	
	
	es_write(d);
}

void es_write_DWORD(DWORD value)
{
	es_write_QWORD(value);
}

void es_write_result_count(DWORD result_count)
{
	es_write_DWORD(result_count);
	es_write(L"\r\n");
}

void es_listresultsW(EVERYTHING_IPC_LIST *list)
{
	if (es_no_result_error)
	{
		if (list->totitems == 0)
		{
			es_ret = ES_ERROR_NO_RESULTS;
		}
	}

	if (es_get_result_count)
	{
		es_write_result_count(list->totitems);
	}
	else
	if (es_get_total_size)
	{
		// version 2 IPC unavailable.
		es_ret = ES_ERROR_IPC;
	}
	else
	{
		DWORD i;
		
		if (es_sort == EVERYTHING_IPC_SORT_PATH_ASCENDING)
		{
			es_sort_list = list;
			qsort(list->items,list->numitems,sizeof(EVERYTHING_IPC_ITEM),es_compare_list_items);
		}
			
		
		for(i=0;i<list->numitems;i++)
		{
			if (list->items[i].flags & EVERYTHING_IPC_DRIVE)
			{
				es_write(EVERYTHING_IPC_ITEMFILENAME(list,&list->items[i]));
				es_write(L"\r\n");
			}
			else
			{
				es_write(EVERYTHING_IPC_ITEMPATH(list,&list->items[i]));
				es_write(L"\\");
				es_write(EVERYTHING_IPC_ITEMFILENAME(list,&list->items[i]));
				es_write(L"\r\n");
			}
		}
	}
	
	PostQuitMessage(0);
}

void es_listresults2W(EVERYTHING_IPC_LIST2 *list,int index_start,int count)
{
	DWORD i;
	EVERYTHING_IPC_ITEM2 *items;
	
	items = (EVERYTHING_IPC_ITEM2 *)(list + 1);

	es_cibuf_y = 0;
	i = index_start;
	
	while(count)
	{
		if (i >= list->numitems)
		{
			break;
		}
	
		es_cibuf_x = -es_cibuf_hscroll;
		
		if ((es_export == ES_EXPORT_CSV) || (es_export == ES_EXPORT_TSV))
		{
			int columni;
			
			for(columni=0;columni<es_numcolumns;columni++)
			{
				void *data;
				
				if (columni)
				{
					es_fwrite((es_export == ES_EXPORT_CSV) ? L"," : L"\t");
				}
				
				data = es_get_column_data(list,i,es_columns[columni]);
				
				if (data)
				{
					switch(es_columns[columni])
					{
						case ES_COLUMN_NAME:
							es_fwrite_csv_string((wchar_t *)((char *)data+sizeof(DWORD)));
							break;
							
						case ES_COLUMN_PATH:
							es_fwrite_csv_string((wchar_t *)((char *)data+sizeof(DWORD)));
							break;
							
						case ES_COLUMN_FILENAME:
							es_fwrite_csv_string((wchar_t *)((char *)data+sizeof(DWORD)));
							break;
							
						case ES_COLUMN_HIGHLIGHTED_NAME:
							es_fwrite_csv_string((wchar_t *)((char *)data+sizeof(DWORD)));
							break;
							
						case ES_COLUMN_HIGHLIGHTED_PATH:
							es_fwrite_csv_string((wchar_t *)((char *)data+sizeof(DWORD)));
							break;
							
						case ES_COLUMN_HIGHLIGHTED_FILENAME:
							es_fwrite_csv_string((wchar_t *)((char *)data+sizeof(DWORD)));
							break;
							
						case ES_COLUMN_EXTENSION:
							es_fwrite_csv_string((wchar_t *)((char *)data+sizeof(DWORD)));
							break;
							
						case ES_COLUMN_SIZE:
						{
							wchar_t column_buf[ES_WSTRING_SIZE];
							
							if ((items[i].flags & EVERYTHING_IPC_FOLDER) && (*(QWORD *)data == 0xffffffffffffffffI64))
							{
								column_buf[0] = 0;
							}
							else
							{
								es_wstring_print_qword(column_buf,*(QWORD *)data);
							}
							
							es_fwrite(column_buf);
							
							break;
						}

						case ES_COLUMN_DATE_MODIFIED:
						{
							wchar_t column_buf[ES_WSTRING_SIZE];
							
							es_format_filetime(column_buf,*(QWORD *)data);
							es_fwrite(column_buf);
							break;
						}

						case ES_COLUMN_DATE_CREATED:
						{
							wchar_t column_buf[ES_WSTRING_SIZE];
							
							es_format_filetime(column_buf,*(QWORD *)data);
							es_fwrite(column_buf);
							break;
						}

						case ES_COLUMN_DATE_ACCESSED:
						{
							wchar_t column_buf[ES_WSTRING_SIZE];
							
							es_format_filetime(column_buf,*(QWORD *)data);
							es_fwrite(column_buf);
							break;
						}

						case ES_COLUMN_ATTRIBUTES:
						{
							wchar_t column_buf[ES_WSTRING_SIZE];
							
							es_format_attributes(column_buf,*(DWORD *)data);
							es_fwrite(column_buf);
							break;
						}

						case ES_COLUMN_FILE_LIST_FILENAME:
						{
							es_fwrite_csv_string((wchar_t *)((char *)data+sizeof(DWORD)));
							break;
						}
						
						case ES_COLUMN_RUN_COUNT:
						{
							wchar_t column_buf[ES_WSTRING_SIZE];
							
							es_wstring_print_qword(column_buf,*(DWORD *)data);
							es_fwrite(column_buf);
							break;
						}	
											
						case ES_COLUMN_DATE_RUN:
						{
							wchar_t column_buf[ES_WSTRING_SIZE];
							
							es_format_filetime(column_buf,*(QWORD *)data);
							es_fwrite(column_buf);
							break;
						}		
															
						case ES_COLUMN_DATE_RECENTLY_CHANGED:
						{
							wchar_t column_buf[ES_WSTRING_SIZE];
							
							es_format_filetime(column_buf,*(QWORD *)data);
							es_fwrite(column_buf);
							break;
						}						
					}
				}
			}

			es_fwrite(L"\r\n");
		}
		else
		if (es_export == ES_EXPORT_EFU)
		{
			void *data;
				
			// Filename
			data = es_get_column_data(list,i,ES_COLUMN_FILENAME);
			if (data)
			{
				es_fwrite_csv_string((wchar_t *)((char *)data+sizeof(DWORD)));
			}

			es_fwrite(L",");
			
			// size
			data = es_get_column_data(list,i,ES_COLUMN_SIZE);
			if (data)
			{
				wchar_t column_buf[ES_WSTRING_SIZE];
				
				if (*(QWORD *)data != 0xffffffffffffffffI64)
				{
					es_wstring_print_qword(column_buf,*(QWORD *)data);
					es_fwrite(column_buf);
				}
			}

			es_fwrite(L",");

			// date modified
			data = es_get_column_data(list,i,ES_COLUMN_DATE_MODIFIED);
			if (data)
			{
				if ((*(QWORD *)data != 0xffffffffffffffffI64))
				{
					wchar_t column_buf[ES_WSTRING_SIZE];
					
					es_wstring_print_qword(column_buf,*(QWORD *)data);
					es_fwrite(column_buf);
				}
			}

			es_fwrite(L",");

			// date created
			data = es_get_column_data(list,i,ES_COLUMN_DATE_CREATED);
			if (data)
			{
				if ((*(QWORD *)data != 0xffffffffffffffffI64))
				{
					wchar_t column_buf[ES_WSTRING_SIZE];
					
					es_wstring_print_qword(column_buf,*(QWORD *)data);
					es_fwrite(column_buf);
				}
			}

			es_fwrite(L",");

			// date created
			data = es_get_column_data(list,i,ES_COLUMN_ATTRIBUTES);
			if (data)
			{
				wchar_t column_buf[ES_WSTRING_SIZE];
						
				es_wstring_print_qword(column_buf,*(DWORD *)data);
				es_fwrite(column_buf);
			}
			else
			{
				DWORD file_attributes;
				wchar_t column_buf[ES_WSTRING_SIZE];
				
				// add file/folder attributes.
				if (items[i].flags & EVERYTHING_IPC_FOLDER)
				{
					file_attributes = FILE_ATTRIBUTE_DIRECTORY;
				}
				else
				{
					file_attributes = 0;
				}

				es_wstring_print_qword(column_buf,file_attributes);
				es_fwrite(column_buf);
			}

			es_fwrite(L"\r\n");
		}
		else
		if ((es_export == ES_EXPORT_TXT) || (es_export == ES_EXPORT_M3U) || (es_export == ES_EXPORT_M3U8))
		{
			void *data;
			
			data = es_get_column_data(list,i,ES_COLUMN_FILENAME);
			
			if (es_double_quote)
			{
				es_fwrite(L"\"");
			}
			
			if (data)
			{
				es_fwrite((wchar_t *)((char *)data+sizeof(DWORD)));
			}

			if (es_double_quote)
			{
				es_fwrite(L"\"");
			}
			
			es_fwrite(L"\r\n");
		}
		else
		{
			int columni;
			int did_set_color;
			int tot_column_text_len;
			int tot_column_width;
			
			tot_column_text_len = 0;
			tot_column_width = 0;

			for(columni=0;columni<es_numcolumns;columni++)
			{
				void *data;
				const wchar_t *column_text;
				int column_is_highlighted;
				int column_is_double_quote;
				wchar_t column_buf[ES_WSTRING_SIZE];
				
				if (columni)
				{
					es_write(L" ");
					tot_column_text_len++;
					tot_column_width++;
				}
				
				data = es_get_column_data(list,i,es_columns[columni]);

				es_is_last_color = 0;
				did_set_color = 0;
				
				column_text = L"";
				column_is_highlighted = 0;
				column_is_double_quote = 0;

				if (data)
				{
					if (!es_output_is_file)
					{
						if (es_column_color_is_valid[es_columns[columni]])
						{
							es_cibuf_attributes = es_column_color[es_columns[columni]];
							SetConsoleTextAttribute(es_output_handle,es_column_color[es_columns[columni]]);

							es_last_color = es_column_color[es_columns[columni]];
							es_is_last_color = 1;

							did_set_color = 1;
						}
					}

					switch(es_columns[columni])
					{
						case ES_COLUMN_NAME:
							column_text = (wchar_t *)((char *)data+sizeof(DWORD));
							column_is_double_quote = es_double_quote;
							break;
							
						case ES_COLUMN_PATH:
							column_text = (wchar_t *)((char *)data+sizeof(DWORD));
							column_is_double_quote = es_double_quote;
							break;
							
						case ES_COLUMN_FILENAME:
							column_text = (wchar_t *)((char *)data+sizeof(DWORD));
							column_is_double_quote = es_double_quote;
							break;
							
						case ES_COLUMN_HIGHLIGHTED_NAME:
							column_text = (wchar_t *)((char *)data+sizeof(DWORD));
							column_is_highlighted = 1;
							column_is_double_quote = es_double_quote;
							break;
							
						case ES_COLUMN_HIGHLIGHTED_PATH:
							column_text = (wchar_t *)((char *)data+sizeof(DWORD));
							column_is_highlighted = 1;
							column_is_double_quote = es_double_quote;
							break;
							
						case ES_COLUMN_HIGHLIGHTED_FILENAME:
							column_text = (wchar_t *)((char *)data+sizeof(DWORD));
							column_is_highlighted = 1;
							column_is_double_quote = es_double_quote;
							break;
							
						case ES_COLUMN_EXTENSION:
						{
							column_text = (wchar_t *)((char *)data+sizeof(DWORD));
							break;
						}
							
						case ES_COLUMN_SIZE:
						{
							
							if ((items[i].flags & EVERYTHING_IPC_FOLDER) && (*(QWORD *)data == 0xffffffffffffffffI64))
							{
								es_format_dir(column_buf);
							}
							else
							{
								es_format_size(column_buf,*(QWORD *)data);
							}

							column_text = column_buf;

							break;
						}

						case ES_COLUMN_DATE_CREATED:
						{
							es_format_filetime(column_buf,*(QWORD *)data);

							column_text = column_buf;
							break;
						}
						
						case ES_COLUMN_DATE_MODIFIED:
						{
							es_format_filetime(column_buf,*(QWORD *)data);
							column_text = column_buf;
							break;
						}
						
						case ES_COLUMN_DATE_ACCESSED:
						{
							es_format_filetime(column_buf,*(QWORD *)data);
							column_text = column_buf;
							break;
						}
						
						case ES_COLUMN_ATTRIBUTES:
						{
							es_format_attributes(column_buf,*(DWORD *)data);
							column_text = column_buf;
							break;
						}

						case ES_COLUMN_FILE_LIST_FILENAME:
						{
							column_text = (wchar_t *)((char *)data+sizeof(DWORD));
							break;
						}
						
						case ES_COLUMN_RUN_COUNT:
						{
							es_format_run_count(column_buf,*(DWORD *)data);
							column_text = column_buf;
							break;
						}	
											
						case ES_COLUMN_DATE_RUN:
						{
							es_format_filetime(column_buf,*(QWORD *)data);
							column_text = column_buf;
							break;
						}		
															
						case ES_COLUMN_DATE_RECENTLY_CHANGED:
						{
							es_format_filetime(column_buf,*(QWORD *)data);
							column_text = column_buf;
							break;
						}
					}

					//es_column_widths
					{
						int column_text_len;
						int fill;
						int column_width;
						int is_right_aligned;
						
						is_right_aligned = es_column_is_right_aligned[es_columns[columni]];
						
						if (is_right_aligned)
						{
							// check for right aligned dir
							// and make it left aligned.
							if (*column_text == '<')
							{
								is_right_aligned = 0;
							}
						}
						
						if (column_is_highlighted)
						{
							column_text_len = es_wstring_highlighted_length(column_text);
						}
						else
						{
							column_text_len = es_wstring_length(column_text);
						}
						
						if (column_is_double_quote)
						{
							column_text_len += 2;
						}
						
						column_width = es_column_widths[es_columns[columni]];
						
						// left fill
						if (is_right_aligned)
						{
							if (tot_column_width + column_width > (tot_column_text_len + column_text_len))
							{
								int fillch;
								
								fill = tot_column_width + column_width - (tot_column_text_len + column_text_len);

								fillch = ' ';
								
								if (!es_digit_grouping)
								{
									if (es_columns[columni] == ES_COLUMN_SIZE)
									{
										fillch = es_size_leading_zero ? '0' : ' ';
									}
									else
									if (es_columns[columni] == ES_COLUMN_RUN_COUNT)
									{
										fillch = es_run_count_leading_zero ? '0' : ' ';
									}
								}
							
								// left spaces.
								es_fill(fill,fillch);
								tot_column_text_len += fill;
							}
						}

						if (column_is_double_quote)
						{
							es_write(L"\"");
						}

						// write text.
						if (column_is_highlighted)
						{
							es_write_highlighted(column_text);
						}
						else
						{
							es_write(column_text);
						}
				
						if (column_is_double_quote)
						{
							es_write(L"\"");
						}

						// right fill
						if (!is_right_aligned)
						{
							if (tot_column_width + column_width > (tot_column_text_len + column_text_len))
							{
								fill = tot_column_width + column_width - (tot_column_text_len + column_text_len);

								// dont right fill last column.
								if (columni != es_numcolumns - 1)
								{
									// right spaces.
									es_fill(fill,' ');
									tot_column_text_len += fill;
								}
							}
						}
							
									
						tot_column_text_len += column_text_len;
						tot_column_width += es_column_widths[es_columns[columni]];
					}

					// restore color
					if (did_set_color)
					{
						es_cibuf_attributes = es_default_attributes;
						SetConsoleTextAttribute(es_output_handle,es_default_attributes);
					}
				}
			}
			
			if (es_pause)
			{
				// fill right side of screen
				if (es_cibuf)
				{
					int wlen;
					
					if (es_cibuf_x)
					{
						if (es_cibuf_x + es_cibuf_hscroll > es_max_wide)
						{
							es_max_wide = es_cibuf_x + es_cibuf_hscroll;
						}
					}
			
					wlen = es_console_wide - es_cibuf_x;
					
					if (wlen > 0)
					{
						int bufi;
						
						for(bufi=0;bufi<wlen;bufi++)
						{
							if (bufi + es_cibuf_x >= es_console_wide)
							{
								break;
							}

							if (bufi + es_cibuf_x >= 0)
							{
								es_cibuf[bufi+es_cibuf_x].Attributes = es_cibuf_attributes;
								es_cibuf[bufi+es_cibuf_x].Char.UnicodeChar = ' ';
							}
						}
					}
					
					// draw buffer line.
					{
						COORD buf_size;
						COORD buf_pos;
						SMALL_RECT write_rect;
						
						buf_size.X = es_console_wide;
						buf_size.Y = 1;
						
						buf_pos.X = 0;
						buf_pos.Y = 0;
						
						write_rect.Left = es_console_window_x;
						write_rect.Top = es_console_window_y + es_cibuf_y;
						write_rect.Right = es_console_window_x + es_console_wide;
						write_rect.Bottom = es_console_window_y + es_cibuf_y + 1;
						
						WriteConsoleOutput(es_output_handle,es_cibuf,buf_size,buf_pos,&write_rect);
						
						es_cibuf_x += wlen;				
					}
				}			
			}
			else
			{
				es_write(L"\r\n");
			}
		}

		es_cibuf_y++;
		count--;
		i++;
	}
}

void es_write_total_size(EVERYTHING_IPC_LIST2 *list,int count)
{
	DWORD i;
	EVERYTHING_IPC_ITEM2 *items;
	QWORD total_size;
	
	items = (EVERYTHING_IPC_ITEM2 *)(list + 1);

	i = 0;
	total_size = 0;
	
	while(count)
	{
		void *data;
		
		if (i >= list->numitems)
		{
			break;
		}
	
		data = es_get_column_data(list,i,ES_COLUMN_SIZE);

		if (data)
		{
			// dont count folders
			if (!(items[i].flags & EVERYTHING_IPC_FOLDER))
			{
				total_size += *(QWORD *)data;
			}
		}

		count--;
		i++;
	}

	es_write_QWORD(total_size);
	es_write(L"\r\n");
}

// custom window proc
LRESULT __stdcall es_window_proc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
	switch(msg)
	{
		case WM_COPYDATA:
		{
			COPYDATASTRUCT *cds = (COPYDATASTRUCT *)lParam;
			
			switch(cds->dwData)
			{
				case ES_COPYDATA_IPCTEST_QUERYCOMPLETEW:
					es_listresultsW((EVERYTHING_IPC_LIST *)cds->lpData);
					return TRUE;
					
				case ES_COPYDATA_IPCTEST_QUERYCOMPLETE2W:
				{
					if (es_no_result_error)
					{
						if (((EVERYTHING_IPC_LIST2 *)cds->lpData)->totitems == 0)
						{
							es_ret = ES_ERROR_NO_RESULTS;
						}
					}
				
					if (es_get_result_count)
					{
						es_write_result_count(((EVERYTHING_IPC_LIST2 *)cds->lpData)->totitems);
					}
					else
					if (es_get_total_size)
					{
						es_write_total_size((EVERYTHING_IPC_LIST2 *)cds->lpData,((EVERYTHING_IPC_LIST2 *)cds->lpData)->numitems);
					}
					else
					if ((int)((EVERYTHING_IPC_LIST2 *)cds->lpData)->numitems)
					{
						if (es_pause)
						{
							HANDLE std_input_handle;
							int start_index;
							int last_start_index;
							int last_hscroll;
							int info_line;
							
							info_line = es_console_high - 1;
							
							if (info_line > (int)((EVERYTHING_IPC_LIST2 *)cds->lpData)->numitems)
							{
								info_line = (int)((EVERYTHING_IPC_LIST2 *)cds->lpData)->numitems;
							}
							
							// push lines above up.
							{
								int i;
								
								if (es_console_window_y + info_line + 1 > es_console_size_high)
								{
									for(i=0;i<(es_console_window_y + info_line + 1) - es_console_size_high;i++)
									{
										DWORD numwritten;
										
										WriteFile(es_output_handle,"\r\n",2,&numwritten,0);
									}
																
									es_console_window_y = es_console_size_high - (info_line + 1);
								}
							}
							
							std_input_handle = GetStdHandle(STD_INPUT_HANDLE);

							es_cibuf = es_alloc(es_console_wide * sizeof(CHAR_INFO));
							
							// set cursor pos to the bottom of the screen
							{
								COORD cur_pos;
								cur_pos.X = es_console_window_x;
								cur_pos.Y = es_console_window_y + info_line;
								
								SetConsoleCursorPosition(es_output_handle,cur_pos);
							}

							// write out some basic usage at the bottom
							{
								DWORD numwritten;
						
								WriteFile(es_output_handle,ES_PAUSE_TEXT,(int)strlen(ES_PAUSE_TEXT),&numwritten,0);
							}
						
							start_index = 0;
							last_start_index = 0;
							last_hscroll = 0;
						
							for(;;)
							{
								INPUT_RECORD ir;
								DWORD numread;

								es_listresults2W((EVERYTHING_IPC_LIST2 *)cds->lpData,start_index,es_console_high-1);
								
								// is everything is shown?
								if (es_max_wide <= es_console_wide)
								{
									if (((int)((EVERYTHING_IPC_LIST2 *)cds->lpData)->numitems) < es_console_high)
									{
										goto exit;
									}
								}
								
start:
								
								for(;;)
								{
									if (PeekConsoleInput(std_input_handle,&ir,1,&numread)) 
									{
										if (numread)
										{
											ReadConsoleInput(std_input_handle,&ir,1,&numread);

											if ((ir.EventType == KEY_EVENT) && (ir.Event.KeyEvent.bKeyDown))
											{
												if (ir.Event.KeyEvent.wVirtualKeyCode == VK_RETURN)
												{
													if ((int)((EVERYTHING_IPC_LIST2 *)cds->lpData)->numitems < es_console_high + 1)
													{
														goto exit;
													}
													if (start_index == (int)((EVERYTHING_IPC_LIST2 *)cds->lpData)->numitems - es_console_high + 1)
													{
														goto exit;
													}
													start_index += 1;
													break;
												}
												else
												if (ir.Event.KeyEvent.wVirtualKeyCode == VK_SPACE)
												{
													if ((int)((EVERYTHING_IPC_LIST2 *)cds->lpData)->numitems < es_console_high + 1)
													{
														goto exit;
													}
													
													if (start_index == (int)((EVERYTHING_IPC_LIST2 *)cds->lpData)->numitems - es_console_high + 1)
													{
														goto exit;
													}
													
													// fall through
												}
												else
												if (ir.Event.KeyEvent.wVirtualKeyCode == VK_RIGHT)
												{
													es_cibuf_hscroll += 5;
													
													if (es_max_wide > es_console_wide)
													{
														if (es_cibuf_hscroll > es_max_wide - es_console_wide)
														{
															es_cibuf_hscroll = es_max_wide - es_console_wide;
														}
													}
													else
													{
														es_cibuf_hscroll = 0;
													}
													break;
												}
												else
												if (ir.Event.KeyEvent.wVirtualKeyCode == VK_LEFT)
												{
													es_cibuf_hscroll -= 5;
													if (es_cibuf_hscroll < 0)
													{
														es_cibuf_hscroll = 0;
													}
													break;
												}
												else
												if (ir.Event.KeyEvent.wVirtualKeyCode == VK_UP)
												{
													start_index -= 1;
													break;
												}
												else
												if (ir.Event.KeyEvent.wVirtualKeyCode == VK_DOWN)
												{
													start_index += 1;
													break;
												}
												else
												if (ir.Event.KeyEvent.wVirtualKeyCode == VK_PRIOR)
												{
													start_index -= es_console_high - 1;
													break;
												}
												else
												if (ir.Event.KeyEvent.wVirtualKeyCode == VK_HOME)
												{
													start_index = 0;
													break;
												}
												else
												if (ir.Event.KeyEvent.wVirtualKeyCode == VK_END)
												{
													start_index = ((EVERYTHING_IPC_LIST2 *)cds->lpData)->numitems - es_console_high + 1;
													break;
												}
												else
												if ((ir.Event.KeyEvent.wVirtualKeyCode == 'Q') || (ir.Event.KeyEvent.wVirtualKeyCode == VK_ESCAPE))
												{
													goto exit;
												}
												else
												if (es_is_valid_key(&ir))
												{
													start_index += es_console_high - 1;
													break;
												}
											}
										}
									}
							
									Sleep(1);
								}
								
								// clip start index.
								if (start_index < 0)
								{
									start_index = 0;
								}
								else
								if ((int)((EVERYTHING_IPC_LIST2 *)cds->lpData)->numitems > es_console_high + 1)
								{
									if (start_index > (int)((EVERYTHING_IPC_LIST2 *)cds->lpData)->numitems - es_console_high + 1)
									{
										start_index = ((EVERYTHING_IPC_LIST2 *)cds->lpData)->numitems - es_console_high + 1;
									}
								}
								else
								{
									start_index = 0;
								}
								
								if (last_start_index != start_index)
								{
									last_start_index = start_index;
								}
								else
								if (last_hscroll != es_cibuf_hscroll)
								{
									last_hscroll = es_cibuf_hscroll;
								}
								else
								{
									goto start;
								}
							}
							
	exit:						
							
							// remove text.
							if (es_cibuf)
							{
								// set cursor pos to the bottom of the screen
								{
									COORD cur_pos;
									cur_pos.X = es_console_window_x;
									cur_pos.Y = es_console_window_y + info_line;
									
									SetConsoleCursorPosition(es_output_handle,cur_pos);
								}

								// write out some basic usage at the bottom
								{
									DWORD numwritten;
							
									WriteFile(es_output_handle,ES_BLANK_PAUSE_TEXT,(int)strlen(ES_BLANK_PAUSE_TEXT),&numwritten,0);
								}
							
								// reset cursor pos.
								{
									COORD cur_pos;
									cur_pos.X = es_console_window_x;
									cur_pos.Y = es_console_window_y + info_line;
									
									SetConsoleCursorPosition(es_output_handle,cur_pos);
								}
								
								// free
								es_free(es_cibuf);
							}								
						}
						else
						{
							es_listresults2W((EVERYTHING_IPC_LIST2 *)cds->lpData,0,((EVERYTHING_IPC_LIST2 *)cds->lpData)->numitems);
						}
					}
	
					PostQuitMessage(0);
				
					return TRUE;
				}
			}
			
			break;
		}
	}
	
	return DefWindowProc(hwnd,msg,wParam,lParam);
}

void es_help(void)
{
	// Help from NotNull
	es_write(L"ES " ES_VERSION L"\r\n");
	es_write(L"ES is a command line interface to search Everything from a command prompt.\r\n");
	es_write(L"ES uses the Everything search syntax.\r\n");
	es_write(L"\r\n");
	es_write(L"Usage: es.exe [options] search text\r\n");
	es_write(L"Example: ES  Everything ext:exe;ini \r\n");
	es_write(L"\r\n");
	es_write(L"\r\n");
	es_write(L"Search options\r\n");
	es_write(L"   -r <search>, -regex <search>\r\n");
	es_write(L"        Search using regular expressions.\r\n");
	es_write(L"   -i, -case\r\n");
	es_write(L"        Match case.\r\n");
	es_write(L"   -w, -ww, -whole-word, -whole-words\r\n");
	es_write(L"        Match whole words.\r\n");
	es_write(L"   -p, -match-path\r\n");
	es_write(L"        Match full path and file name.\r\n");
	es_write(L"   -a, -diacritics\r\n");
	es_write(L"        Match diacritical marks.\r\n");
	es_write(L"\r\n");
	es_write(L"   -o <offset>, -offset <offset>\r\n");
	es_write(L"        Show results starting from offset.\r\n");
	es_write(L"   -n <num>, -max-results <num>\r\n");
	es_write(L"        Limit the number of results shown to <num>.\r\n");
	es_write(L"\r\n");
	es_write(L"   -path <path>\r\n");
	es_write(L"        Search for subfolders and files in path.\r\n");
	es_write(L"   -parent-path <path>\r\n");
	es_write(L"        Search for subfolders and files in the parent of path.\r\n");
	es_write(L"   -parent <path>\r\n");
	es_write(L"        Search for files with the specified parent path.\r\n");
	es_write(L"\r\n");
	es_write(L"   /ad\r\n");
	es_write(L"        Folders only.\r\n");
	es_write(L"   /a-d\r\n");
	es_write(L"        Files only.\r\n");
	es_write(L"   /a[RHSDAVNTPLCOIE]\r\n");
	es_write(L"        DIR style attributes search.\r\n");
	es_write(L"        R = Read only.\r\n");
	es_write(L"        H = Hidden.\r\n");
	es_write(L"        S = System.\r\n");
	es_write(L"        D = Directory.\r\n");
	es_write(L"        A = Archive.\r\n");
	es_write(L"        V = Device.\r\n");
	es_write(L"        N = Normal.\r\n");
	es_write(L"        T = Temporary.\r\n");
	es_write(L"        P = Sparse file.\r\n");
	es_write(L"        L = Reparse point.\r\n");
	es_write(L"        C = Compressed.\r\n");
	es_write(L"        O = Offline.\r\n");
	es_write(L"        I = Not content indexed.\r\n");
	es_write(L"        E = Encrypted.\r\n");
	es_write(L"        - = Prefix a flag with - to exclude.\r\n");
	es_write(L"\r\n");
	es_write(L"\r\n");
	es_write(L"Sort options\r\n");
	es_write(L"   -s\r\n");
	es_write(L"        sort by full path.\r\n");
	es_write(L"   -sort <name[-ascending|-descending]>, -sort-<name>[-ascending|-descending]\r\n");
	es_write(L"        Set sort\r\n");
	es_write(L"        name=name|path|size|extension|date-created|date-modified|date-accessed|\r\n");
	es_write(L"        attributes|file-list-file-name|run-count|date-recently-changed|date-run\r\n");
	es_write(L"   -sort-ascending, -sort-descending\r\n");
	es_write(L"        Set sort order\r\n");
	es_write(L"\r\n");
	es_write(L"   /on, /o-n, /os, /o-s, /oe, /o-e, /od, /o-d\r\n");
	es_write(L"        DIR style sorts.\r\n");
	es_write(L"        N = Name.\r\n");
	es_write(L"        S = Size.\r\n");
	es_write(L"        E = Extension.\r\n");
	es_write(L"        D = Date modified.\r\n");
	es_write(L"        - = Sort in descending order.\r\n");
	es_write(L"\r\n");
	es_write(L"\r\n");
	es_write(L"Display options\r\n");
	es_write(L"   -name\r\n");
	es_write(L"   -path-column\r\n");
	es_write(L"   -full-path-and-name, -filename-column\r\n");
	es_write(L"   -extension, -ext\r\n");
	es_write(L"   -size\r\n");
	es_write(L"   -date-created, -dc\r\n");
	es_write(L"   -date-modified, -dm\r\n");
	es_write(L"   -date-accessed, -da\r\n");
	es_write(L"   -attributes, -attribs, -attrib\r\n");
	es_write(L"   -file-list-file-name\r\n");
	es_write(L"   -run-count\r\n");
	es_write(L"   -date-run\r\n");
	es_write(L"   -date-recently-changed, -rc\r\n");
	es_write(L"        Show the specified column.\r\n");
	es_write(L"        \r\n");
	es_write(L"   -highlight\r\n");
	es_write(L"        Highlight results.\r\n");
	es_write(L"   -highlight-color <color>\r\n");
	es_write(L"        Highlight color 0-255.\r\n");
	es_write(L"\r\n");
	es_write(L"   -csv\r\n");
	es_write(L"   -efu\r\n");
	es_write(L"   -txt\r\n");
	es_write(L"   -m3u\r\n");
	es_write(L"   -m3u8\r\n");
	es_write(L"   -tsv\r\n");
	es_write(L"        Change display format.\r\n");
	es_write(L"\r\n");
	es_write(L"   -size-format <format>\r\n");
	es_write(L"        0=auto, 1=Bytes, 2=KB, 3=MB.\r\n");
	es_write(L"   -date-format <format>\r\n");
	es_write(L"        0=auto, 1=ISO-8601, 2=FILETIME, 3=ISO-8601(UTC)\r\n");
	es_write(L"\r\n");
	es_write(L"   -filename-color <color>\r\n");
	es_write(L"   -name-color <color>\r\n");
	es_write(L"   -path-color <color>\r\n");
	es_write(L"   -extension-color <color>\r\n");
	es_write(L"   -size-color <color>\r\n");
	es_write(L"   -date-created-color <color>, -dc-color <color>\r\n");
	es_write(L"   -date-modified-color <color>, -dm-color <color>\r\n");
	es_write(L"   -date-accessed-color <color>, -da-color <color>\r\n");
	es_write(L"   -attributes-color <color>\r\n");
	es_write(L"   -file-list-filename-color <color>\r\n");
	es_write(L"   -run-count-color <color>\r\n");
	es_write(L"   -date-run-color <color>\r\n");
	es_write(L"   -date-recently-changed-color <color>, -rc-color <color>\r\n");
	es_write(L"        Set the column color 0-255.\r\n");
	es_write(L"\r\n");
	es_write(L"   -filename-width <width>\r\n");
	es_write(L"   -name-width <width>\r\n");
	es_write(L"   -path-width <width>\r\n");
	es_write(L"   -extension-width <width>\r\n");
	es_write(L"   -size-width <width>\r\n");
	es_write(L"   -date-created-width <width>, -dc-width <width>\r\n");
	es_write(L"   -date-modified-width <width>, -dm-width <width>\r\n");
	es_write(L"   -date-accessed-width <width>, -da-width <width>\r\n");
	es_write(L"   -attributes-width <width>\r\n");
	es_write(L"   -file-list-filename-width <width>\r\n");
	es_write(L"   -run-count-width <width>\r\n");
	es_write(L"   -date-run-width <width>\r\n");
	es_write(L"   -date-recently-changed-width <width>, -rc-width <width>\r\n");
	es_write(L"        Set the column width 0-200.\r\n");
	es_write(L"\r\n");
	es_write(L"   -no-digit-grouping\r\n");
	es_write(L"        Don't group numbers with commas.\r\n");
	es_write(L"   -size-leading-zero\r\n");
	es_write(L"   -run-count-leading-zero\r\n");
	es_write(L"        Format the number with leading zeros, use with -no-digit-grouping.\r\n");
	es_write(L"   -double-quote\r\n");
	es_write(L"        Wrap paths and filenames with double quotes.\r\n");
	es_write(L"\r\n");
	es_write(L"\r\n");
	es_write(L"Export options\r\n");
	es_write(L"   -export-csv <out.csv>\r\n");
	es_write(L"   -export-efu <out.efu>\r\n");
	es_write(L"   -export-txt <out.txt>\r\n");
	es_write(L"   -export-m3u <out.m3u>\r\n");
	es_write(L"   -export-m3u8 <out.m3u8>\r\n");
	es_write(L"   -export-tsv <out.txt>\r\n");
	es_write(L"        Export to a file using the specified layout.\r\n");
	es_write(L"   -no-header\r\n");
	es_write(L"        Do not output a column header for CSV, EFU and TSV files.\r\n");
	es_write(L"   -utf8-bom\r\n");
	es_write(L"        Store a UTF-8 byte order mark at the start of the exported file.\r\n");
	es_write(L"\r\n");
	es_write(L"\r\n");
	es_write(L"General options\r\n");
	es_write(L"   -h, -help\r\n");
	es_write(L"        Display this help.\r\n");
	es_write(L"\r\n");
	es_write(L"   -instance <name>\r\n");
	es_write(L"        Connect to the unique Everything instance name.\r\n");
	es_write(L"   -ipc1, -ipc2\r\n");
	es_write(L"        Use IPC version 1 or 2.\r\n");
	es_write(L"   -pause, -more\r\n");
	es_write(L"        Pause after each page of output.\r\n");
	es_write(L"   -hide-empty-search-results\r\n");
	es_write(L"        Don't show any results when there is no search.\r\n");
	es_write(L"   -empty-search-help\r\n");
	es_write(L"        Show help when no search is specified.\r\n");
	es_write(L"   -timeout <milliseconds>\r\n");
	es_write(L"        Timeout after the specified number of milliseconds to wait for\r\n");
	es_write(L"        the Everything database to load before sending a query.\r\n");
	es_write(L"        \r\n");
	es_write(L"   -set-run-count <filename> <count>\r\n");
	es_write(L"        Set the run count for the specified filename.\r\n");
	es_write(L"   -inc-run-count <filename>\r\n");
	es_write(L"        Increment the run count for the specified filename by one.\r\n");
	es_write(L"   -get-run-count <filename>\r\n");
	es_write(L"        Display the run count for the specified filename.\r\n");
	es_write(L"   -get-result-count\r\n");
	es_write(L"        Display the result count for the specified search.\r\n");
	es_write(L"   -get-total-size\r\n");
	es_write(L"        Display the total result size for the specified search.\r\n");
	es_write(L"   -save-settings, -clear-settings\r\n");
	es_write(L"        Save or clear settings.\r\n");
	es_write(L"   -version\r\n");
	es_write(L"        Display ES major.minor.revision.build version and exit.\r\n");
	es_write(L"   -get-everything-version\r\n");
	es_write(L"        Display Everything major.minor.revision.build version and exit.\r\n");
	es_write(L"   -exit\r\n");
	es_write(L"        Exit Everything.\r\n");
	es_write(L"        Returns after Everything process closes.\r\n");
	es_write(L"   -save-db\r\n");
	es_write(L"        Save the Everything database to disk.\r\n");
	es_write(L"        Returns after saving completes.\r\n");
	es_write(L"   -reindex\r\n");
	es_write(L"        Force Everything to reindex.\r\n");
	es_write(L"        Returns after indexing completes.\r\n");
	es_write(L"   -no-result-error\r\n");
	es_write(L"        Set the error level if no results are found.\r\n");
	es_write(L"\r\n");
	es_write(L"\r\n");
	es_write(L"Notes \r\n");
	es_write(L"    Internal -'s in options can be omitted, eg: -nodigitgrouping\r\n");
	es_write(L"    Switches can also start with a /\r\n");
	es_write(L"    Use double quotes to escape spaces and switches.\r\n");
	es_write(L"    Switches can be disabled by prefixing them with no-, eg: -no-size.\r\n");
	es_write(L"    Use a ^ prefix or wrap with double quotes (\") to escape \\ & | > < ^\r\n");
}

// main entry
int main(int argc,char **argv)
{
	WNDCLASSEX wcex;
	HWND hwnd;
	MSG msg;
	int ret;
	wchar_t *d;
	wchar_t *e;
	wchar_t *s;
	const wchar_t *command_line;
	int perform_search;
	
	perform_search = 1;
	
	ZeroMemory(&wcex,sizeof(wcex));
	wcex.cbSize = sizeof(wcex);
	
	es_output_handle = GetStdHandle(STD_OUTPUT_HANDLE);
	
	es_cp = GetConsoleCP();

	// get console info.
	{
		CONSOLE_SCREEN_BUFFER_INFO csbi;
		DWORD mode;

		if (GetConsoleMode(es_output_handle,&mode))
		{
			if (GetConsoleScreenBufferInfo(es_output_handle,&csbi))
			{
				es_console_wide = csbi.srWindow.Right - csbi.srWindow.Left + 1;
				es_console_high = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;

				es_console_window_x = csbi.srWindow.Left;
				es_console_window_y = csbi.dwCursorPosition.Y;
				
				if ((!es_console_wide) || (!es_console_high))
				{
					es_console_wide = csbi.dwSize.X;
					es_console_high = csbi.dwSize.Y;
				}
				
				es_console_size_high = csbi.dwSize.Y;
				
				es_cibuf_attributes = csbi.wAttributes;
				es_default_attributes = csbi.wAttributes;
				es_output_is_file = 0;
			}
		}
	}
			
	if (!GetClassInfoEx(GetModuleHandle(0),TEXT("IPCTEST"),&wcex))
	{
		ZeroMemory(&wcex,sizeof(wcex));
		wcex.cbSize = sizeof(wcex);
		wcex.hInstance = GetModuleHandle(0);
		wcex.lpfnWndProc = es_window_proc;
		wcex.lpszClassName = TEXT("IPCTEST");
		
		if (!RegisterClassEx(&wcex))
		{
			es_fatal(ES_ERROR_REGISTER_WINDOW_CLASS);
		}
	}
	
	hwnd = CreateWindow(TEXT("IPCTEST"),TEXT(""),0,0,0,0,0,0,0,GetModuleHandle(0),0);
	if (!hwnd)
	{
		es_fatal(ES_ERROR_CREATE_WINDOW);
	}

	// allow the everything window to send a reply.
	es_user32_hdll = LoadLibraryA("user32.dll");
	
	if (es_user32_hdll)
	{
		es_pChangeWindowMessageFilterEx = (BOOL (WINAPI *)(HWND hWnd,UINT message,DWORD action,PCHANGEFILTERSTRUCT pChangeFilterStruct))GetProcAddress(es_user32_hdll,"ChangeWindowMessageFilterEx");

		if (es_pChangeWindowMessageFilterEx)
		{
			es_pChangeWindowMessageFilterEx(hwnd,WM_COPYDATA,MSGFLT_ALLOW,0);
		}
	}
	
	es_instance = es_alloc(ES_WSTRING_SIZE * sizeof(wchar_t));
	es_search = es_alloc(ES_SEARCH_BUF_SIZE * sizeof(wchar_t));
	es_filter = es_alloc(ES_FILTER_BUF_SIZE * sizeof(wchar_t));
	
	*es_instance = 0;
	*es_filter = 0;

	d = es_search;

	// allow room for null terminator
	e = es_search + ES_SEARCH_BUF_SIZE - 1;

	// load default settings.	
	es_load_settings();
	
	command_line = GetCommandLine();
	
/*
	// code page test
	
	printf("CP %u\n",GetConsoleCP());
	printf("CP output %u\n",GetConsoleOutputCP());
	
	MessageBox(0,command_line,L"command line",MB_OK);
	return 0;
//	printf("command line %S\n",command_line);
*/
	// expect the executable name in the first argv.
	if (command_line)
	{
		command_line = es_get_argv(command_line);
	}
	
	if (command_line)
	{
		command_line = es_get_argv(command_line);
		
		if (command_line)
		{
			for(;;)
			{
				if (es_check_param(es_argv,L"-set-run-count"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_run_history_size = sizeof(EVERYTHING_IPC_RUN_HISTORY) + ((es_wstring_length(es_argv) + 1) * sizeof(wchar_t));
					es_run_history_data = es_alloc(es_run_history_size);
					es_wstring_copy((wchar_t *)(((EVERYTHING_IPC_RUN_HISTORY *)es_run_history_data)+1),es_argv);
					
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					((EVERYTHING_IPC_RUN_HISTORY *)es_run_history_data)->run_count = es_wstring_to_int(es_argv);
					es_run_history_command = EVERYTHING_IPC_COPYDATA_SET_RUN_COUNTW;
				}
				else			
				if (es_check_param(es_argv,L"-inc-run-count"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_run_history_size = (es_wstring_length(es_argv) + 1) * sizeof(wchar_t);
					es_run_history_data = es_wstring_alloc(es_argv);
					es_run_history_command = EVERYTHING_IPC_COPYDATA_INC_RUN_COUNTW;
				}
				else			
				if (es_check_param(es_argv,L"-get-run-count"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_run_history_size = (es_wstring_length(es_argv) + 1) * sizeof(wchar_t);
					es_run_history_data = es_wstring_alloc(es_argv);
					es_run_history_command = EVERYTHING_IPC_COPYDATA_GET_RUN_COUNTW;
				}
				else
				if ((es_check_param(es_argv,L"r")) || (es_check_param(es_argv,L"regex")))
				{
					command_line = es_get_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
							
					if ((d != es_search) && (d < e)) *d++ = ' ';
					
					s = L"regex:";
					while(*s)
					{
						if (d < e) *d++ = *s;
						s++;
					}
										
					s = es_argv;
					while(*s)
					{
						if (d < e) *d++ = *s;
						s++;
					}		
				}
				else
				if ((es_check_param(es_argv,L"i")) || (es_check_param(es_argv,L"case")))
				{
					es_match_case = 1;
				}
				else
				if ((es_check_param(es_argv,L"no-i")) || (es_check_param(es_argv,L"no-case")))
				{
					es_match_case = 0;
				}
				else
				if ((es_check_param(es_argv,L"a")) || (es_check_param(es_argv,L"diacritics")))
				{
					es_match_diacritics = 1;
				}
				else
				if ((es_check_param(es_argv,L"no-a")) || (es_check_param(es_argv,L"no-diacritics")))
				{
					es_match_diacritics = 0;
				}
				else
				if (es_check_param(es_argv,L"instance"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_wstring_copy(es_instance,es_argv);
				}
				else
				if ((es_check_param(es_argv,L"exit")) || (es_check_param(es_argv,L"quit")))
				{
					es_exit_everything = 1;
				}
				else
				if ((es_check_param(es_argv,L"re-index")) || (es_check_param(es_argv,L"re-build")) || (es_check_param(es_argv,L"update")))
				{
					es_reindex = 1;
				}
				else
				if (es_check_param(es_argv,L"save-db"))
				{
					es_save_db = 1;
				}
				else
				if (es_check_param(es_argv,L"connect"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					if (es_connect)
					{
						es_free(es_connect);
					}
					
					es_connect = es_wstring_alloc(es_argv);
				}
				else
				if (es_check_param(es_argv,L"highlight-color"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_highlight_color = es_wstring_to_int(es_argv);
				}
				else
				if (es_check_param(es_argv,L"highlight"))
				{
					es_highlight = 1;
				}
				else			
				if (es_check_param(es_argv,L"no-highlight"))
				{
					es_highlight = 0;
				}
				else
				if (es_check_param(es_argv,L"m3u"))
				{
					es_export = ES_EXPORT_M3U;
				}
				else				
				if (es_check_param(es_argv,L"export-m3u"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_export_file = CreateFile(es_argv,GENERIC_WRITE,FILE_SHARE_READ,0,CREATE_ALWAYS,0,0);
					if (es_export_file != INVALID_HANDLE_VALUE)
					{
						es_export = ES_EXPORT_M3U;
					}
					else
					{
						es_fatal(ES_ERROR_CREATE_FILE);
					}
				}
				else					
				if (es_check_param(es_argv,L"m3u8"))
				{
					es_export = ES_EXPORT_M3U8;
				}
				else				
				if (es_check_param(es_argv,L"export-m3u8"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_export_file = CreateFile(es_argv,GENERIC_WRITE,FILE_SHARE_READ,0,CREATE_ALWAYS,0,0);
					if (es_export_file != INVALID_HANDLE_VALUE)
					{
						es_export = ES_EXPORT_M3U8;
					}
					else
					{
						es_fatal(ES_ERROR_CREATE_FILE);
					}
				}
				else		
				if (es_check_param(es_argv,L"csv"))
				{
					es_export = ES_EXPORT_CSV;
				}
				else				
				if (es_check_param(es_argv,L"tsv"))
				{
					es_export = ES_EXPORT_TSV;
				}
				else				
				if (es_check_param(es_argv,L"export-csv"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_export_file = CreateFile(es_argv,GENERIC_WRITE,FILE_SHARE_READ,0,CREATE_ALWAYS,0,0);
					if (es_export_file != INVALID_HANDLE_VALUE)
					{
						es_export = ES_EXPORT_CSV;
					}
					else
					{
						es_fatal(ES_ERROR_CREATE_FILE);
					}
				}
				else		
				if (es_check_param(es_argv,L"export-tsv"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_export_file = CreateFile(es_argv,GENERIC_WRITE,FILE_SHARE_READ,0,CREATE_ALWAYS,0,0);
					if (es_export_file != INVALID_HANDLE_VALUE)
					{
						es_export = ES_EXPORT_TSV;
					}
					else
					{
						es_fatal(ES_ERROR_CREATE_FILE);
					}
				}
				else		
				if (es_check_param(es_argv,L"efu"))
				{
					es_export = ES_EXPORT_EFU;
				}
				else		
				if (es_check_param(es_argv,L"export-efu"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_export_file = CreateFile(es_argv,GENERIC_WRITE,FILE_SHARE_READ,0,CREATE_ALWAYS,0,0);
					if (es_export_file != INVALID_HANDLE_VALUE)
					{
						es_export = ES_EXPORT_EFU;
					}
					else
					{
						es_fatal(ES_ERROR_CREATE_FILE);
					}
				}
				else		
				if (es_check_param(es_argv,L"txt"))
				{
					es_export = ES_EXPORT_TXT;
				}
				else				
				if (es_check_param(es_argv,L"export-txt"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_export_file = CreateFile(es_argv,GENERIC_WRITE,FILE_SHARE_READ,0,CREATE_ALWAYS,0,0);
					if (es_export_file != INVALID_HANDLE_VALUE)
					{
						es_export = ES_EXPORT_TXT;
					}
					else
					{
						es_fatal(ES_ERROR_CREATE_FILE);
					}
				}
				else
				if (es_check_param(es_argv,L"cp"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_cp = es_wstring_to_int(es_argv);
				}
				else
				if ((es_check_param(es_argv,L"w")) || (es_check_param(es_argv,L"ww")) || (es_check_param(es_argv,L"whole-word")) || (es_check_param(es_argv,L"whole-words")))
				{
					es_match_whole_word = 1;
				}
				else
				if ((es_check_param(es_argv,L"no-w")) || (es_check_param(es_argv,L"no-ww")) || (es_check_param(es_argv,L"no-whole-word")) || (es_check_param(es_argv,L"no-whole-words")))
				{
					es_match_whole_word = 0;
				}
				else
				if ((es_check_param(es_argv,L"p")) || (es_check_param(es_argv,L"match-path")))
				{
					es_match_path = 1;
				}
				else
				if (es_check_param(es_argv,L"no-p"))
				{
					es_match_path = 0;
				}
				else
				if ((es_check_param(es_argv,L"file-name-width")) || (es_check_param(es_argv,L"file-name-wide")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_set_column_wide(ES_COLUMN_FILENAME);
					es_column_widths[ES_COLUMN_HIGHLIGHTED_FILENAME] = es_column_widths[ES_COLUMN_FILENAME];
				}
				else
				if ((es_check_param(es_argv,L"name-width")) || (es_check_param(es_argv,L"name-wide")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_set_column_wide(ES_COLUMN_NAME);
					es_column_widths[ES_COLUMN_HIGHLIGHTED_NAME] = es_column_widths[ES_COLUMN_NAME];
				}
				else
				if ((es_check_param(es_argv,L"path-width")) || (es_check_param(es_argv,L"path-wide")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_set_column_wide(ES_COLUMN_PATH);
					es_column_widths[ES_COLUMN_HIGHLIGHTED_PATH] = es_column_widths[ES_COLUMN_PATH];
				}
				else
				if ((es_check_param(es_argv,L"extension-width")) || (es_check_param(es_argv,L"extension-wide")) || (es_check_param(es_argv,L"ext-width")) || (es_check_param(es_argv,L"ext-wide")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_set_column_wide(ES_COLUMN_EXTENSION);
				}
				else
				if ((es_check_param(es_argv,L"size-width")) || (es_check_param(es_argv,L"size-wide")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_set_column_wide(ES_COLUMN_SIZE);
				}
				else
				if ((es_check_param(es_argv,L"date-created-width")) || (es_check_param(es_argv,L"date-created-wide")) || (es_check_param(es_argv,L"dc-width")) || (es_check_param(es_argv,L"dc-wide")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_set_column_wide(ES_COLUMN_DATE_CREATED);
				}
				else
				if ((es_check_param(es_argv,L"date-modified-width")) || (es_check_param(es_argv,L"date-modified-wide")) || (es_check_param(es_argv,L"dm-width")) || (es_check_param(es_argv,L"dm-wide")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_set_column_wide(ES_COLUMN_DATE_MODIFIED);
				}
				else
				if ((es_check_param(es_argv,L"date-accessed-width")) || (es_check_param(es_argv,L"date-accessed-wide")) || (es_check_param(es_argv,L"da-width")) || (es_check_param(es_argv,L"da-wide")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_set_column_wide(ES_COLUMN_DATE_ACCESSED);
				}
				else
				if ((es_check_param(es_argv,L"attributes-width")) || (es_check_param(es_argv,L"attributes-wide")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_set_column_wide(ES_COLUMN_ATTRIBUTES);
				}
				else
				if ((es_check_param(es_argv,L"file-list-file-name-width")) || (es_check_param(es_argv,L"file-list-file-name-wide")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_set_column_wide(ES_COLUMN_FILE_LIST_FILENAME);
				}
				else
				if ((es_check_param(es_argv,L"run-count-width")) || (es_check_param(es_argv,L"run-count-wide")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_set_column_wide(ES_COLUMN_RUN_COUNT);
				}
				else
				if ((es_check_param(es_argv,L"date-run-width")) || (es_check_param(es_argv,L"date-run-wide")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_set_column_wide(ES_COLUMN_DATE_RUN);
				}
				else
				if ((es_check_param(es_argv,L"date-recently-changed-width")) || (es_check_param(es_argv,L"date-recently-changed-wide")) || (es_check_param(es_argv,L"rc-width")) || (es_check_param(es_argv,L"rc-wide")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_set_column_wide(ES_COLUMN_DATE_RECENTLY_CHANGED);
				}
				else
				if (es_check_param(es_argv,L"size-leading-zero"))
				{
					es_size_leading_zero = 1;
				}
				else
				if (es_check_param(es_argv,L"no-size-leading-zero"))
				{
					es_size_leading_zero = 0;
				}
				else
				if (es_check_param(es_argv,L"run-count-leading-zero"))
				{
					es_run_count_leading_zero = 1;
				}
				else
				if (es_check_param(es_argv,L"no-run-count-leading-zero"))
				{
					es_run_count_leading_zero = 0;
				}
				else
				if (es_check_param(es_argv,L"no-digit-grouping"))
				{
					es_digit_grouping = 0;
				}
				else
				if (es_check_param(es_argv,L"digit-grouping"))
				{
					es_digit_grouping = 1;
				}
				else
				if (es_check_param(es_argv,L"size-format"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_size_format = es_wstring_to_int(es_argv);
				}
				else
				if (es_check_param(es_argv,L"date-format"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_date_format = es_wstring_to_int(es_argv);
				}
				else			
				if ((es_check_param(es_argv,L"pause")) || (es_check_param(es_argv,L"more")))
				{
					es_pause = 1;
				}
				else
				if ((es_check_param(es_argv,L"no-pause")) || (es_check_param(es_argv,L"no-more")))
				{
					es_pause = 0;
				}
				else
				if (es_check_param(es_argv,L"empty-search-help"))
				{
					es_empty_search_help = 1;
					es_hide_empty_search_results = 0;
				}
				else
				if (es_check_param(es_argv,L"no-empty-search-help"))
				{
					es_empty_search_help = 0;
				}
				else
				if (es_check_param(es_argv,L"hide-empty-search-results"))
				{
					es_hide_empty_search_results = 1;
					es_empty_search_help = 0;
				}
				else
				if (es_check_param(es_argv,L"no-hide-empty-search-results"))
				{
					es_hide_empty_search_results = 0;
				}
				else
				if (es_check_param(es_argv,L"save-settings"))
				{
					es_save = 1;
				}
				else
				if (es_check_param(es_argv,L"clear-settings"))
				{
					char filename[MAX_PATH];
					
					if (es_get_ini_filename(filename))
					{
						DeleteFileA(filename);

						es_write(L"Settings saved.\r\n");
					}
					
					goto exit;
				}
				else
				if (es_check_param(es_argv,L"filename-color"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_set_color(ES_COLUMN_FILENAME);
					es_column_color[ES_COLUMN_HIGHLIGHTED_FILENAME] = es_column_color[ES_COLUMN_FILENAME];
					es_column_color_is_valid[ES_COLUMN_HIGHLIGHTED_FILENAME] = es_column_color_is_valid[ES_COLUMN_FILENAME];
				}
				else			
				if (es_check_param(es_argv,L"name-color"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
								
					es_set_color(ES_COLUMN_NAME);
					es_column_color[ES_COLUMN_NAME] = es_column_color[ES_COLUMN_NAME];
					es_column_color_is_valid[ES_COLUMN_NAME] = es_column_color_is_valid[ES_COLUMN_NAME];
				}
				else			
				if (es_check_param(es_argv,L"path-color"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
								
					es_set_color(ES_COLUMN_PATH);
					es_column_color[ES_COLUMN_PATH] = es_column_color[ES_COLUMN_PATH];
					es_column_color_is_valid[ES_COLUMN_PATH] = es_column_color_is_valid[ES_COLUMN_PATH];
				}
				else		
				if (es_check_param(es_argv,L"extension-color"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
								
					es_set_color(ES_COLUMN_EXTENSION);
				}
				else
				if (es_check_param(es_argv,L"size-color"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
								
					es_set_color(ES_COLUMN_SIZE);
				}
				else
				if ((es_check_param(es_argv,L"date-created-color")) || (es_check_param(es_argv,L"dc-color")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
								
					es_set_color(ES_COLUMN_DATE_CREATED);
				}
				else
				if ((es_check_param(es_argv,L"date-modified-color")) || (es_check_param(es_argv,L"dm-color")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
								
					es_set_color(ES_COLUMN_DATE_MODIFIED);
				}
				else
				if ((es_check_param(es_argv,L"date-accessed-color")) || (es_check_param(es_argv,L"da-color")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
								
					es_set_color(ES_COLUMN_DATE_ACCESSED);
				}
				else			
				if ((es_check_param(es_argv,L"attributes-color")) || (es_check_param(es_argv,L"attribs-color")) || (es_check_param(es_argv,L"attrib-color"))) 
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
								
					es_set_color(ES_COLUMN_ATTRIBUTES);
				}
				else			
				if (es_check_param(es_argv,L"file-list-filename-color"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
								
					es_set_color(ES_COLUMN_FILE_LIST_FILENAME);
				}
				else
				if (es_check_param(es_argv,L"run-count-color"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
								
					es_set_color(ES_COLUMN_RUN_COUNT);
				}
				else			
				if (es_check_param(es_argv,L"date-run-color"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
								
					es_set_color(ES_COLUMN_DATE_RUN);
				}
				else
				if ((es_check_param(es_argv,L"date-recently-changed-color")) || (es_check_param(es_argv,L"rc-color")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
								
					es_set_color(ES_COLUMN_DATE_RECENTLY_CHANGED);
				}
				else
				if (es_check_param(es_argv,L"name"))
				{
					es_add_column(ES_COLUMN_NAME);
				}
				else
				if (es_check_param(es_argv,L"no-name"))
				{
					es_remove_column(ES_COLUMN_NAME);
				}
				else
				if (es_check_param(es_argv,L"path-column"))
				{
					es_add_column(ES_COLUMN_PATH);
				}
				else
				if (es_check_param(es_argv,L"no-path-column"))
				{
					es_remove_column(ES_COLUMN_PATH);
				}
				else
				if ((es_check_param(es_argv,L"full-path-and-name")) || (es_check_param(es_argv,L"path-and-name")) || (es_check_param(es_argv,L"filename-column")))
				{
					es_add_column(ES_COLUMN_FILENAME);
				}
				else
				if ((es_check_param(es_argv,L"no-full-path-and-name")) || (es_check_param(es_argv,L"no-path-and-name")) || (es_check_param(es_argv,L"no-filename-column")))
				{
					es_remove_column(ES_COLUMN_FILENAME);
				}
				else
				if ((es_check_param(es_argv,L"extension")) || (es_check_param(es_argv,L"ext")))
				{
					es_add_column(ES_COLUMN_EXTENSION);
				}
				else
				if ((es_check_param(es_argv,L"no-extension")) || (es_check_param(es_argv,L"no-ext")))
				{
					es_remove_column(ES_COLUMN_EXTENSION);
				}
				else
				if (es_check_param(es_argv,L"size"))
				{
					es_add_column(ES_COLUMN_SIZE);
				}
				else
				if (es_check_param(es_argv,L"no-size"))
				{
					es_remove_column(ES_COLUMN_SIZE);
				}
				else
				if ((es_check_param(es_argv,L"date-created")) || (es_check_param(es_argv,L"dc")))
				{
					es_add_column(ES_COLUMN_DATE_CREATED);
				}
				else
				if ((es_check_param(es_argv,L"no-date-created")) || (es_check_param(es_argv,L"no-dc")))
				{
					es_remove_column(ES_COLUMN_DATE_CREATED);
				}
				else
				if ((es_check_param(es_argv,L"date-modified")) || (es_check_param(es_argv,L"dm")))
				{
					es_add_column(ES_COLUMN_DATE_MODIFIED);
				}
				else
				if ((es_check_param(es_argv,L"no-date-modified")) || (es_check_param(es_argv,L"no-dm")))
				{
					es_remove_column(ES_COLUMN_DATE_MODIFIED);
				}
				else
				if ((es_check_param(es_argv,L"date-accessed")) || (es_check_param(es_argv,L"da")))
				{
					es_add_column(ES_COLUMN_DATE_ACCESSED);
				}
				else
				if ((es_check_param(es_argv,L"no-date-accessed")) || (es_check_param(es_argv,L"no-da")))
				{
					es_remove_column(ES_COLUMN_DATE_ACCESSED);
				}
				else
				if ((es_check_param(es_argv,L"attributes")) || (es_check_param(es_argv,L"attribs")) || (es_check_param(es_argv,L"attrib")))
				{
					es_add_column(ES_COLUMN_ATTRIBUTES);
				}
				else
				if ((es_check_param(es_argv,L"no-attributes")) || (es_check_param(es_argv,L"no-attribs")) || (es_check_param(es_argv,L"no-attrib")))
				{
					es_remove_column(ES_COLUMN_ATTRIBUTES);
				}
				else
				if ((es_check_param(es_argv,L"file-list-file-name")) || (es_check_param(es_argv,L"flfn")))
				{
					es_add_column(ES_COLUMN_FILE_LIST_FILENAME);
				}
				else
				if ((es_check_param(es_argv,L"no-file-list-file-name")) || (es_check_param(es_argv,L"no-flfn")))
				{
					es_remove_column(ES_COLUMN_FILE_LIST_FILENAME);
				}
				else
				if (es_check_param(es_argv,L"run-count"))
				{
					es_add_column(ES_COLUMN_RUN_COUNT);
				}
				else
				if (es_check_param(es_argv,L"no-run-count"))
				{
					es_remove_column(ES_COLUMN_RUN_COUNT);
				}
				else
				if (es_check_param(es_argv,L"date-run"))
				{
					es_add_column(ES_COLUMN_DATE_RUN);
				}
				else
				if (es_check_param(es_argv,L"no-date-run"))
				{
					es_remove_column(ES_COLUMN_DATE_RUN);
				}
				else
				if ((es_check_param(es_argv,L"date-recently-changed")) || (es_check_param(es_argv,L"rc")) || (es_check_param(es_argv,L"drc")) || (es_check_param(es_argv,L"recent-change")))
				{
					es_add_column(ES_COLUMN_DATE_RECENTLY_CHANGED);
				}
				else
				if ((es_check_param(es_argv,L"no-date-recently-changed")) || (es_check_param(es_argv,L"no-rc")) || (es_check_param(es_argv,L"no-drc")) || (es_check_param(es_argv,L"no-recent-change")))
				{
					es_remove_column(ES_COLUMN_DATE_RECENTLY_CHANGED);
				}
				else
				if (es_check_param(es_argv,L"sort-ascending"))
				{
					es_sort_ascending = 1;
				}
				else
				if (es_check_param(es_argv,L"sort-descending"))
				{
					es_sort_ascending = -1;
				}
				else
				if (es_check_param(es_argv,L"sort"))
				{	
					wchar_t sortnamebuf[ES_WSTRING_SIZE];
					int sortnamei;
					
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					for(sortnamei=0;sortnamei<ES_SORT_NAME_COUNT;sortnamei++)
					{
						if (es_check_param_param(es_argv,es_sort_names[sortnamei]))
						{
							es_sort = es_sort_names_to_ids[sortnamei];

							break;
						}
						else
						{
							es_wstring_copy(sortnamebuf,es_sort_names[sortnamei]);
							es_wstring_cat(sortnamebuf,L"-ascending");
							
							if (es_check_param_param(es_argv,sortnamebuf))
							{
								es_sort = es_sort_names_to_ids[sortnamei];
								es_sort_ascending = 1;

								break;
							}
							else
							{
								es_wstring_copy(sortnamebuf,es_sort_names[sortnamei]);
								es_wstring_cat(sortnamebuf,L"-descending");
								
								if (es_check_param_param(es_argv,sortnamebuf))
								{
									es_sort = es_sort_names_to_ids[sortnamei];
									es_sort_ascending = -1;

									break;
								}
							}
						}
					}
					
					if (sortnamei == ES_SORT_NAME_COUNT)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
				}
				else
				if (es_check_param(es_argv,L"ipc1"))
				{	
					es_ipc_version = 0x01; 
				}
				else
				if (es_check_param(es_argv,L"ipc2"))
				{	
					es_ipc_version = 0x02; 
				}
				else
				if (es_check_param(es_argv,L"header"))
				{	
					es_header = 1; 
				}
				else
				if (es_check_param(es_argv,L"no-header"))
				{	
					es_header = 0; 
				}
				else
				if (es_check_param(es_argv,L"double-quote"))
				{	
					es_double_quote = 1; 
				}
				else
				if (es_check_param(es_argv,L"no-double-quote"))
				{	
					es_double_quote = 0; 
				}
				else
				if (es_check_param(es_argv,L"version"))
				{	
					es_write(ES_VERSION);
					es_write(L"\r\n");

					goto exit;
				}
				else
				if (es_check_param(es_argv,L"get-everything-version"))
				{
					es_get_everything_version = 1;
				}
				else
				if (es_check_param(es_argv,L"utf8-bom"))
				{
					es_utf8_bom = 1;
				}
				else
				if (es_check_sorts())
				{
				}
				else
				if (es_check_param(es_argv,L"on"))
				{	
					es_sort = EVERYTHING_IPC_SORT_NAME_ASCENDING;
					es_sort_ascending = 1;
				}
				else
				if (es_check_param(es_argv,L"o-n"))
				{	
					es_sort = EVERYTHING_IPC_SORT_NAME_DESCENDING;
					es_sort_ascending = -1;
				}
				else
				if (es_check_param(es_argv,L"os"))
				{	
					es_sort = EVERYTHING_IPC_SORT_SIZE_ASCENDING;
					es_sort_ascending = 1;
				}
				else
				if (es_check_param(es_argv,L"o-s"))
				{	
					es_sort = EVERYTHING_IPC_SORT_SIZE_DESCENDING;
					es_sort_ascending = -1;
				}
				else
				if (es_check_param(es_argv,L"oe"))
				{	
					es_sort = EVERYTHING_IPC_SORT_EXTENSION_ASCENDING;
					es_sort_ascending = 1;
				}
				else
				if (es_check_param(es_argv,L"o-e"))
				{	
					es_sort = EVERYTHING_IPC_SORT_EXTENSION_DESCENDING;
					es_sort_ascending = -1;
				}
				else
				if (es_check_param(es_argv,L"od"))
				{	
					es_sort = EVERYTHING_IPC_SORT_DATE_MODIFIED_ASCENDING;
					es_sort_ascending = 1;
				}
				else
				if (es_check_param(es_argv,L"o-d"))
				{	
					es_sort = EVERYTHING_IPC_SORT_DATE_MODIFIED_DESCENDING;
					es_sort_ascending = -1;
				}
				else
				if (es_check_param(es_argv,L"s"))
				{
					es_sort = EVERYTHING_IPC_SORT_PATH_ASCENDING;
				}
				else
				if ((es_check_param(es_argv,L"n")) || (es_check_param(es_argv,L"max-results")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_max_results = es_wstring_to_int(es_argv);
				}
				else
				if ((es_check_param(es_argv,L"o")) || (es_check_param(es_argv,L"offset")))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_offset = es_wstring_to_int(es_argv);
				}
				else
				if (es_check_param(es_argv,L"path"))
				{
					wchar_t pathbuf[ES_WSTRING_SIZE];
					wchar_t *namepart;
				
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					// relative path.
					GetFullPathName(es_argv,ES_WSTRING_SIZE,pathbuf,&namepart);
					
					if (*es_filter)
					{
						es_wbuf_cat(es_filter,ES_FILTER_BUF_SIZE,L" ");
					}

					es_wbuf_cat(es_filter,ES_FILTER_BUF_SIZE,L"\"");
					es_wbuf_cat(es_filter,ES_FILTER_BUF_SIZE,pathbuf);
					if ((*pathbuf) && (pathbuf[es_wstring_length(pathbuf) - 1] != '\\'))
					{
						es_wbuf_cat(es_filter,ES_FILTER_BUF_SIZE,L"\\");
					}
					es_wbuf_cat(es_filter,ES_FILTER_BUF_SIZE,L"\"");
				}
				else
				if (es_check_param(es_argv,L"parent-path"))
				{
					wchar_t pathbuf[ES_WSTRING_SIZE];
					wchar_t *namepart;
				
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					// relative path.
					GetFullPathName(es_argv,ES_WSTRING_SIZE,pathbuf,&namepart);
					PathRemoveFileSpec(pathbuf);
					
					if (*es_filter)
					{
						es_wbuf_cat(es_filter,ES_FILTER_BUF_SIZE,L" ");
					}

					es_wbuf_cat(es_filter,ES_FILTER_BUF_SIZE,L"\"");
					es_wbuf_cat(es_filter,ES_FILTER_BUF_SIZE,pathbuf);
					if ((*pathbuf) && (pathbuf[es_wstring_length(pathbuf) - 1] != '\\'))
					{
						es_wbuf_cat(es_filter,ES_FILTER_BUF_SIZE,L"\\");
					}
					es_wbuf_cat(es_filter,ES_FILTER_BUF_SIZE,L"\"");
				}
				else
				if (es_check_param(es_argv,L"parent"))
				{
					wchar_t pathbuf[ES_WSTRING_SIZE];
					wchar_t *namepart;
				
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					// relative path.
					GetFullPathName(es_argv,ES_WSTRING_SIZE,pathbuf,&namepart);
					
					if (*es_filter)
					{
						es_wbuf_cat(es_filter,ES_FILTER_BUF_SIZE,L" ");
					}

					es_wbuf_cat(es_filter,ES_FILTER_BUF_SIZE,L"parent:\"");
					es_wbuf_cat(es_filter,ES_FILTER_BUF_SIZE,pathbuf);
					if ((*pathbuf) && (pathbuf[es_wstring_length(pathbuf) - 1] != '\\'))
					{
						es_wbuf_cat(es_filter,ES_FILTER_BUF_SIZE,L"\\");
					}
					es_wbuf_cat(es_filter,ES_FILTER_BUF_SIZE,L"\"");
				}
				else
				if (es_check_param(es_argv,L"time-out"))
				{
					command_line = es_get_command_argv(command_line);
					if (!command_line)
					{
						es_fatal(ES_ERROR_EXPECTED_SWITCH_PARAMETER);
					}
					
					es_timeout = (DWORD)es_wstring_to_int(es_argv);
				}
				else
				if (es_check_param(es_argv,L"no-time-out"))
				{
					es_timeout = 0;
				}
				else
				if (es_check_param(es_argv,L"ad"))
				{	
					// add folder:
					es_append_filter(L"folder:");
				}
				else
				if (es_check_param(es_argv,L"a-d"))
				{	
					// add folder:
					es_append_filter(L"file:");
				}
				else
				if (es_check_param(es_argv,L"get-result-count"))
				{
					es_get_result_count = 1;
				}
				else
				if (es_check_param(es_argv,L"get-total-size"))
				{
					es_get_total_size = 1;
				}
				else
				if (es_check_param(es_argv,L"no-result-error"))
				{
					es_no_result_error = 1;
				}
				else
				if (((es_argv[0] == '-') || (es_argv[0] == '/')) && (es_argv[1] == 'a') && (es_argv[2]))
				{
					const wchar_t *p;
					wchar_t attrib[ES_WSTRING_SIZE];
					wchar_t notattrib[ES_WSTRING_SIZE];
					wchar_t wch[2];

					p = es_argv + 2;
					
					attrib[0] = 0;
					notattrib[0] = 0;
					
					// TODO handle unknown a switches.
					while(*p)
					{
						int lower_p;
						
						lower_p = tolower(*p);
						
						if (lower_p == '-')
						{
							p++;
							
							lower_p = tolower(*p);
							
							wch[0] = lower_p;
							wch[1] = 0;
							
							es_wstring_cat(notattrib,wch);
						}
						else
						{
							wch[0] = lower_p;
							wch[1] = 0;
							
							es_wstring_cat(attrib,wch);
						}
												
						p++;						
					}
					
					// copy append to search
					if (*attrib)
					{
						if ((d != es_search) && (d < e)) *d++ = ' ';

						s = L"attrib:";
						while(*s)
						{
							if (d < e) *d++ = *s;
							s++;
						}
						
						// copy append to search
						s = attrib;
						while(*s)
						{
							if (d < e) *d++ = *s;
							s++;
						}
					}

					// copy not append to search
					if (*notattrib)
					{
						if ((d != es_search) && (d < e)) *d++ = ' ';
	
						s = L"!attrib:";
						while(*s)
						{
							if (d < e) *d++ = *s;
							s++;
						}
						
						// copy append to search
						s = notattrib;
						while(*s)
						{
							if (d < e) *d++ = *s;
							s++;
						}
					}
				}
				else
				if ((es_check_param(es_argv,L"?")) || (es_check_param(es_argv,L"help")) || (es_check_param(es_argv,L"h")))
				{
					// user requested help
					es_help();
					
					goto exit;
				}
				else
				if (es_argv[0] == '-')
				{
					// unknown command
					// allow /downloads to search for "\downloads" for now
					es_fatal(ES_ERROR_UNKNOWN_SWITCH);
				}
				else
				{
					if ((d != es_search) && (d < e)) *d++ = ' ';

					// copy append to search
					s = es_argv;
					while(*s)
					{
						if (d < e) *d++ = *s;
						s++;
					}
				}

				command_line = es_get_argv(command_line);
				if (!command_line)
				{
					break;
				}
			}
		}
	}
	
	// fix sort order
	if (es_sort_ascending)
	{
		if (es_sort_ascending > 0)
		{
			es_set_sort_ascending();
		}
		else
		{
			es_set_sort_descending();
		}
	}
		
	// save settings.
	if (es_save)
	{
		es_save_settings();
		
		es_write(L"Settings saved.\r\n");
		
		perform_search = 0;
	}
	
	// save settings.
	if (es_get_everything_version)
	{
		es_everything_hwnd = es_find_ipc_window();
		
		if (es_everything_hwnd)
		{
			int major;
			int minor;
			int revision;
			int build;

			// wait for DB_IS_LOADED so we don't get 0 results
			major = (int)SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_GET_MAJOR_VERSION,0);
			minor = (int)SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_GET_MINOR_VERSION,0);
			revision = (int)SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_GET_REVISION,0);
			build = (int)SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_GET_BUILD_NUMBER,0);
				
			es_write_DWORD(major);
			es_write(L".");
			es_write_DWORD(minor);
			es_write(L".");
			es_write_DWORD(revision);
			es_write(L".");
			es_write_DWORD(build);
			es_write(L"\r\n");
		}
		else
		{
			es_fatal(ES_ERROR_IPC);
		}
		
		perform_search = 0;
	}
	
	// reindex?
	if (es_reindex)
	{
		es_everything_hwnd = es_find_ipc_window();
		
		if (es_everything_hwnd)
		{
			SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_REBUILD_DB,0);
			
			// poll until db is available.
			es_wait_for_db_loaded();
		}
		else
		{
			es_fatal(ES_ERROR_IPC);
		}

		perform_search = 0;
	}
	
	// run history command
	if (es_run_history_command)
	{
		es_do_run_history_command();

		perform_search = 0;
	}
	
	// save db
	// do this after a reindex.
	if (es_save_db)
	{
		es_everything_hwnd = es_find_ipc_window();
		
		if (es_everything_hwnd)
		{
			SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_SAVE_DB,0);
			
			// wait until not busy..
			es_wait_for_db_not_busy();
		}
		else
		{
			es_fatal(ES_ERROR_IPC);
		}

		perform_search = 0;
	}
	
	// Exit Everything?
	if (es_exit_everything)
	{
		es_everything_hwnd = es_find_ipc_window();
		
		if (es_everything_hwnd)
		{
			DWORD dwProcessId;

			SendMessage(es_everything_hwnd,WM_CLOSE,0,0);

			// wait for Everything to exit.
			if (GetWindowThreadProcessId(es_everything_hwnd,&dwProcessId))
			{
				HANDLE h;
				
				h = OpenProcess(SYNCHRONIZE,FALSE,dwProcessId);
				if (h)
				{
					WaitForSingleObject(h,es_timeout ? es_timeout : INFINITE);
				
					CloseHandle(h);
				}
				else
				{
					es_fatal(ES_ERROR_SEND_MESSAGE);
				}
			}
			else
			{
				es_fatal(ES_ERROR_SEND_MESSAGE);
			}
		}
		else
		{
			es_fatal(ES_ERROR_IPC);
		}
		
		perform_search = 0;
	}
	
	if (perform_search)
	{
		// empty search?
		// if max results is set, treat the search as non-empty.
		// -useful if you want to see the top ten largest files etc..
		if ((d == es_search) && (!*es_filter) && (es_max_results == 0xffffffff) && (!es_get_result_count) && (!es_get_total_size))
		{
			if (es_empty_search_help)
			{
				es_help();
				
				goto exit;
			}

			if (es_hide_empty_search_results)
			{
				goto exit;
			}
		}
		
		// add filename column
		if (es_find_column(ES_COLUMN_FILENAME) == -1)
		{
			if (es_find_column(ES_COLUMN_NAME) == -1)
			{
				if (es_find_column(ES_COLUMN_PATH) == -1)
				{
					es_add_column(ES_COLUMN_FILENAME);
				}
			}
		}
		
		// apply highlighting to columns.
		if (es_highlight)
		{
			int columni;
			
			for(columni=0;columni<es_numcolumns;columni++)
			{
				if (es_columns[columni] == ES_COLUMN_FILENAME)
				{
					es_columns[columni] = ES_COLUMN_HIGHLIGHTED_FILENAME;
				}
				else
				if (es_columns[columni] == ES_COLUMN_PATH)
				{
					es_columns[columni] = ES_COLUMN_HIGHLIGHTED_PATH;
				}
				else
				if (es_columns[columni] == ES_COLUMN_NAME)
				{
					es_columns[columni] = ES_COLUMN_HIGHLIGHTED_NAME;
				}
			}
		}
		
		// null terminate
		*d = 0;

		// write export headers
		// write header
		if (es_export)
		{
			if (es_utf8_bom)
			{
				if (es_export_file != INVALID_HANDLE_VALUE)
				{
					BYTE bom[3];
					DWORD numwritten;
					
					// 0xEF,0xBB,0xBF.
					bom[0] = 0xEF;
					bom[1] = 0xBB;
					bom[2] = 0xBF;
					
					WriteFile(es_export_file,bom,3,&numwritten,0);
				}
			}
		
			// disable pause
			es_pause = 0;
		
			// remove highlighting.
			{
				int columni;
				
				for(columni=0;columni<es_numcolumns;columni++)
				{
					if (es_columns[columni] == ES_COLUMN_HIGHLIGHTED_FILENAME)
					{
						es_columns[columni] = ES_COLUMN_FILENAME;
					}
					else
					if (es_columns[columni] == ES_COLUMN_HIGHLIGHTED_PATH)
					{
						es_columns[columni] = ES_COLUMN_PATH;
					}
					else
					if (es_columns[columni] == ES_COLUMN_HIGHLIGHTED_NAME)
					{
						es_columns[columni] = ES_COLUMN_NAME;
					}
				}
			}
			
			if (es_export_file != INVALID_HANDLE_VALUE)
			{
				es_export_buf = es_alloc(ES_EXPORT_BUF_SIZE);
				es_export_p = es_export_buf;
				es_export_remaining = ES_EXPORT_BUF_SIZE;
			}
			
			if ((es_export == ES_EXPORT_CSV) || (es_export == ES_EXPORT_TSV))
			{
				if (es_header)
				{
					int columni;
					
					for(columni=0;columni<es_numcolumns;columni++)
					{
						if (columni)
						{
							es_fwrite((es_export == ES_EXPORT_CSV) ? L"," : L"\t");
						}

						es_fwrite(es_column_names[es_columns[columni]]);
					}

					es_fwrite(L"\r\n");
				}
			}
			else
			if (es_export == ES_EXPORT_EFU)
			{
				int was_size_column;
				int was_date_modified_column;
				int was_date_created_column;
				int was_attributes_column;
				int column_i;

				was_size_column = 0;
				was_date_modified_column = 0;
				was_date_created_column = 0;
				was_attributes_column = 0;
							
				for(column_i=0;column_i<es_numcolumns;column_i++)
				{
					switch(es_columns[column_i])
					{
						case ES_COLUMN_SIZE:
							was_size_column = 1;
							break;
							
						case ES_COLUMN_DATE_MODIFIED:
							was_date_modified_column = 1;
							break;
							
						case ES_COLUMN_DATE_CREATED:
							was_date_created_column = 1;
							break;
							
						case ES_COLUMN_ATTRIBUTES:
							was_attributes_column = 1;
							break;
					}
				}
				
				// reset columns and force Filename,Size,Date Modified,Date Created,Attributes.
				es_numcolumns = 0;
				es_add_column(ES_COLUMN_FILENAME);
				
				if (was_size_column)
				{
					es_add_column(ES_COLUMN_SIZE);
				}

				if (was_date_modified_column)
				{
					es_add_column(ES_COLUMN_DATE_MODIFIED);
				}

				if (was_date_created_column)
				{
					es_add_column(ES_COLUMN_DATE_CREATED);
				}

				if (was_attributes_column)
				{
					es_add_column(ES_COLUMN_ATTRIBUTES);
				}

				if (es_header)
				{
					es_fwrite(L"Filename,Size,Date Modified,Date Created,Attributes\r\n");
				}
			}
			else
			if ((es_export == ES_EXPORT_TXT) || (es_export == ES_EXPORT_M3U) || (es_export == ES_EXPORT_M3U8))
			{
				// reset columns and force Filename.
				es_numcolumns = 0;
				es_add_column(ES_COLUMN_FILENAME);
			}
		}

		// fix search filter
		if (*es_filter)
		{
			wchar_t *new_search;
			
			new_search = es_alloc(ES_SEARCH_BUF_SIZE * sizeof(wchar_t));
			
			*new_search = 0;
			
			es_wbuf_cat(new_search,ES_SEARCH_BUF_SIZE,L"<");
			es_wbuf_cat(new_search,ES_SEARCH_BUF_SIZE,es_filter);
			es_wbuf_cat(new_search,ES_SEARCH_BUF_SIZE,L"><");
			es_wbuf_cat(new_search,ES_SEARCH_BUF_SIZE,es_search);
			es_wbuf_cat(new_search,ES_SEARCH_BUF_SIZE,L">");
			
			es_free(es_search);
			
			es_search = new_search;
		}

		{
			int got_indexed_file_info;
			
			got_indexed_file_info = 0;
			
			es_everything_hwnd = es_find_ipc_window();
			if (es_everything_hwnd)
			{
				if (!got_indexed_file_info)
				{
					if (es_export == ES_EXPORT_EFU)
					{
						// get indexed file info column for exporting.
						if (SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_IS_FILE_INFO_INDEXED,EVERYTHING_IPC_FILE_INFO_FILE_SIZE))
						{
							es_add_column(ES_COLUMN_SIZE);
						}
						
						if (SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_IS_FILE_INFO_INDEXED,EVERYTHING_IPC_FILE_INFO_DATE_MODIFIED))
						{
							es_add_column(ES_COLUMN_DATE_MODIFIED);
						}
						
						if (SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_IS_FILE_INFO_INDEXED,EVERYTHING_IPC_FILE_INFO_DATE_CREATED))
						{
							es_add_column(ES_COLUMN_DATE_CREATED);
						}
						
						if (SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_IS_FILE_INFO_INDEXED,EVERYTHING_IPC_FILE_INFO_ATTRIBUTES))
						{
							es_add_column(ES_COLUMN_ATTRIBUTES);
						}
					}
					
					got_indexed_file_info = 1;
				}
		
				if (es_ipc_version & 2)
				{
					if (es_sendquery2(hwnd)) 
					{
						// success
						// don't try version 1.
						goto query_sent;
					}
				}

				if (es_ipc_version & 1)
				{
					if (es_sendquery(hwnd)) 
					{
						// success
						// don't try other versions.
						goto query_sent;
					}
				}

				es_fatal(ES_ERROR_SEND_MESSAGE);
			}
		}

query_sent:


		// message pump
	loop:

		// update windows
		if (PeekMessage(&msg,NULL,0,0,0)) 
		{
			ret = (int)GetMessage(&msg,0,0,0);
			if (ret <= 0) goto exit;

			// let windows handle it.
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}			
		else
		{
			WaitMessage();
		}
		
		goto loop;
	}

exit:

	if (es_run_history_data)
	{
		es_free(es_run_history_data);
	}

	if (es_argv)
	{
		es_free(es_argv);
	}

	if (es_search)
	{
		es_free(es_search);
	}
	
	if (es_filter)
	{
		es_free(es_filter);
	}
	
	if (es_instance)
	{
		es_free(es_instance);
	}
	
	if (es_connect)
	{
		es_free(es_connect);
	}

	es_flush();
	
	if (es_export_buf)
	{
		es_free(es_export_buf);
	}
	
	if (es_export_file != INVALID_HANDLE_VALUE)
	{
		CloseHandle(es_export_file);
	}
	
	if (es_user32_hdll)
	{
		FreeLibrary(es_user32_hdll);
	}
		
	if (es_ret != ES_ERROR_SUCCESS)
	{
		es_fatal(es_ret);
	}
		
	return ES_ERROR_SUCCESS;
}

int es_wstring_to_int(const wchar_t *s)
{
	const wchar_t *p;
	int value;
	
	p = s;
	value = 0;
	
	if ((*p == '0') && ((p[1] == 'x') || (p[1] == 'X')))
	{
		p += 2;
		
		while(*p)
		{
			if ((*p >= '0') && (*p <= '9'))
			{
				value *= 16;
				value += *p - '0';
			}
			else
			if ((*p >= 'A') && (*p <= 'F'))
			{
				value *= 16;
				value += *p - 'A' + 10;
			}
			else
			if ((*p >= 'a') && (*p <= 'f'))
			{
				value *= 16;
				value += *p - 'a' + 10;
			}
			else
			{
				break;
			}
			
			p++;
		}
	}
	else
	{
		while(*p)
		{
			if (!((*p >= '0') && (*p <= '9')))
			{
				break;
			}
			
			value *= 10;
			value += *p - '0';
			p++;
		}
	}
	
	return value;
}

// find the Everything IPC window
HWND es_find_ipc_window(void)
{
	DWORD tickstart;
	DWORD tick;
	wchar_t window_class[ES_WSTRING_SIZE];
	HWND ret;

	tickstart = GetTickCount();
	
	*window_class = 0;
	
	es_wstring_cat(window_class,EVERYTHING_IPC_WNDCLASS);
	
	if (*es_instance)
	{
		es_wstring_cat(window_class,L"_(");
		es_wstring_cat(window_class,es_instance);
		es_wstring_cat(window_class,L")");
	}

	ret = 0;
	
	for(;;)
	{
		HWND hwnd;
		
		hwnd = FindWindow(window_class,0);

		if (hwnd)
		{
			// wait for DB_IS_LOADED so we don't get 0 results
			if (es_timeout)
			{
				int major;
				int minor;
				int is_db_loaded;
				
				major = (int)SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_GET_MAJOR_VERSION,0);
				minor = (int)SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_GET_MINOR_VERSION,0);
				
				if (((major == 1) && (minor >= 4)) || (major > 1))
				{
					is_db_loaded = (int)SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_IS_DB_LOADED,0);
					
					if (!is_db_loaded)
					{
						goto wait;
					}
				}
			}
			
			ret = hwnd;
			break;
		}

wait:
		
		if (!es_timeout)
		{
			// the everything window was not found.
			// we can optionally RegisterWindowMessage("EVERYTHING_IPC_CREATED") and 
			// wait for Everything to post this message to all top level windows when its up and running.
			es_fatal(ES_ERROR_IPC);
		}
		
		// try again..
		Sleep(10);
		
		tick = GetTickCount();
		
		if (tick - tickstart > es_timeout)
		{
			// the everything window was not found.
			// we can optionally RegisterWindowMessage("EVERYTHING_IPC_CREATED") and 
			// wait for Everything to post this message to all top level windows when its up and running.
			es_fatal(ES_ERROR_IPC);
		}
	}
	
	return ret;
}

// find the Everything IPC window
static void es_wait_for_db_loaded(void)
{
	DWORD tickstart;
	wchar_t window_class[ES_WSTRING_SIZE];

	tickstart = GetTickCount();
	
	*window_class = 0;
	
	es_wstring_cat(window_class,EVERYTHING_IPC_WNDCLASS);
	
	if (*es_instance)
	{
		es_wstring_cat(window_class,L"_(");
		es_wstring_cat(window_class,es_instance);
		es_wstring_cat(window_class,L")");
	}

	for(;;)
	{
		HWND hwnd;
		DWORD tick;
		
		hwnd = FindWindow(window_class,0);

		if (hwnd)
		{
			int major;
			int minor;
			int is_db_loaded;
			
			// wait for DB_IS_LOADED so we don't get 0 results
			major = (int)SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_GET_MAJOR_VERSION,0);
			minor = (int)SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_GET_MINOR_VERSION,0);
			
			if (((major == 1) && (minor >= 4)) || (major > 1))
			{
				is_db_loaded = (int)SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_IS_DB_LOADED,0);
				
				if (is_db_loaded)
				{
					break;
				}
			}
			else
			{
				// can't wait
				break;
			}
		}
		else
		{
			// window was closed.
			break;
		}
		
		// try again..
		Sleep(10);
		
		tick = GetTickCount();
		
		if (es_timeout)
		{
			if (tick - tickstart > es_timeout)
			{
				// the everything window was not found.
				// we can optionally RegisterWindowMessage("EVERYTHING_IPC_CREATED") and 
				// wait for Everything to post this message to all top level windows when its up and running.
				es_fatal(ES_ERROR_IPC);
			}
		}
	}
}

// find the Everything IPC window
static void es_wait_for_db_not_busy(void)
{
	DWORD tickstart;
	wchar_t window_class[ES_WSTRING_SIZE];

	tickstart = GetTickCount();
	
	*window_class = 0;
	
	es_wstring_cat(window_class,EVERYTHING_IPC_WNDCLASS);
	
	if (*es_instance)
	{
		es_wstring_cat(window_class,L"_(");
		es_wstring_cat(window_class,es_instance);
		es_wstring_cat(window_class,L")");
	}

	for(;;)
	{
		HWND hwnd;
		DWORD tick;
		
		hwnd = FindWindow(window_class,0);

		if (hwnd)
		{
			int major;
			int minor;
			
			// wait for DB_IS_LOADED so we don't get 0 results
			major = (int)SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_GET_MAJOR_VERSION,0);
			minor = (int)SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_GET_MINOR_VERSION,0);
			
			if (((major == 1) && (minor >= 4)) || (major > 1))
			{
				int is_busy;
				
				is_busy = (int)SendMessage(es_everything_hwnd,EVERYTHING_WM_IPC,EVERYTHING_IPC_IS_DB_BUSY,0);
				
				if (!is_busy)
				{
					break;
				}
			}
			else
			{
				// can't check.
				break;
			}
		}
		else
		{
			// window was closed.
			break;
		}
		
		// try again..
		Sleep(10);
		
		tick = GetTickCount();
		
		if (es_timeout)
		{
			if (tick - tickstart > es_timeout)
			{
				// the everything window was not found.
				// we can optionally RegisterWindowMessage("EVERYTHING_IPC_CREATED") and 
				// wait for Everything to post this message to all top level windows when its up and running.
				es_fatal(ES_ERROR_IPC);
			}
		}
	}
}

void es_wstring_copy(wchar_t *buf,const wchar_t *s)
{
	int max;
	
	max = ES_WSTRING_SIZE - 1;
	while(max)
	{
		if (!*s) 
		{
			break;
		}
		
		*buf = *s;
		
		buf++;
		s++;
		max--;
	}
	
	*buf = 0;
}

// cat a string to buf
// max MUST be > 0
void es_wstring_cat(wchar_t *buf,const wchar_t *s)
{
	es_wbuf_cat(buf,ES_WSTRING_SIZE,s);
}

// cat a string to buf
// max MUST be > 0
void es_wstring_cat_qword(wchar_t *buf,QWORD qw)
{
	wchar_t qwbuf[ES_WSTRING_SIZE];
	
	es_wstring_print_qword(qwbuf,qw);
	
	es_wstring_cat(buf,qwbuf);
	
}

int es_check_param(wchar_t *param,const wchar_t *s)
{
	if ((*param == '-') || (*param == '/'))
	{
		param++;
		
		return es_check_param_param(param,s);
	}
	
	return 0;
}

int es_check_param_param(wchar_t *param,const wchar_t *s)
{
	while(*s)
	{
		if (*s == '-')
		{
			if (*param == '-')
			{
				param++;
			}
		
			s++;
		}
		else
		{
			if (*param != *s)
			{
				return 0;
			}
		
			param++;
			s++;
		}
	}
	
	if (*param)
	{
		return 0;
	}
	
	return 1;
}

void es_set_sort_ascending(void)
{
	switch(es_sort)
	{
		case EVERYTHING_IPC_SORT_NAME_DESCENDING:
			es_sort = EVERYTHING_IPC_SORT_NAME_ASCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_PATH_DESCENDING:
			es_sort = EVERYTHING_IPC_SORT_PATH_ASCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_SIZE_DESCENDING:
			es_sort = EVERYTHING_IPC_SORT_SIZE_ASCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_EXTENSION_DESCENDING:
			es_sort = EVERYTHING_IPC_SORT_EXTENSION_ASCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_TYPE_NAME_DESCENDING:
			es_sort = EVERYTHING_IPC_SORT_TYPE_NAME_ASCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_DATE_CREATED_DESCENDING:
			es_sort = EVERYTHING_IPC_SORT_DATE_CREATED_ASCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_DATE_MODIFIED_DESCENDING:
			es_sort = EVERYTHING_IPC_SORT_DATE_MODIFIED_ASCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_ATTRIBUTES_DESCENDING:
			es_sort = EVERYTHING_IPC_SORT_ATTRIBUTES_ASCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_FILE_LIST_FILENAME_DESCENDING:
			es_sort = EVERYTHING_IPC_SORT_FILE_LIST_FILENAME_ASCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_RUN_COUNT_DESCENDING:
			es_sort = EVERYTHING_IPC_SORT_RUN_COUNT_ASCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_DATE_RECENTLY_CHANGED_DESCENDING:
			es_sort = EVERYTHING_IPC_SORT_DATE_RECENTLY_CHANGED_ASCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_DATE_ACCESSED_DESCENDING:
			es_sort = EVERYTHING_IPC_SORT_DATE_ACCESSED_ASCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_DATE_RUN_DESCENDING:
			es_sort = EVERYTHING_IPC_SORT_DATE_RUN_ASCENDING;
			break;
	}
}
	
void es_set_sort_descending(void)
{
	switch(es_sort)
	{
		case EVERYTHING_IPC_SORT_NAME_ASCENDING:
			es_sort = EVERYTHING_IPC_SORT_NAME_DESCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_PATH_ASCENDING:
			es_sort = EVERYTHING_IPC_SORT_PATH_DESCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_SIZE_ASCENDING:
			es_sort = EVERYTHING_IPC_SORT_SIZE_DESCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_EXTENSION_ASCENDING:
			es_sort = EVERYTHING_IPC_SORT_EXTENSION_DESCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_TYPE_NAME_ASCENDING:
			es_sort = EVERYTHING_IPC_SORT_TYPE_NAME_DESCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_DATE_CREATED_ASCENDING:
			es_sort = EVERYTHING_IPC_SORT_DATE_CREATED_DESCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_DATE_MODIFIED_ASCENDING:
			es_sort = EVERYTHING_IPC_SORT_DATE_MODIFIED_DESCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_ATTRIBUTES_ASCENDING:
			es_sort = EVERYTHING_IPC_SORT_ATTRIBUTES_DESCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_FILE_LIST_FILENAME_ASCENDING:
			es_sort = EVERYTHING_IPC_SORT_FILE_LIST_FILENAME_DESCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_RUN_COUNT_ASCENDING:
			es_sort = EVERYTHING_IPC_SORT_RUN_COUNT_DESCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_DATE_RECENTLY_CHANGED_ASCENDING:
			es_sort = EVERYTHING_IPC_SORT_DATE_RECENTLY_CHANGED_DESCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_DATE_ACCESSED_ASCENDING:
			es_sort = EVERYTHING_IPC_SORT_DATE_ACCESSED_DESCENDING;
			break;
			
		case EVERYTHING_IPC_SORT_DATE_RUN_ASCENDING:
			es_sort = EVERYTHING_IPC_SORT_DATE_RUN_DESCENDING;
			break;
	}
}

int es_find_column(int type)
{
	int i;
	
	for(i=0;i<es_numcolumns;i++)
	{
		if (es_columns[i] == type)
		{
			return i;
		}
	}

	return -1;
}
		
void es_add_column(int type)
{
	es_remove_column(type);
	
	es_columns[es_numcolumns++] = type;
}

void es_remove_column(type)
{
	int i;
	int newcount;
	
	newcount = 0;
	
	for(i=0;i<es_numcolumns;i++)
	{
		if (es_columns[i] != type)
		{
			es_columns[newcount++] = es_columns[i];
		}
	}
	
	es_numcolumns = newcount;
}
		
void *es_get_column_data(EVERYTHING_IPC_LIST2 *list,int index,int type)
{	
	char *p;
	EVERYTHING_IPC_ITEM2 *items;
	
	items = (EVERYTHING_IPC_ITEM2 *)(list + 1);
	
	p = ((char *)list) + items[index].data_offset;

	if (list->request_flags & EVERYTHING_IPC_QUERY2_REQUEST_NAME)
	{
		DWORD len;

		if (type == ES_COLUMN_NAME)	
		{
			return p;
		}
		
		len = *(DWORD *)p;
		p += sizeof(DWORD);
		
		p += (len + 1) * sizeof(wchar_t);
	}		
	
	if (list->request_flags & EVERYTHING_IPC_QUERY2_REQUEST_PATH)
	{
		DWORD len;
		
		if (type == ES_COLUMN_PATH)	
		{
			return p;
		}
		
		len = *(DWORD *)p;
		p += sizeof(DWORD);
		
		p += (len + 1) * sizeof(wchar_t);
	}
	
	if (list->request_flags & EVERYTHING_IPC_QUERY2_REQUEST_FULL_PATH_AND_NAME)
	{
		DWORD len;
		
		if (type == ES_COLUMN_FILENAME)	
		{
			return p;
		}
		
		len = *(DWORD *)p;
		p += sizeof(DWORD);

		p += (len + 1) * sizeof(wchar_t);
	}
	
	if (list->request_flags & EVERYTHING_IPC_QUERY2_REQUEST_EXTENSION)
	{
		DWORD len;
		
		if (type == ES_COLUMN_EXTENSION)	
		{
			return p;
		}
		
		len = *(DWORD *)p;
		p += sizeof(DWORD);
		
		p += (len + 1) * sizeof(wchar_t);
	}
	
	if (list->request_flags & EVERYTHING_IPC_QUERY2_REQUEST_SIZE)
	{
		if (type == ES_COLUMN_SIZE)	
		{
			return p;
		}
		
		p += sizeof(LARGE_INTEGER);
	}
	
	if (list->request_flags & EVERYTHING_IPC_QUERY2_REQUEST_DATE_CREATED)
	{
		if (type == ES_COLUMN_DATE_CREATED)	
		{
			return p;
		}
		
		p += sizeof(FILETIME);
	}
	
	if (list->request_flags & EVERYTHING_IPC_QUERY2_REQUEST_DATE_MODIFIED)
	{
		if (type == ES_COLUMN_DATE_MODIFIED)	
		{
			return p;
		}
		
		p += sizeof(FILETIME);
	}
	
	if (list->request_flags & EVERYTHING_IPC_QUERY2_REQUEST_DATE_ACCESSED)
	{
		if (type == ES_COLUMN_DATE_ACCESSED)	
		{
			return p;
		}
		
		p += sizeof(FILETIME);
	}
	
	if (list->request_flags & EVERYTHING_IPC_QUERY2_REQUEST_ATTRIBUTES)
	{
		if (type == ES_COLUMN_ATTRIBUTES)	
		{
			return p;
		}
		
		p += sizeof(DWORD);
	}
		
	if (list->request_flags & EVERYTHING_IPC_QUERY2_REQUEST_FILE_LIST_FILE_NAME)
	{
		DWORD len;
		
		if (type == ES_COLUMN_FILE_LIST_FILENAME)	
		{
			return p;
		}
		
		len = *(DWORD *)p;
		p += sizeof(DWORD);
		
		p += (len + 1) * sizeof(wchar_t);
	}	
		
	if (list->request_flags & EVERYTHING_IPC_QUERY2_REQUEST_RUN_COUNT)
	{
		if (type == ES_COLUMN_RUN_COUNT)	
		{
			return p;
		}
		
		p += sizeof(DWORD);
	}	
	
	if (list->request_flags & EVERYTHING_IPC_QUERY2_REQUEST_DATE_RUN)
	{
		if (type == ES_COLUMN_DATE_RUN)	
		{
			return p;
		}
		
		p += sizeof(FILETIME);
	}		
	
	if (list->request_flags & EVERYTHING_IPC_QUERY2_REQUEST_DATE_RECENTLY_CHANGED)
	{
		if (type == ES_COLUMN_DATE_RECENTLY_CHANGED)	
		{
			return p;
		}
		
		p += sizeof(FILETIME);
	}	
	
	if (list->request_flags & EVERYTHING_IPC_QUERY2_REQUEST_HIGHLIGHTED_NAME)
	{
		DWORD len;
		
		if (type == ES_COLUMN_HIGHLIGHTED_NAME)	
		{
			return p;
		}
		
		len = *(DWORD *)p;
		p += sizeof(DWORD);
		
		p += (len + 1) * sizeof(wchar_t);
	}		
	
	if (list->request_flags & EVERYTHING_IPC_QUERY2_REQUEST_HIGHLIGHTED_PATH)
	{
		DWORD len;
		
		if (type == ES_COLUMN_HIGHLIGHTED_PATH)	
		{
			return p;
		}
		
		len = *(DWORD *)p;
		p += sizeof(DWORD);
		
		p += (len + 1) * sizeof(wchar_t);
	}
	
	if (list->request_flags & EVERYTHING_IPC_QUERY2_REQUEST_HIGHLIGHTED_FULL_PATH_AND_NAME)
	{
		DWORD len;
		
		if (type == ES_COLUMN_HIGHLIGHTED_FILENAME)	
		{
			return p;
		}
		
		len = *(DWORD *)p;
		p += sizeof(DWORD);
		
		p += (len + 1) * sizeof(wchar_t);
	}			
	
	return 0;
}

void es_format_dir(wchar_t *buf)
{
	es_wstring_copy(buf,L"<DIR>");
	
//	es_space_to_width(buf,es_size_width);
}

void es_format_size(wchar_t *buf,QWORD size)
{
	if (size != 0xffffffffffffffffI64)
	{
		if (es_size_format == 0)
		{
			// auto size.
			if (size < 1000)
			{
				es_wstring_print_qword(buf,size);
				es_wstring_cat(buf,L"  B");
			}
			else
			{
				const wchar_t *suffix;
				
				// get suffix
				if (size / 1024I64 < 1000)
				{
					size = ((size * 100) ) / 1024;
					
					suffix = L" KB";
				}
				else
				if (size / (1024I64*1024I64) < 1000)
				{
					size = ((size * 100) ) / 1048576;
					
					suffix = L" MB";
				}
				else
				if (size / (1024I64*1024I64*1024I64) < 1000)
				{
					size = ((size * 100) ) / (1024I64*1024I64*1024I64);
					
					suffix = L" GB";
				}
				else
				if (size / (1024I64*1024I64*1024I64*1024I64) < 1000)
				{
					size = ((size * 100) ) / (1024I64*1024I64*1024I64*1024I64);
					
					suffix = L" TB";
				}
				else
				{
					size = ((size * 100) ) / (1024I64*1024I64*1024I64*1024I64*1024I64);
					
					suffix = L" PB";
				}
				
				*buf = 0;
				
				if (size == 0)
				{
					es_wstring_cat_qword(buf,size);
					es_wstring_cat(buf,suffix);
				}
				else
				if (size < 10)
				{
					// 0.0x
					es_wstring_cat(buf,L"0.0");
					es_wstring_cat_qword(buf,size);
					es_wstring_cat(buf,suffix);
				}
				else
				if (size < 100)
				{
					// 0.xx
					es_wstring_cat(buf,L"0.");
					es_wstring_cat_qword(buf,size);
					es_wstring_cat(buf,suffix);
				}
				else
				if (size < 1000)
				{
					// x.xx
					es_wstring_cat_qword(buf,size/100);
					es_wstring_cat(buf,L".");
					if (size%100 < 10)
					{
						// leading zero
						es_wstring_cat_qword(buf,0);
					}
					es_wstring_cat_qword(buf,size%100);
					es_wstring_cat(buf,suffix);
				}
				else
				if (size < 10000)
				{
					// xx.x
					es_wstring_cat_qword(buf,size/100);
					es_wstring_cat(buf,L".");
					es_wstring_cat_qword(buf,(size/10)%10);
					es_wstring_cat(buf,suffix);
				}
				else
				if (size < 100000)
				{
					// xxx
					es_wstring_cat_qword(buf,size/100);
					es_wstring_cat(buf,suffix);
				}
				else
				{
					// too big..
					es_format_number(buf,size/100);
					es_wstring_cat(buf,suffix);				
				}
			}
		}
		else
		if (es_size_format == 2)
		{
			es_format_number(buf,((size) + 1023) / 1024);
			es_wstring_cat(buf,L" KB");
		}
		else
		if (es_size_format == 3)
		{
			es_format_number(buf,((size) + 1048575) / 1048576);
			es_wstring_cat(buf,L" MB");
		}
		else
		if (es_size_format == 4)
		{
			es_format_number(buf,((size) + 1073741823) / 1073741824);
			es_wstring_cat(buf,L" GB");
		}
		else
		{
			es_format_number(buf,size);
		}
	}
	else
	{
		*buf = 0;
	}

//	es_format_leading_space(buf,es_size_width,es_size_leading_zero);
}

void es_format_leading_space(wchar_t *buf,int size,int ch)
{
	int len;
	
	len = es_wstring_length(buf);

	if (es_digit_grouping)
	{
		ch = ' ';
	}

	if (len < size)
	{
		int i;
		
		MoveMemory(buf+(size-len),buf,(len + 1) * sizeof(wchar_t));
		
		for(i=0;i<size-len;i++)
		{
			buf[i] = ch;
		}
	}
}

int es_filetime_to_localtime(SYSTEMTIME *localst,QWORD ft)
{
	// try to convert with SystemTimeToTzSpecificLocalTime which will handle daylight savings correctly.
	{
		SYSTEMTIME utcst;
		
		if (FileTimeToSystemTime((FILETIME *)&ft,&utcst))
		{
			if (SystemTimeToTzSpecificLocalTime(NULL,&utcst,localst))
			{
				return 1;
			}
		}
	}
	
//	debug_color_printf(0xffff0000,"SystemTimeToTzSpecificLocalTime failed %d\n",GetLastError());
	
	// win9x: just convert normally.
	{
		FILETIME localft;
		
		if (FileTimeToLocalFileTime((FILETIME *)&ft,&localft))
		{
			if (FileTimeToSystemTime(&localft,localst))
			{
				return 1;
			}
		}
	}
	
	return 0;
}

void es_format_attributes(wchar_t *buf,DWORD attributes)
{
	wchar_t *d;
	
	d = buf;
	
	if (attributes & FILE_ATTRIBUTE_READONLY) *d++ = 'R';
	if (attributes & FILE_ATTRIBUTE_HIDDEN) *d++ = 'H';
	if (attributes & FILE_ATTRIBUTE_SYSTEM) *d++ = 'S';
	if (attributes & FILE_ATTRIBUTE_DIRECTORY) *d++ = 'D';
	if (attributes & FILE_ATTRIBUTE_ARCHIVE) *d++ = 'A';
	if (attributes & 0x8000) *d++ = 'V'; // FILE_ATTRIBUTE_INTEGRITY_STREAM
	if (attributes & 0x20000) *d++ = 'X'; // FILE_ATTRIBUTE_NO_SCRUB_DATA
	if (attributes & FILE_ATTRIBUTE_NORMAL) *d++ = 'N';
	if (attributes & FILE_ATTRIBUTE_TEMPORARY) *d++ = 'T';
//	if (attributes & FILE_ATTRIBUTE_SPARSE_FILE) *d++ = 'P';
	if (attributes & FILE_ATTRIBUTE_REPARSE_POINT) *d++ = 'L';
	if (attributes & FILE_ATTRIBUTE_COMPRESSED) *d++ = 'C';
	if (attributes & FILE_ATTRIBUTE_OFFLINE) *d++ = 'O';
	if (attributes & FILE_ATTRIBUTE_NOT_CONTENT_INDEXED) *d++ = 'I';
	if (attributes & FILE_ATTRIBUTE_ENCRYPTED) *d++ = 'E';
	if (attributes & 0x00100000) *d++ = 'U'; // FILE_ATTRIBUTE_UNPINNED; break;
	if (attributes & 0x00080000) *d++ = 'P'; // FILE_ATTRIBUTE_PINNED; break;
	if (attributes & 0x00400000) *d++ = 'M'; // FILE_ATTRIBUTE_RECALL_ON_DATA_ACCESS; break;

	*d = 0;

//	es_space_to_width(buf,es_attributes_width);
}

void es_format_run_count(wchar_t *buf,DWORD run_count)
{
	es_format_number(buf,run_count);

//	es_format_leading_space(buf,es_run_count_width,es_run_count_leading_zero);
}

void es_format_filetime(wchar_t *buf,QWORD filetime)
{
	if (filetime != 0xffffffffffffffffI64)
	{
		switch(es_date_format)
		{	
			default:
			case 0: // system format
			{
				wchar_t dmybuf[ES_WSTRING_SIZE];
				int dmyformat;
				SYSTEMTIME st;
				int val1;
				int val2;
				int val3;
								
				dmyformat = 1;

				if (GetLocaleInfoW(LOCALE_USER_DEFAULT,LOCALE_IDATE,dmybuf,ES_WSTRING_SIZE))
				{
					dmyformat = dmybuf[0] - '0';
				}
				
				es_filetime_to_localtime(&st,filetime);
				
				switch(dmyformat)
				{
					case 0: val1 = st.wMonth; val2 = st.wDay; val3 = st.wYear; break; // Month-Day-Year
					default: val1 = st.wDay; val2 = st.wMonth; val3 = st.wYear; break; // Day-Month-Year
					case 2: val1 = st.wYear; val2 = st.wMonth; val3 = st.wDay; break; // Year-Month-Day
				}

				wsprintf(buf,L"%02d/%02d/%02d %02d:%02d",val1,val2,val3,st.wHour,st.wMinute);
	//seconds		wsprintf(buf,L"%02d/%02d/%02d %02d:%02d:%02d",val1,val2,val3,st.wHour,st.wMinute,st.wSecond);
				break;
			}
				
			case 1: // ISO-8601
			{
				SYSTEMTIME st;
				es_filetime_to_localtime(&st,filetime);
				wsprintf(buf,L"%04d-%02d-%02dT%02d:%02d:%02d",st.wYear,st.wMonth,st.wDay,st.wHour,st.wMinute,st.wSecond);
				break;
			}

			case 2: // raw filetime
				wsprintf(buf,L"%I64u",filetime);
				break;
				
			case 3: // ISO-8601 (UTC/Z)
			{
				SYSTEMTIME st;
				FileTimeToSystemTime((FILETIME *)&filetime,&st);
				wsprintf(buf,L"%04d-%02d-%02dT%02d:%02d:%02dZ",st.wYear,st.wMonth,st.wDay,st.wHour,st.wMinute,st.wSecond);
				break;
			}
		}
	}
	else
	{
		*buf = 0;
	}
}

void es_wstring_print_qword(wchar_t *buf,QWORD number)
{
	wchar_t *d;
	
	d = buf + ES_WSTRING_SIZE;
	*--d = 0;

	if (number)
	{
		QWORD i;
		
		i = number;
		
		while(i)
		{
			*--d = (wchar_t)('0' + (i % 10));
			
			i /= 10;
		}
	}
	else
	{
		*--d = '0';
	}	
	
	MoveMemory(buf,d,((buf + ES_WSTRING_SIZE) - d) * sizeof(wchar_t));
}

void es_format_number(wchar_t *buf,QWORD number)
{
	wchar_t *d;
	int comma;
	
	d = buf + ES_WSTRING_SIZE;
	*--d = 0;
	comma = 0;

	if (number)
	{
		QWORD i;
		
		i = number;
		
		while(i)
		{
			if (comma >= 3)
			{
				if (es_digit_grouping)
				{
					*--d = ',';
				}
				
				comma = 0;
			}
		
			*--d = (wchar_t)('0' + (i % 10));
			
			i /= 10;
			
			comma++;
		}
	}
	else
	{
		*--d = '0';
	}	
	
	MoveMemory(buf,d,((buf + ES_WSTRING_SIZE) - d) * sizeof(wchar_t));
}

void es_space_to_width(wchar_t *buf,int wide)
{
	int len;
	
	len = es_wstring_length(buf);
	
	if (len < wide)
	{
		int i;
		
		for(i=0;i<wide-len;i++)
		{
			buf[i+len] = ' ';
		}
		
		buf[i+len] = 0;
	}
}

void *es_alloc(uintptr_t size)
{
	void *p;

	p = HeapAlloc(GetProcessHeap(),0,size);
	if (!p)
	{
		es_fatal(ES_ERROR_OUT_OF_MEMORY);
	}
	
	return p;
}

void es_free(void *ptr)
{
	HeapFree(GetProcessHeap(),0,ptr);
}

int es_is_ws(const wchar_t c)
{
	if ((c == ' ') || (c == '\t') || (c == '\r') || (c == '\n'))
	{
		return 1;
	}
	
	return 0;
}

const wchar_t *es_skip_ws(const wchar_t *p)
{
	while(*p)
	{
		if (!es_is_ws(*p))
		{
			break;
		}
		
		p++;
	}
	
	return p;
}

const wchar_t *es_get_argv(const wchar_t *command_line)
{
	int pass;
	int inquote;
	wchar_t *d;
	
	if (es_argv)
	{
		es_free(es_argv);
		
		es_argv = 0;
	}
	
	if (!*command_line)
	{
		return 0;
	}
	
	d = 0;
	
	for(pass=0;pass<2;pass++)
	{
		const wchar_t *p;

		p = es_skip_ws(command_line);
		
		inquote = 0;
		
		while(*p)
		{
			if ((!inquote) && (es_is_ws(*p)))
			{
				break;
			}
			else
			if (*p == '"')
			{
				if (pass)
				{
					*d = '"';
				}
				
				d++;

				p++;

				// 3 quotes = 1 literal quote.
				if ((*p == '"') && (p[1] == '"'))
				{
					p += 2;
					
					if (pass)
					{
						*d = '"';
					}
					
					d++;
				}
				else
				{
					inquote = !inquote;
				}
			}
			else
			{
				if (pass) 
				{
					*d = *p;
				}

				d++;
				p++;
			}
		}
	
		if (pass) 
		{
			*d = 0;
			return p;
		}
		else
		{
			d = es_alloc((uintptr_t)(d+1));
			es_argv = d;
		}		
	}
	
	return 0;
}

// like es_get_argv, but we remove double quotes.
const wchar_t *es_get_command_argv(const wchar_t *command_line)
{
	int pass;
	int inquote;
	wchar_t *d;
	
	if (es_argv)
	{
		es_free(es_argv);
		
		es_argv = 0;
	}
	
	if (!*command_line)
	{
		return 0;
	}
	
	d = 0;
	
	for(pass=0;pass<2;pass++)
	{
		const wchar_t *p;

		p = es_skip_ws(command_line);
		
		inquote = 0;
		
		while(*p)
		{
			if ((!inquote) && (es_is_ws(*p)))
			{
				break;
			}
			else
			if (*p == '"')
			{
				p++;

				// 3 quotes = 1 literal quote.
				if ((*p == '"') && (p[1] == '"'))
				{
					p += 2;
					
					if (pass)
					{
						*d = '"';
					}
					
					d++;
				}
				else
				{
					inquote = !inquote;
				}
			}
			else
			{
				if (pass) 
				{
					*d = *p;
				}

				d++;
				p++;
			}
		}
	
		if (pass) 
		{
			*d = 0;
			return p;
		}
		else
		{
			d = es_alloc((uintptr_t)(d+1));
			es_argv = d;
		}		
	}
	
	return 0;
}

void es_set_color(int id)
{
	es_column_color[id] = es_wstring_to_int(es_argv);
	es_column_color_is_valid[id] = 1;
}

void es_set_column_wide(int id)
{
	es_column_widths[id] = es_wstring_to_int(es_argv);
	
	// sanity.
	if (es_column_widths[id] < 0) 
	{
		es_column_widths[id] = 0;
	}
	
	if (es_column_widths[id] > 200) 
	{
		es_column_widths[id] = 200;
	}
}

int es_is_valid_key(INPUT_RECORD *ir)
{
	switch (ir->Event.KeyEvent.wVirtualKeyCode)
	{
		case 0x00: //  
		case 0x10: // SHIFT
		case 0x11: // CONTROL
		case 0x12: // ALT
		case 0x13: // PAUSE
		case 0x14: // CAPITAL
		case 0x90: // NUMLOCK
		case 0x91: // SCROLLLOCK
            return 0;
    }
    
    return 1;
}

int es_get_ini_filename(char *buf)
{
	char exe_filename[MAX_PATH];
	
	if (GetModuleFileNameA(0,exe_filename,MAX_PATH))
	{
		if (PathRemoveFileSpecA(exe_filename))
		{
			if (PathCombineA(buf,exe_filename,"es.ini"))
			{
				return 1;
			}
		}
	}
	
	return 0;
}

void es_ini_write_int(const char *name,int value,const char *filename)
{
	char numbuf[256];
	
	sprintf(numbuf,"%u",value);

	WritePrivateProfileStringA("ES",name,numbuf,filename);
}

void es_ini_write_string(const char *name,const wchar_t *value,const char *filename)
{
	int len;
	
	len = WideCharToMultiByte(CP_UTF8,0,value,-1,0,0,0,0);
	if (len)
	{	
		es_buf_t cbuf;
		
		es_buf_init(&cbuf,len);

		if (WideCharToMultiByte(CP_UTF8,0,value,-1,cbuf.buf,len,0,0))
		{
			WritePrivateProfileStringA("ES",name,cbuf.buf,filename);
		}

		es_buf_kill(&cbuf);
	}
}

void es_save_settings(void)
{
	char filename[ES_WSTRING_SIZE];
	
	if (es_get_ini_filename(filename))
	{
		es_ini_write_int("sort",es_sort,filename);
		es_ini_write_int("sort_ascending",es_sort_ascending,filename);
		es_ini_write_string("instance",es_instance,filename);
		es_ini_write_int("highlight_color",es_highlight_color,filename);
		es_ini_write_int("highlight",es_highlight,filename);
		es_ini_write_int("match_whole_word",es_match_whole_word,filename);
		es_ini_write_int("match_path",es_match_path,filename);
		es_ini_write_int("match_case",es_match_case,filename);
		es_ini_write_int("match_diacritics",es_match_diacritics,filename);

		{
			wchar_t columnbuf[ES_WSTRING_SIZE];
			int columni;
			
			*columnbuf = 0;
			
			for(columni=0;columni<es_numcolumns;columni++)
			{
				if (columni)
				{
					es_wstring_cat(columnbuf,L",");
				}
				
				es_wstring_cat_qword(columnbuf,es_columns[columni]);
			}

			es_ini_write_string("columns",columnbuf,filename);
		}

		es_ini_write_int("size_leading_zero",es_size_leading_zero,filename);
		es_ini_write_int("run_count_leading_zero",es_run_count_leading_zero,filename);
		es_ini_write_int("digit_grouping",es_digit_grouping,filename);
		es_ini_write_int("offset",es_offset,filename);
		es_ini_write_int("max_results",es_max_results,filename);
		es_ini_write_int("timeout",es_timeout,filename);

		{
			wchar_t colorbuf[ES_WSTRING_SIZE];
			int columni;
			
			*colorbuf = 0;
			
			for(columni=0;columni<ES_COLUMN_TOTAL;columni++)
			{
				if (columni)
				{
					es_wstring_cat(colorbuf,L",");
				}
				
				if (es_column_color_is_valid[columni])
				{
					es_wstring_cat_qword(colorbuf,es_column_color[columni]);
				}
			}

			es_ini_write_string("column_colors",colorbuf,filename);
		}

		es_ini_write_int("size_format",es_size_format,filename);
		es_ini_write_int("date_format",es_date_format,filename);
		es_ini_write_int("pause",es_pause,filename);
		es_ini_write_int("empty_search_help",es_empty_search_help,filename);
		es_ini_write_int("hide_empty_search_results",es_hide_empty_search_results,filename);
		
		{
			wchar_t widthbuf[ES_WSTRING_SIZE];
			int columni;
			
			*widthbuf = 0;
			
			for(columni=0;columni<ES_COLUMN_TOTAL;columni++)
			{
				if (columni)
				{
					es_wstring_cat(widthbuf,L",");
				}
				
				es_wstring_cat_qword(widthbuf,es_column_widths[columni]);
			}

			es_ini_write_string("column_widths",widthbuf,filename);
		}
	}
}

int es_ini_read_string(const char *name,wchar_t *pvalue,const char *filename)
{
	char buf[ES_WSTRING_SIZE];
	char default_string[ES_WSTRING_SIZE];
	
	default_string[0] = 0;
	
	if (GetPrivateProfileStringA("ES",name,default_string,buf,ES_WSTRING_SIZE,filename))
	{
		if (*buf)
		{
			if (MultiByteToWideChar(CP_UTF8,0,buf,-1,pvalue,ES_WSTRING_SIZE))
			{
				return 1;
			}
		}
	}
	
	return 0;
}

int es_ini_read_int(const char *name,int *pvalue,const char *filename)
{
	wchar_t wbuf[ES_WSTRING_SIZE];
	
	if (es_ini_read_string(name,wbuf,filename))
	{	
		*pvalue = es_wstring_to_int(wbuf);
		
		return 1;
	}
	
	return 0;
}


void es_load_settings(void)
{
	char filename[ES_WSTRING_SIZE];
	
	if (es_get_ini_filename(filename))
	{
		es_ini_read_int("sort",&es_sort,filename);
		es_ini_read_int("sort_ascending",&es_sort_ascending,filename);
		es_ini_read_string("instance",es_instance,filename);
		es_ini_read_int("highlight_color",&es_highlight_color,filename);
		es_ini_read_int("highlight",&es_highlight,filename);
		es_ini_read_int("match_whole_word",&es_match_whole_word,filename);
		es_ini_read_int("match_path",&es_match_path,filename);
		es_ini_read_int("match_case",&es_match_case,filename);
		es_ini_read_int("match_diacritics",&es_match_diacritics,filename);

		{
			wchar_t columnbuf[ES_WSTRING_SIZE];
			wchar_t *p;
			
			*columnbuf = 0;
			
			es_ini_read_string("columns",columnbuf,filename);
			
			p = columnbuf;
			
			while(*p)
			{
				const wchar_t *start;
				int columntype;
				
				start = p;
				
				while(*p)
				{
					if (*p == ',')
					{
						*p++ = 0;
						
						break;
					}

					p++;
				}
				
				if (*start)
				{
					columntype = es_wstring_to_int(start);
					
					if ((columntype >= 0) && (columntype < ES_COLUMN_TOTAL))
					{
						es_add_column(columntype);
					}
				}
			}
		}

		es_ini_read_int("size_leading_zero",&es_size_leading_zero,filename);
		es_ini_read_int("run_count_leading_zero",&es_run_count_leading_zero,filename);
		es_ini_read_int("digit_grouping",&es_digit_grouping,filename);
		es_ini_read_int("offset",&es_offset,filename);
		es_ini_read_int("max_results",&es_max_results,filename);
		es_ini_read_int("timeout",&es_timeout,filename);

		{
			wchar_t colorbuf[ES_WSTRING_SIZE];
			wchar_t *p;
			int column_index;
			
			*colorbuf = 0;
			
			es_ini_read_string("column_colors",colorbuf,filename);
			
			p = colorbuf;
			column_index = 0;
			
			while(*p)
			{
				const wchar_t *start;
				int color;
				
				start = p;
				
				while(*p)
				{
					if (*p == ',')
					{
						*p++ = 0;
						
						break;
					}

					p++;
				}
				
				if (*start)
				{
					color = es_wstring_to_int(start);
					
					es_column_color[column_index] = color;
					es_column_color_is_valid[column_index] = 1;
				}
				
				column_index++;
			}
		}

		es_ini_read_int("size_format",&es_size_format,filename);
		es_ini_read_int("date_format",&es_date_format,filename);
		es_ini_read_int("pause",&es_pause,filename);
		es_ini_read_int("empty_search_help",&es_empty_search_help,filename);
		es_ini_read_int("hide_empty_search_results",&es_hide_empty_search_results,filename);
		
		{
			wchar_t widthbuf[ES_WSTRING_SIZE];
			wchar_t *p;
			int column_index;
			
			*widthbuf = 0;
			
			es_ini_read_string("column_widths",widthbuf,filename);
			
			p = widthbuf;
			column_index = 0;
			
			while(*p)
			{
				const wchar_t *start;
				int width;
				
				start = p;
				
				while(*p)
				{
					if (*p == ',')
					{
						*p++ = 0;
						
						break;
					}

					p++;
				}
				
				if (*start)
				{
					width = es_wstring_to_int(start);
					
					// sanity.
					if (width < 0) 
					{
						width = 0;
					}
					
					if (width > 200) 
					{
						width = 200;
					}						
					
					es_column_widths[column_index] = width;
				}
				
				column_index++;
			}
		}		
	}
}

void es_append_filter(const wchar_t *filter)
{
	if (*es_filter)
	{
		es_wbuf_cat(es_filter,ES_FILTER_BUF_SIZE,L" ");
	}

	es_wbuf_cat(es_filter,ES_FILTER_BUF_SIZE,filter);
}

// max MUST be > 0
void es_wbuf_cat(wchar_t *buf,int max,const wchar_t *s)
{
	const wchar_t *p;
	wchar_t *d;
	
	max--;
	d = buf;
	
	while(max)
	{
		if (!*d) break;
		
		d++;
		max--;
	}
	
	p = s;
	while(max)
	{
		if (!*p) break;
		
		*d++ = *p;
		p++;
		max--;
	}
	
	*d = 0;
}

wchar_t *es_wstring_alloc(const wchar_t *s)
{
	int size;
	wchar_t *p;
	
	size = (es_wstring_length(s) + 1) * sizeof(wchar_t);
	
	p = es_alloc(size);
	
	CopyMemory(p,s,size);
	
	return p;
}

void es_do_run_history_command(void)
{	
	es_everything_hwnd = es_find_ipc_window();
	if (es_everything_hwnd)
	{
		COPYDATASTRUCT cds;
		DWORD run_count;

		cds.cbData = es_run_history_size;
		cds.dwData = es_run_history_command;
		cds.lpData = es_run_history_data;
		
		run_count = (DWORD)SendMessage(es_everything_hwnd,WM_COPYDATA,0,(LPARAM)&cds);

		if (es_run_history_command == EVERYTHING_IPC_COPYDATA_GET_RUN_COUNTW)
		{
			es_write_DWORD(run_count);
		}
	}
	else
	{
		// the everything window was not found.
		// we can optionally RegisterWindowMessage("EVERYTHING_IPC_CREATED") and 
		// wait for Everything to post this message to all top level windows when its up and running.
		es_fatal(ES_ERROR_IPC);
	}
}

// checks for -sort-size, -sort-size-ascending and -sort-size-descending
int es_check_sorts(void)
{
	wchar_t sortnamebuf[ES_WSTRING_SIZE];
	int sortnamei;
	
	for(sortnamei=0;sortnamei<ES_SORT_NAME_COUNT;sortnamei++)
	{
		es_wstring_copy(sortnamebuf,L"sort-");
		es_wstring_cat(sortnamebuf,es_sort_names[sortnamei]);
		es_wstring_cat(sortnamebuf,L"-ascending");
		
		if (es_check_param(es_argv,sortnamebuf))
		{
			es_sort = es_sort_names_to_ids[sortnamei];
			es_sort_ascending = 1;

			return 1;
		}
		
		es_wstring_copy(sortnamebuf,L"sort-");
		es_wstring_cat(sortnamebuf,es_sort_names[sortnamei]);
		es_wstring_cat(sortnamebuf,L"-descending");
		
		if (es_check_param(es_argv,sortnamebuf))
		{
			es_sort = es_sort_names_to_ids[sortnamei];
			es_sort_ascending = -1;

			return 1;
		}
		
		es_wstring_copy(sortnamebuf,L"sort-");
		es_wstring_cat(sortnamebuf,es_sort_names[sortnamei]);
		
		if (es_check_param(es_argv,sortnamebuf))
		{
			es_sort = es_sort_names_to_ids[sortnamei];

			return 1;
		}
	}
	
	return 0;
}

static void *es_buf_init(es_buf_t *cbuf,uintptr_t size)
{
	if (size <= ES_BUF_SIZE)
	{
		cbuf->buf = cbuf->stackbuf;
	}
	else
	{
		cbuf->buf = es_alloc(size);
	}
	
	return cbuf->buf;
}

static void es_buf_kill(es_buf_t *cbuf)
{
	if (cbuf->buf != cbuf->stackbuf)
	{
		es_free(cbuf->buf);
	}
}

[vitnetdev]

This is my basic implementation of the Gui for this:

import tkinter as tk
import subprocess
import os
import pty
import threading
import keyboard

# Global variables to handle the pseudo-terminal
master_fd, slave_fd = pty.openpty()
process = None

def open_c_file():
    global process, master_fd, slave_fd

    # Path to the .c file
    file_path = 'your_file.c'

    # Launch the terminal and run the .c file
    try:
        process = subprocess.Popen(
            ['gcc', file_path, '-o', 'program.out', '&&', './program.out'],
            stdin=slave_fd, stdout=slave_fd, stderr=slave_fd, shell=True
        )
    except Exception as e:
        print(f"An error occurred while starting the terminal: {e}")

def send_to_terminal(user_input):
    global master_fd
    os.write(master_fd, (user_input + '\n').encode('utf-8'))

def read_from_terminal():
    global master_fd
    while process and process.poll() is None:
        output = os.read(master_fd, 1024).decode('utf-8')
        if output:
            # Update GUI with terminal output
            output_text.config(state=tk.NORMAL)
            output_text.insert(tk.END, output)
            output_text.config(state=tk.DISABLED)

def on_submit():
    user_input = input_entry.get()
    send_to_terminal(user_input)
    input_entry.delete(0, tk.END)

def background_gui():
    # Create a hidden Tkinter window
    global input_entry, output_text
    root = tk.Tk()
    root.title("Terminal GUI")
    
    # Create and pack widgets
    input_entry = tk.Entry(root, width=50)
    input_entry.pack(pady=10)
    
    submit_button = tk.Button(root, text="Send", command=on_submit)
    submit_button.pack(pady=10)
    
    output_text = tk.Text(root, wrap=tk.WORD, height=20, width=50, state=tk.DISABLED)
    output_text.pack(pady=10)
    
    # Start reading from terminal in a separate thread
    threading.Thread(target=read_from_terminal, daemon=True).start()
    
    # Hide the main window
    root.withdraw()
    
    # Run the application
    root.mainloop()

def setup_shortcut():
    # Register the shortcut Alt + Space
    keyboard.add_hotkey('alt+space', lambda: open_c_file())

if __name__ == "__main__":
    # Run the GUI in a background thread
    threading.Thread(target=background_gui, daemon=True).start()
    
    # Set up the shortcut listener
    setup_shortcut()
    
    # Keep the main thread alive to listen for the shortcut
    keyboard.wait('esc')  # Press 'Esc' to exit the program

[vitnetdev]

UPDATE: The basic GUI seems to not be working. It is still here so far but I will change it into a working one when finished