#include "types.h"
#include "common.h"
#include <FormControlW.h>
#include <FormControlA.h>

// int xlFormControlObjectType(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlObjectType(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int ret = xlFormControlObjectType(form_control_resource->handle);

	return enif_make_int(env, ret);
}

// int xlFormControlChecked(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlChecked(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int ret = xlFormControlChecked(form_control_resource->handle);

	return enif_make_int(env, ret);
}

// void xlFormControlSetChecked(FormControlHandle handle, int checked);
ERL_NIF_TERM c_xlFormControlSetChecked(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int checked;

	if (0 == enif_get_int(env, argv[1], &checked)) {
		return enif_make_badarg(env);
	}

	xlFormControlSetChecked(form_control_resource->handle, checked);

	return enif_make_atom(env, "nil");
}

// const wchar_t* xlFormControlFmlaGroup(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlFmlaGroup(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	const wchar_t *wstr = xlFormControlFmlaGroup(form_control_resource->handle);

	if(!wstr) {
		return enif_make_atom(env, "error");
	}

	ErlNifBinary ret = convertWcharToMbBinary(wstr);

	if(!ret.data) {
		return enif_make_atom(env, "error");
	}

	return enif_make_binary(env, &ret);
}

// void xlFormControlSetFmlaGroup(FormControlHandle handle, const wchar_t* group);
ERL_NIF_TERM c_xlFormControlSetFmlaGroup(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	ErlNifBinary group_temp;

	if(enif_inspect_binary(env, argv[1], &group_temp) < 1) {
		return enif_make_badarg(env);
	}

	unsigned char *pt1 = createNullTermMbString(group_temp);

	if(!pt1) {
		return enif_make_badarg(env);
	}

	size_t mbs_len1 = strlen((const char*)pt1);

	size_t character_count1 = mbstowcs(NULL, (const char*)pt1, mbs_len1);

	wchar_t w_group[character_count1 + 1];

	(void)memset(w_group, '\0', sizeof(w_group) / sizeof(w_group[0]));

	if((size_t)-1 == mbstowcs(w_group, (const char*)pt1, character_count1 + 1)) {
		free(pt1);

		return enif_make_badarg(env);
	}

	free(pt1);

	xlFormControlSetFmlaGroup(form_control_resource->handle, w_group);

	return enif_make_atom(env, "nil");
}

// const wchar_t* xlFormControlFmlaLink(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlFmlaLink(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	const wchar_t *wstr = xlFormControlFmlaLink(form_control_resource->handle);

	if(!wstr) {
		return enif_make_atom(env, "error");
	}

	ErlNifBinary ret = convertWcharToMbBinary(wstr);

	if(!ret.data) {
		return enif_make_atom(env, "error");
	}

	return enif_make_binary(env, &ret);
}

// void xlFormControlSetFmlaLink(FormControlHandle handle, const wchar_t* link);
ERL_NIF_TERM c_xlFormControlSetFmlaLink(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	ErlNifBinary link_temp;

	if(enif_inspect_binary(env, argv[1], &link_temp) < 1) {
		return enif_make_badarg(env);
	}

	unsigned char *pt1 = createNullTermMbString(link_temp);

	if(!pt1) {
		return enif_make_badarg(env);
	}

	size_t mbs_len1 = strlen((const char*)pt1);

	size_t character_count1 = mbstowcs(NULL, (const char*)pt1, mbs_len1);

	wchar_t w_link[character_count1 + 1];

	(void)memset(w_link, '\0', sizeof(w_link) / sizeof(w_link[0]));

	if((size_t)-1 == mbstowcs(w_link, (const char*)pt1, character_count1 + 1)) {
		free(pt1);

		return enif_make_badarg(env);
	}

	free(pt1);

	xlFormControlSetFmlaLink(form_control_resource->handle, w_link);

	return enif_make_atom(env, "nil");
}

// const wchar_t* xlFormControlFmlaRange(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlFmlaRange(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	const wchar_t *wstr = xlFormControlFmlaRange(form_control_resource->handle);

	if(!wstr) {
		return enif_make_atom(env, "error");
	}

	ErlNifBinary ret = convertWcharToMbBinary(wstr);

	if(!ret.data) {
		return enif_make_atom(env, "error");
	}

	return enif_make_binary(env, &ret);
}

// void xlFormControlSetFmlaRange(FormControlHandle handle, const wchar_t* range);
ERL_NIF_TERM c_xlFormControlSetFmlaRange(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	ErlNifBinary range_temp;

	if(enif_inspect_binary(env, argv[1], &range_temp) < 1) {
		return enif_make_badarg(env);
	}

	unsigned char *pt1 = createNullTermMbString(range_temp);

	if(!pt1) {
		return enif_make_badarg(env);
	}

	size_t mbs_len1 = strlen((const char*)pt1);

	size_t character_count1 = mbstowcs(NULL, (const char*)pt1, mbs_len1);

	wchar_t w_range[character_count1 + 1];

	(void)memset(w_range, '\0', sizeof(w_range) / sizeof(w_range[0]));

	if((size_t)-1 == mbstowcs(w_range, (const char*)pt1, character_count1 + 1)) {
		free(pt1);

		return enif_make_badarg(env);
	}

	free(pt1);

	xlFormControlSetFmlaRange(form_control_resource->handle, w_range);

	return enif_make_atom(env, "nil");
}

// const wchar_t* xlFormControlFmlaTxbx(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlFmlaTxbx(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	const wchar_t *wstr = xlFormControlFmlaTxbx(form_control_resource->handle);

	if(!wstr) {
		return enif_make_atom(env, "error");
	}

	ErlNifBinary ret = convertWcharToMbBinary(wstr);

	if(!ret.data) {
		return enif_make_atom(env, "error");
	}

	return enif_make_binary(env, &ret);
}

// void xlFormControlSetFmlaTxbx(FormControlHandle handle, const wchar_t* txbx);
ERL_NIF_TERM c_xlFormControlSetFmlaTxbx(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	ErlNifBinary txbx_temp;

	if(enif_inspect_binary(env, argv[1], &txbx_temp) < 1) {
		return enif_make_badarg(env);
	}

	unsigned char *pt1 = createNullTermMbString(txbx_temp);

	if(!pt1) {
		return enif_make_badarg(env);
	}

	size_t mbs_len1 = strlen((const char*)pt1);

	size_t character_count1 = mbstowcs(NULL, (const char*)pt1, mbs_len1);

	wchar_t w_txbx[character_count1 + 1];

	(void)memset(w_txbx, '\0', sizeof(w_txbx) / sizeof(w_txbx[0]));

	if((size_t)-1 == mbstowcs(w_txbx, (const char*)pt1, character_count1 + 1)) {
		free(pt1);

		return enif_make_badarg(env);
	}

	free(pt1);

	xlFormControlSetFmlaTxbx(form_control_resource->handle, w_txbx);

	return enif_make_atom(env, "nil");
}

// const wchar_t* xlFormControlName(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlName(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	const wchar_t *wstr = xlFormControlName(form_control_resource->handle);

	if(!wstr) {
		return enif_make_atom(env, "error");
	}

	ErlNifBinary ret = convertWcharToMbBinary(wstr);

	if(!ret.data) {
		return enif_make_atom(env, "error");
	}

	return enif_make_binary(env, &ret);
}

// const wchar_t* xlFormControlLinkedCell(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlLinkedCell(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	const wchar_t *wstr = xlFormControlLinkedCell(form_control_resource->handle);

	if(!wstr) {
		return enif_make_atom(env, "error");
	}

	ErlNifBinary ret = convertWcharToMbBinary(wstr);

	if(!ret.data) {
		return enif_make_atom(env, "error");
	}

	return enif_make_binary(env, &ret);
}

// const wchar_t* xlFormControlListFillRange(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlListFillRange(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	const wchar_t *wstr = xlFormControlListFillRange(form_control_resource->handle);

	if(!wstr) {
		return enif_make_atom(env, "error");
	}

	ErlNifBinary ret = convertWcharToMbBinary(wstr);

	if(!ret.data) {
		return enif_make_atom(env, "error");
	}

	return enif_make_binary(env, &ret);
}

// const wchar_t* xlFormControlMacro(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlMacro(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	const wchar_t *wstr = xlFormControlMacro(form_control_resource->handle);

	if(!wstr) {
		return enif_make_atom(env, "error");
	}

	ErlNifBinary ret = convertWcharToMbBinary(wstr);

	if(!ret.data) {
		return enif_make_atom(env, "error");
	}

	return enif_make_binary(env, &ret);
}

// const wchar_t* xlFormControlAltText(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlAltText(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	const wchar_t *wstr = xlFormControlAltText(form_control_resource->handle);

	if(!wstr) {
		return enif_make_atom(env, "error");
	}

	ErlNifBinary ret = convertWcharToMbBinary(wstr);

	if(!ret.data) {
		return enif_make_atom(env, "error");
	}

	return enif_make_binary(env, &ret);
}

// int xlFormControlLocked(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlLocked(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int ret = xlFormControlLocked(form_control_resource->handle);

	return enif_make_int(env, ret);
}

// int xlFormControlDefaultSize(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlDefaultSize(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int ret = xlFormControlDefaultSize(form_control_resource->handle);

	return enif_make_int(env, ret);
}

// int xlFormControlPrint(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlPrint(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int ret = xlFormControlPrint(form_control_resource->handle);

	return enif_make_int(env, ret);
}

// int xlFormControlDisabled(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlDisabled(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int ret = xlFormControlDisabled(form_control_resource->handle);

	return enif_make_int(env, ret);
}

// const wchar_t* xlFormControlItem(FormControlHandle handle, int index);
ERL_NIF_TERM c_xlFormControlItem(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int index;

	if (0 == enif_get_int(env, argv[1], &index)) {
		return enif_make_badarg(env);
	}

	const wchar_t *wstr = xlFormControlItem(form_control_resource->handle, index);

	if(!wstr) {
		return enif_make_atom(env, "error");
	}

	ErlNifBinary ret = convertWcharToMbBinary(wstr);

	if(!ret.data) {
		return enif_make_atom(env, "error");
	}

	return enif_make_binary(env, &ret);
}

// int xlFormControlItemSize(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlItemSize(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int ret = xlFormControlItemSize(form_control_resource->handle);

	return enif_make_int(env, ret);
}

// void xlFormControlAddItem(FormControlHandle handle, const wchar_t* value);
ERL_NIF_TERM c_xlFormControlAddItem(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	ErlNifBinary value_temp;

	if(enif_inspect_binary(env, argv[1], &value_temp) < 1) {
		return enif_make_badarg(env);
	}

	unsigned char *pt1 = createNullTermMbString(value_temp);

	if(!pt1) {
		return enif_make_badarg(env);
	}

	size_t mbs_len1 = strlen((const char*)pt1);

	size_t character_count1 = mbstowcs(NULL, (const char*)pt1, mbs_len1);

	wchar_t w_value[character_count1 + 1];

	(void)memset(w_value, '\0', sizeof(w_value) / sizeof(w_value[0]));

	if((size_t)-1 == mbstowcs(w_value, (const char*)pt1, character_count1 + 1)) {
		free(pt1);

		return enif_make_badarg(env);
	}

	free(pt1);

	xlFormControlAddItem(form_control_resource->handle, w_value);

	return enif_make_atom(env, "nil");
}

// void xlFormControlInsertItem(FormControlHandle handle, int index, const wchar_t* value);
ERL_NIF_TERM c_xlFormControlInsertItem(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int index;

	if (0 == enif_get_int(env, argv[1], &index)) {
		return enif_make_badarg(env);
	}

	ErlNifBinary value_temp;

	if(enif_inspect_binary(env, argv[2], &value_temp) < 1) {
		return enif_make_badarg(env);
	}

	unsigned char *pt1 = createNullTermMbString(value_temp);

	if(!pt1) {
		return enif_make_badarg(env);
	}

	size_t mbs_len1 = strlen((const char*)pt1);

	size_t character_count1 = mbstowcs(NULL, (const char*)pt1, mbs_len1);

	wchar_t w_value[character_count1 + 1];

	(void)memset(w_value, '\0', sizeof(w_value) / sizeof(w_value[0]));

	if((size_t)-1 == mbstowcs(w_value, (const char*)pt1, character_count1 + 1)) {
		free(pt1);

		return enif_make_badarg(env);
	}

	free(pt1);

	xlFormControlInsertItem(form_control_resource->handle, index, w_value);

	return enif_make_atom(env, "nil");
}

// void xlFormControlClearItems(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlClearItems(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	xlFormControlClearItems(form_control_resource->handle);

	return enif_make_atom(env, "nil");
}

// int xlFormControlDropLines(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlDropLines(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int ret = xlFormControlDropLines(form_control_resource->handle);

	return enif_make_int(env, ret);
}

// void xlFormControlSetDropLines(FormControlHandle handle, int lines);
ERL_NIF_TERM c_xlFormControlSetDropLines(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int lines;

	if (0 == enif_get_int(env, argv[1], &lines)) {
		return enif_make_badarg(env);
	}

	xlFormControlSetDropLines(form_control_resource->handle, lines);

	return enif_make_atom(env, "nil");
}

// int xlFormControlDx(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlDx(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int ret = xlFormControlDx(form_control_resource->handle);

	return enif_make_int(env, ret);
}

// void xlFormControlSetDx(FormControlHandle handle, int dx);
ERL_NIF_TERM c_xlFormControlSetDx(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int dx;

	if (0 == enif_get_int(env, argv[1], &dx)) {
		return enif_make_badarg(env);
	}

	xlFormControlSetDx(form_control_resource->handle, dx);

	return enif_make_atom(env, "nil");
}

// int xlFormControlFirstButton(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlFirstButton(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int ret = xlFormControlFirstButton(form_control_resource->handle);

	return enif_make_int(env, ret);
}

// void xlFormControlSetFirstButton(FormControlHandle handle, int firstButton);
ERL_NIF_TERM c_xlFormControlSetFirstButton(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int first_button;

	if (0 == enif_get_int(env, argv[1], &first_button)) {
		return enif_make_badarg(env);
	}

	xlFormControlSetFirstButton(form_control_resource->handle, first_button);

	return enif_make_atom(env, "nil");
}

// int xlFormControlHoriz(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlHoriz(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int ret = xlFormControlHoriz(form_control_resource->handle);

	return enif_make_int(env, ret);
}

// void xlFormControlSetHoriz(FormControlHandle handle, int horiz);
ERL_NIF_TERM c_xlFormControlSetHoriz(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int horiz;

	if (0 == enif_get_int(env, argv[1], &horiz)) {
		return enif_make_badarg(env);
	}

	xlFormControlSetHoriz(form_control_resource->handle, horiz);

	return enif_make_atom(env, "nil");
}

// int xlFormControlInc(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlInc(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int ret = xlFormControlInc(form_control_resource->handle);

	return enif_make_int(env, ret);
}

// void xlFormControlSetInc(FormControlHandle handle, int inc);
ERL_NIF_TERM c_xlFormControlSetInc(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int inc;

	if (0 == enif_get_int(env, argv[1], &inc)) {
		return enif_make_badarg(env);
	}

	xlFormControlSetInc(form_control_resource->handle, inc);

	return enif_make_atom(env, "nil");
}

// int xlFormControlGetMax(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlGetMax(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int ret = xlFormControlGetMax(form_control_resource->handle);

	return enif_make_int(env, ret);
}

// void xlFormControlSetMax(FormControlHandle handle, int max);
ERL_NIF_TERM c_xlFormControlSetMax(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int max;

	if (0 == enif_get_int(env, argv[1], &max)) {
		return enif_make_badarg(env);
	}

	xlFormControlSetMax(form_control_resource->handle, max);

	return enif_make_atom(env, "nil");
}

// int xlFormControlGetMin(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlGetMin(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int ret = xlFormControlGetMin(form_control_resource->handle);

	return enif_make_int(env, ret);
}

// void xlFormControlSetMin(FormControlHandle handle, int min);
ERL_NIF_TERM c_xlFormControlSetMin(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int min;

	if (0 == enif_get_int(env, argv[1], &min)) {
		return enif_make_badarg(env);
	}

	xlFormControlSetMin(form_control_resource->handle, min);

	return enif_make_atom(env, "nil");
}

// const wchar_t* xlFormControlMultiSel(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlMultiSel(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	const wchar_t *wstr = xlFormControlMultiSel(form_control_resource->handle);

	if(!wstr) {
		return enif_make_atom(env, "error");
	}

	ErlNifBinary ret = convertWcharToMbBinary(wstr);

	if(!ret.data) {
		return enif_make_atom(env, "error");
	}

	return enif_make_binary(env, &ret);
}

// void xlFormControlSetMultiSel(FormControlHandle handle, const wchar_t* value);
ERL_NIF_TERM c_xlFormControlSetMultiSel(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	ErlNifBinary value_temp;

	if(enif_inspect_binary(env, argv[1], &value_temp) < 1) {
		return enif_make_badarg(env);
	}

	unsigned char *pt1 = createNullTermMbString(value_temp);

	if(!pt1) {
		return enif_make_badarg(env);
	}

	size_t mbs_len1 = strlen((const char*)pt1);

	size_t character_count1 = mbstowcs(NULL, (const char*)pt1, mbs_len1);

	wchar_t w_value[character_count1 + 1];

	(void)memset(w_value, '\0', sizeof(w_value) / sizeof(w_value[0]));

	if((size_t)-1 == mbstowcs(w_value, (const char*)pt1, character_count1 + 1)) {
		free(pt1);

		return enif_make_badarg(env);
	}

	free(pt1);

	xlFormControlSetMultiSel(form_control_resource->handle, w_value);

	return enif_make_atom(env, "nil");
}

// int xlFormControlSel(FormControlHandle handle);
ERL_NIF_TERM c_xlFormControlSel(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int ret = xlFormControlSel(form_control_resource->handle);

	return enif_make_int(env, ret);
}

// void xlFormControlSetSel(FormControlHandle handle, int sel);
ERL_NIF_TERM c_xlFormControlSetSel(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int sel;

	if (0 == enif_get_int(env, argv[1], &sel)) {
		return enif_make_badarg(env);
	}

	xlFormControlSetSel(form_control_resource->handle, sel);

	return enif_make_atom(env, "nil");
}

// int xlFormControlFromAnchor(FormControlHandle handle, int* col, int* colOff, int* row, int* rowOff);
ERL_NIF_TERM c_xlFormControlFromAnchor(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int col;
	int colOff;
	int row;
	int rowOff;

	int ret = xlFormControlFromAnchor(form_control_resource->handle, &col, &colOff, &row, &rowOff);

	return enif_make_list5(env,
		enif_make_int(env, ret),
		enif_make_int(env, col),
		enif_make_int(env, colOff),
		enif_make_int(env, row),
		enif_make_int(env, rowOff)
	);
}

// int xlFormControlToAnchor(FormControlHandle handle, int* col, int* colOff, int* row, int* rowOff);
ERL_NIF_TERM c_xlFormControlToAnchor(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
	FormControlType *form_control_resource = NULL;

	if (0 == enif_get_resource(env, argv[0], TypeOfFormControl, (void**)&form_control_resource)) {
		return enif_make_badarg(env);
	}

	int col;
	int colOff;
	int row;
	int rowOff;

	int ret = xlFormControlToAnchor(form_control_resource->handle, &col, &colOff, &row, &rowOff);

	return enif_make_list5(env,
		enif_make_int(env, ret),
		enif_make_int(env, col),
		enif_make_int(env, colOff),
		enif_make_int(env, row),
		enif_make_int(env, rowOff)
	);
}