Проект внешней компоненты для 1С:8 (сделай сам)

/*Получение свойства*/
	virtual bool ADDIN_API GetPropVal(const long num, tVariant* var) override {
		switch(num) {
			case 0: //Свойство_int
				TV_VT(var) = VTYPE_I4; //выставляем тип
				TV_I4(var) = Prop0;    //выставляем значение
				break;
			case 1: //Свойство_double
				TV_VT(var) = VTYPE_R8;  //выставляем тип
				TV_R8(var) = Prop1;     //выставляем значение
				break;
			case 2: //Свойство_pchar
				TV_VT(var) = VTYPE_PSTR;  //выставляем тип
				var->pstrVal = Prop2;     //сразу указатель на строку
				var->strLen  = std::strlen(Prop2);
				break;
			case 3: //Свойство_bool
				TV_VT(var) = VTYPE_BOOL; //выставляем тип
				TV_BOOL(var) = Prop3;    //выставляем значение
				break;
			case 4: //Свойство_tm
				TV_VT(var) = VTYPE_TM; //выставляем тип
				var->tmVal = Prop4;    //выставляем значение
				break;
			default:
				return false;
		}
		return true;
	}
	/*Установка свойства*/
	virtual bool ADDIN_API SetPropVal(const long num, tVariant * var) override {
		switch(num) {
			case 0:
				if(TV_VT(var) != VTYPE_I4)
					return false;
				Prop0 = TV_I4(var);
				break;
			case 1:
				if(TV_VT(var) != VTYPE_R8)
					return false;
				Prop1 = TV_R8(var);
				break;
			case 2:
				if(TV_VT(var) == VTYPE_PSTR) { 
					delete[] Prop2;
					size_t len = std::strlen(var->pstrVal);
					Prop2 = new char[len + 1];
					std::strncpy(Prop2, var->pstrVal, len + 1);
					break;
				} else if(TV_VT(var) == VTYPE_PWSTR) {
					delete[] Prop2;
					WCHAR_to_char(Prop2, var->pwstrVal);
					break;
				} else
					return false;
			case 3:
				if(TV_VT(var) != VTYPE_BOOL)
					return false;
				Prop3 = TV_BOOL(var);
				break;
			case 4:
				if(TV_VT(var) != VTYPE_TM)
					return false;
				Prop4 = var->tmVal;
				break;
			default:
				return false;
		}
		return true;
	} 

/*Конвертация wchar_t* -> WCHAR_T* */
size_t wchar_to_WCHAR(WCHAR_T * &Dest, const wchar_t* Source, size_t len) {
	if(len == 0) {//если размер задан, то и место уже зарезервировано
		len = wchar_len(Source) + 1;
		Dest = new WCHAR_T[len];
	}
	memset(Dest, 0, len*sizeof(WCHAR_T));	
	for(size_t i = 0; i < len && Source[i]; ++i)
		Dest[i] = (WCHAR_T)Source[i];			

	return len;
}
/*Конвертация wchar_t* -> char* */
size_t wchar_to_char(char * &Dest, const wchar_t* Source, size_t len) {
	if(len == 0) {//если размер задан, то и место уже зарезервировано
		len = wchar_len(Source) + 1;
		Dest = new char[len];
	}
	len = wcstombs(Dest, Source, len);
	Dest[len - 1] = '\0';
	return len;
}
/*Конвертация WCHAR_T** -> wchar_t* */
size_t WCHAR_to_wchar(wchar_t * &Dest, const WCHAR_T* Source, size_t len) {
	if(len==0){//если размер задан, то и место уже зарезервировано
		len = WCHAR_len(Source) + 1;
		Dest = new wchar_t[len];
	}
	memset(Dest, 0, len*sizeof(wchar_t));
	for(size_t i = 0; i < len && Source[i]; ++i)
		Dest[i] = (wchar_t)Source[i];

	return len;
}
/*Конвертация WCHAR_T** -> char* */
size_t WCHAR_to_char(char * &Dest, const WCHAR_T* Source, size_t len) {
	wchar_t * temp;
	WCHAR_to_wchar(temp, Source);
	len=wchar_to_char(Dest, temp,len);
	delete[] temp;

	return len;
}
/*Вычисление длинны строки WCHAR_T* */
size_t WCHAR_len(const WCHAR_T* Source) {
	size_t res = 0;
	while(Source[res]) 	++res;

	return res;
}
/*Вычисление длинны строки wchar_t* */
size_t wchar_len(const wchar_t* Source) {
	size_t res = 0;
	while(Source[res]) 	++res;

	return res;
}

/*Список доступных типов (регистрируются в RegisterExtensionAs тем же именем)*/
static const wchar_t Class_Names[] = L"myClass"; //|OtherClass1|OtherClass2

/*ЭКСПОРТИРУЕМЫЕ МЕТОДЫ*/
/*Получение экземпляра по имени*/
long GetClassObject(const WCHAR_T* ex_name, Base** pInterface) {
	if(!*pInterface) {
		wchar_t * name = nullptr;
		WCHAR_to_wchar(name, ex_name);
		if(!wcscmp(name, L"myClass"))
			*pInterface = new myClass();
		delete[] name;
		return (long)*pInterface;
	}
	return 0;
}
/*Получение списка возможных типов*/
const WCHAR_T* GetClassNames() {
	static WCHAR_T* names;
	wchar_to_WCHAR(names, Class_Names);

	return names;
}

/***************************************************
*  Данный класс предназначен для наследования      *
****************************************************/
class Base:public IInitDoneBase, public ILanguageExtenderBase, public LocaleBase {
protected:
	/*вложенные типы (для "рефлексии типа из 1С")*/
	struct Prop {	
		wchar_t *ru, *en;
		bool    r,w;
		void Init(const wchar_t *ru, const wchar_t *en, bool r, bool w) {
			/*копируем имена свойств ru и en*/
			size_t len = wcslen(ru) + 1;
			this->ru = new wchar_t[len];
			memcpy(this->ru, ru, len*sizeof(wchar_t));
			len = wcslen(en) + 1;
			this->en = new wchar_t[len];
			memcpy(this->en, en, len*sizeof(wchar_t));
			/*копируем призначки чтения и записи*/
			this->r = r;
			this->w = w;
		}
		Prop(const wchar_t *ru, const wchar_t *en, bool r, bool w) {
			Init(ru, en, r, w);
		}
		Prop(const Prop & other) {
			Init(other.ru, other.en, other.r, other.w);
		}
		~Prop() {
			delete[] ru, en;
			ru = en = nullptr;
		}
	};
	struct Method {
		wchar_t *ru, *en;
		bool    is_proc;
		void Init(const wchar_t *ru, const wchar_t *en, bool is_proc) {
			/*копируем имена методов ru и en*/
			size_t len = wcslen(ru) + 1;
			this->ru = new wchar_t[len];
			memcpy(this->ru, ru, len*sizeof(wchar_t));
			len = wcslen(en) + 1;
			this->en = new wchar_t[len];
			memcpy(this->en, en, len*sizeof(wchar_t));
			/*копируем признак процедуры*/
			this->is_proc = is_proc;
		}
		Method(const wchar_t *ru, const wchar_t *en, bool is_proc) {
			Init(ru, en, is_proc);
		}
		Method(const Method & other) {
			Init(other.ru, other.en, other.is_proc);
		}
		~Method() {
			delete[] ru, en;
			ru = en = nullptr;
		}
	};
	
	/*адаптеры*/
	Adapter            * pAdapter;
	MemoryAdapter      * pMemoryAdapter;
	
	/*Локальное имя*/
	wchar_t * name;
	/*свойства, методы и классы*/
	long cnt_props;
	Prop ** Props;	
	long cnt_methods;
	Method ** Methods;
	/*заполнение свойств и методов*/
	void fill_name(const wchar_t * name);
	void fill_props(const Prop * Prors = nullptr, long cnt_props = 0);
	void fill_methods(const Method * Methods = nullptr, long cnt_methods = 0);
		
	virtual void addError(uint32_t wcode, const wchar_t* source, const wchar_t* descriptor, long code);

public:
	/*Деструктор*/
	virtual ~Base();
	/*Конструктор*/
	Base():cnt_props(0), Props(nullptr), cnt_methods(0), Methods(nullptr), pAdapter(nullptr), pMemoryAdapter(nullptr), name(nullptr) {}

	/*Инициализация и завершение*/
	virtual bool ADDIN_API Init(void*)                   override;
	virtual bool ADDIN_API setMemManager(void* mem)      override;
	virtual long ADDIN_API GetInfo()                     override;
	virtual void ADDIN_API Done()                        override;
	/*смена локализации*/
	virtual void ADDIN_API SetLocale(const WCHAR_T* loc) override;

	/*Расширение языка*/
	/*Регистрация расширения под конкретным именем*/
	virtual       bool     ADDIN_API RegisterExtensionAs(WCHAR_T**) override;

	virtual       long     ADDIN_API GetNProps() override  { return cnt_props; }
	virtual       long     ADDIN_API FindProp(const WCHAR_T* wsPropName) override;
	virtual const WCHAR_T* ADDIN_API GetPropName(long lPropNum, long lPropAlias) override;
	virtual       bool     ADDIN_API IsPropReadable(const long lPropNum) override;
	virtual       bool     ADDIN_API IsPropWritable(const long lPropNum) override;
	virtual       bool     ADDIN_API GetPropVal(const long num, tVariant* var) override { return false; } //заглушка на случай отсутствия свойств
	virtual       bool     ADDIN_API SetPropVal(const long num, tVariant* val) override { return false; } //заглушка на случай отсутствия свойств
	
	virtual       long     ADDIN_API GetNMethods() override  { return cnt_methods; }
	virtual       long     ADDIN_API FindMethod(const WCHAR_T* wsMethodName) override;
	virtual const WCHAR_T* ADDIN_API GetMethodName(const long lMethodNum, const long lMethodAlias) override;
	virtual       long     ADDIN_API GetNParams(const long lMethodNum) override { return 0; }                                                                        //заглушка на случай отсутствия методов
	virtual       bool     ADDIN_API GetParamDefValue(const long lMethodNum, const long lParamNum, tVariant *pvarParamDefValue) override  { return false; }          //заглушка на случай отсутствия методов
	virtual       bool     ADDIN_API HasRetVal(const long lMethodNum) override;	
	virtual       bool     ADDIN_API CallAsProc(const long lMethodNum, tVariant* paParams, const long lSizeArray) override { return false; };                        //заглушка на случай отсутствия методов
	virtual       bool     ADDIN_API CallAsFunc(const long lMethodNum, tVariant* pvarRetValue, tVariant* paParams, const long lSizeArray) override { return false; } //заглушка на случай отсутствия методов
};

#include "base.h"
#include <ctime>

#ifndef CLASS_H
#define CLASS_H

class myClass: public Base {
private:
	int     Prop0 = -113; 
	double  Prop1 = 7.65;
	char  * Prop2 = nullptr;
	bool    Prop3 = true;
	tm      Prop4;
public:
	/*конструктор*/
	myClass() {
		/*объявляем имя класса доступное из 1С*/
		Base::fill_name(L"myClass");

		/*объявляем свойства доступные из 1С*/
		Base::Prop Props[] = {
			{L"Свойство_int"   , L"Prorp0", true, true},
		    {L"Свойство_double", L"Prorp1", true, true},
			{L"Свойство_pchar" , L"Prorp2", true, true},
			{L"Свойство_bool"  , L"Prorp3", true, true},
			{L"Свойство_tm"    , L"Prorp4", true, true}
		};
		Base::fill_props(Props, sizeof(Props) / sizeof(Base::Prop));

		/*объявляем методы доступные из 1С*/
		Base::Method Methods[] = {
			{L"Функция1", L"Func1", false},
		    {L"Функция2", L"Func2", false},
		    {L"Процедура1", L"Proc1", true}
		};
		Base::fill_methods(Methods, sizeof(Methods) / sizeof(Base::Method));

		Prop2 = new char[100];
		std::strcpy(Prop2, "abc абС 123");

		time_t rawtime;
		time(&rawtime);
		Prop4 = *localtime(&rawtime);		
	}
	~myClass() { 
		delete[] Prop2; 		
	}
	
	/*Получение свойства*/
	virtual bool ADDIN_API GetPropVal(const long num, tVariant* var) override {
		switch(num) {
			case 0: //Свойство_int
				TV_VT(var) = VTYPE_I4; //выставляем тип
				TV_I4(var) = Prop0;    //выставляем значение
				break;
			case 1: //Свойство_double
				TV_VT(var) = VTYPE_R8;  //выставляем тип
				TV_R8(var) = Prop1;     //выставляем значение
				break;
			case 2: //Свойство_pchar
				TV_VT(var) = VTYPE_PSTR;  //выставляем тип
				var->pstrVal = Prop2;     //сразу указатель на строку
				var->strLen  = std::strlen(Prop2);
				break;
			case 3: //Свойство_bool
				TV_VT(var) = VTYPE_BOOL; //выставляем тип
				TV_BOOL(var) = Prop3;    //выставляем значение
				break;
			case 4: //Свойство_tm
				TV_VT(var) = VTYPE_TM; //выставляем тип
				var->tmVal = Prop4;    //выставляем значение
				break;
			default:
				return false;
		}
		return true;
	}
	/*Установка свойства*/
	virtual bool ADDIN_API SetPropVal(const long num, tVariant * var) override {
		switch(num) {
			case 0:
				if(TV_VT(var) != VTYPE_I4)
					return false;
				Prop0 = TV_I4(var);
				break;
			case 1:
				if(TV_VT(var) != VTYPE_R8)
					return false;
				Prop1 = TV_R8(var);
				break;
			case 2:
				if(TV_VT(var) == VTYPE_PSTR) { 
					delete[] Prop2;
					size_t len = std::strlen(var->pstrVal);
					Prop2 = new char[len + 1];
					std::strncpy(Prop2, var->pstrVal, len + 1);
					break;
				} else if(TV_VT(var) == VTYPE_PWSTR) {
					delete[] Prop2;
					WCHAR_to_char(Prop2, var->pwstrVal);
					break;
				} else
					return false;
			case 3:
				if(TV_VT(var) != VTYPE_BOOL)
					return false;
				Prop3 = TV_BOOL(var);
				break;
			case 4:
				if(TV_VT(var) != VTYPE_TM)
					return false;
				Prop4 = var->tmVal;
				break;
			default:
				return false;
		}
		return true;
	}

};

#endif

#include "base.h"
#include <wchar.h>
#include <iostream>
#include <string>



/*Реализация базового абстрактного класса*/
void Base::fill_name(const wchar_t * name) {
	/*копируем имя*/
	size_t len = wcslen(name) + 1;
	this->name = new wchar_t[len];
	memcpy(this->name, name, len*sizeof(wchar_t));
}
void Base::fill_props(const Prop * Props, long cnt_props) {
	/*заполним возможные свойства, если они есть*/
	if(cnt_props) {
		this->cnt_props = cnt_props;
		this->Props     = new Prop*[cnt_props];
		for(long i = 0; i < cnt_props; ++i)
			this->Props[i] = new Prop(Props[i]);
	}
}
void Base::fill_methods(const Method * Methods, long cnt_methods) {
	/*заполним возможные методы, если они есть*/
	if(cnt_methods) {
		this->cnt_methods = cnt_methods;
		this->Methods = new Method*[cnt_methods];
		for(long i = 0; i < cnt_methods; ++i)
			this->Methods[i] = new Method(Methods[i]);
	}
}

Base::~Base() {
	/*освобождаем массивы имен свойств*/
	for(long i = 0; i < cnt_props; ++i)
		delete Props[i];
	delete[] Props;
	Props = nullptr;
	cnt_props = 0;

	/*освобождаем массивы имен методов*/
	for(long i = 0; i < cnt_methods; ++i)
		delete Methods[i];
	delete[] Methods;
	Methods = nullptr;
	cnt_methods = 0;

	delete[] name;
}


bool Base::Init(void* pConnection) {
	pAdapter = (Adapter*)pConnection;
	return pAdapter != nullptr;
}
bool Base::setMemManager(void* mem) {
	pMemoryAdapter = (MemoryAdapter*)mem;
	return pMemoryAdapter != 0;
}
long Base::GetInfo() {
	/*Компонента должна сообщить свою версию*/
	return 2000;
}
void Base::Done() {}

void Base::SetLocale(const WCHAR_T* loc) {
	#ifndef __linux__
		_wsetlocale(LC_ALL, loc);
	#else
		//We convert in char* char_locale
		//also we establish locale
		//setlocale(LC_ALL, char_locale);
	#endif
}

bool Base::RegisterExtensionAs(WCHAR_T** ext_name) {
	if(pMemoryAdapter!=nullptr) {
		int len = wcslen(name) + 1;
		if(pMemoryAdapter->AllocMemory((void**)ext_name, len * sizeof(WCHAR_T)))
			wchar_to_WCHAR(*ext_name, name, len);
		return true;
	}else
		return false;
}

/*"Рефлексия" из 1С*/
long Base::FindProp(const WCHAR_T* ex_name) {
	long res = -1;
	wchar_t * temp = nullptr;
	WCHAR_to_wchar(temp, ex_name);
		
	for(long i = 0; res == -1 && i < cnt_props; ++i)
		if(!wcscmp(Props[i]->en, temp) || !wcscmp(Props[i]->ru, temp))
			res = i;
	
	delete[] temp;

	return res;
}
bool Base::IsPropReadable(const long num) {
	if(num < cnt_props)
		return Props[num]->r;
	else
		return false;
}
bool Base::IsPropWritable(const long num) {
	if(num < cnt_props)
		return Props[num]->w;
	else
		return false;
}
const WCHAR_T* Base::GetPropName(long num, long cur_locale) {
	if(num < cnt_props) {
		wchar_t * temp;
		if(cur_locale == 0)
			temp=Props[num]->en;
		else 
			temp = Props[num]->ru;		
		
		WCHAR_T * res_name = NULL;
		int len = wcslen(temp) + 1;
		
		if(pMemoryAdapter 
		   && temp
		   && pMemoryAdapter->AllocMemory((void**)&res_name, len*sizeof(WCHAR_T)))
				wchar_to_WCHAR(res_name, temp, len);
		
		return res_name;
	} else
		return nullptr;
}
long Base::FindMethod(const WCHAR_T* ex_name) {
	long res = -1;
	wchar_t * temp = nullptr;
	WCHAR_to_wchar(temp, ex_name);

	for(long i = 0; res == -1 && i < cnt_methods; ++i)
		if(!wcscmp(Methods[i]->en, temp) || !wcscmp(Methods[i]->ru, temp))
			res = i;

	delete[] temp;

	return res;
}
bool Base::HasRetVal(const long num) {
	if(num < cnt_methods)
		return Methods[num]->is_proc == false;
	else
		return false;
}
const WCHAR_T* Base::GetMethodName(const long num, const long cur_locale) {
	if(num < cnt_methods) {
		wchar_t * temp;
		if(cur_locale == 0)
			temp = Methods[num]->en;
		else
			temp = Methods[num]->ru;

		WCHAR_T * res_name = NULL;
		int len = wcslen(temp) + 1;

		if(pMemoryAdapter
		   && temp
		   && pMemoryAdapter->AllocMemory((void**)&res_name, len*sizeof(WCHAR_T)))
		   wchar_to_WCHAR(res_name, temp, len);

		return res_name;
	} else
		return nullptr;
}
long Base::GetNParams(const long num) {
	if(num < cnt_methods)
		return Methods[num]->cnt;
	else
		return 0;
}

void Base::addError(uint32_t wcode, const wchar_t* source, const wchar_t* descriptor, long code) {
	if(pAdapter) {
		WCHAR_T *err   = nullptr;
		WCHAR_T *descr = nullptr;

		wchar_to_WCHAR(err, source);
		wchar_to_WCHAR(descr, descriptor);

		pAdapter->AddError(wcode, err, descr, code);
		delete[] err, descr;
	}
}

bool Base::CallAsProc(const long num, tVariant* paParams, const long lSizeArray) { 
	if(num < cnt_methods && Methods[num]->proc != nullptr) {		
		return Methods[num]->proc(paParams, lSizeArray);		
	} else
		return false; 
}

bool Base::CallAsFunc(const long num, tVariant* pvarRetValue, tVariant* paParams, const long lSizeArray) {
	if(num < cnt_methods && Methods[num]->func != nullptr) {
		return Methods[num]->func(pvarRetValue, paParams, lSizeArray);
	} else
		return false;
}

#include "base.h"
#include <ctime>

#ifndef CLASS_H
#define CLASS_H

class myClass: public Base {
private:
	int     Prop0 = -113; 
	double  Prop1 = 7.65;
	char  * Prop2 = nullptr;
	bool    Prop3 = true;
	tm      Prop4;
public:
	/*конструктор*/
	myClass() {
		/*объявляем имя класса доступное из 1С*/
		Base::fill_name(L"myClass");

		/*объявляем свойства доступные из 1С*/
		Base::Prop Props[] = {
			{L"Свойство_int"   , L"Prorp0", true, true},
		    {L"Свойство_double", L"Prorp1", true, true},
			{L"Свойство_pchar" , L"Prorp2", true, true},
			{L"Свойство_bool"  , L"Prorp3", true, true},
			{L"Свойство_tm"    , L"Prorp4", true, true}
		};
		Base::fill_props(Props, sizeof(Props) / sizeof(Base::Prop));

		/*объявляем методы доступные из 1С*/
		Base::Method Methods[] = {
			{L"Функция1", L"Func1", nullptr, nullptr, 1},
			{L"Функция2", L"Func2en", (void*)&std::bind(&myClass::Func2, this, _1, _2), nullptr, 2},
			{L"Процедура1", L"Proc1en", nullptr, (void*)&std::bind(&myClass::Proc1, this, _1, _2), 1, true}
		};		
		Base::fill_methods(Methods, sizeof(Methods) / sizeof(Base::Method));
		
		Prop2 = new char[100];
		std::strcpy(Prop2, "abc абС 123");

		time_t rawtime;
		time(&rawtime);
		Prop4 = *localtime(&rawtime);		
	}
	~myClass() { 
		delete[] Prop2; 		
	}
	
	/*Получение свойства*/
	virtual bool ADDIN_API GetPropVal(const long num, tVariant* var) override {
		switch(num) {
			case 0: //Свойство_int
				TV_VT(var) = VTYPE_I4; //выставляем тип
				TV_I4(var) = Prop0;    //выставляем значение
				break;
			case 1: //Свойство_double
				TV_VT(var) = VTYPE_R8;  //выставляем тип
				TV_R8(var) = Prop1;     //выставляем значение
				break;
			case 2: //Свойство_pchar
				TV_VT(var) = VTYPE_PSTR;  //выставляем тип
				var->pstrVal = Prop2;     //сразу указатель на строку
				var->strLen  = std::strlen(Prop2);
				break;
			case 3: //Свойство_bool
				TV_VT(var) = VTYPE_BOOL; //выставляем тип
				TV_BOOL(var) = Prop3;    //выставляем значение
				break;
			case 4: //Свойство_tm
				TV_VT(var) = VTYPE_TM; //выставляем тип
				var->tmVal = Prop4;    //выставляем значение
				break;
			default:
				return false;
		}
		return true;
	}
	/*Установка свойства*/
	virtual bool ADDIN_API SetPropVal(const long num, tVariant * var) override {
		switch(num) {
			case 0:
				if(TV_VT(var) != VTYPE_I4)
					return false;
				Prop0 = TV_I4(var);
				break;
			case 1:
				if(TV_VT(var) != VTYPE_R8)
					return false;
				Prop1 = TV_R8(var);
				break;
			case 2:
				if(TV_VT(var) == VTYPE_PSTR) { 
					delete[] Prop2;
					size_t len = std::strlen(var->pstrVal);
					Prop2 = new char[len + 1];
					std::strncpy(Prop2, var->pstrVal, len + 1);
					break;
				} else if(TV_VT(var) == VTYPE_PWSTR) {
					delete[] Prop2;
					WCHAR_to_char(Prop2, var->pwstrVal);
					break;
				} else
					return false;
			case 3:
				if(TV_VT(var) != VTYPE_BOOL)
					return false;
				Prop3 = TV_BOOL(var);
				break;
			case 4:
				if(TV_VT(var) != VTYPE_TM)
					return false;
				Prop4 = var->tmVal;
				break;
			default:
				return false;
		}
		return true;
	}
	/*Методы*/
	bool Proc1(tVariant* paParams, const long lSizeArray) {
		return true; 
	}
	bool Func2(tVariant* pvarRetValue, tVariant* paParams, const long lSizeArray) {
		return true;
	}
};

#endif

		if(!m_pDlg)
			{
				m_pDlg = new CMainDlg();
				m_pDlg->Create(IDD_DIALOG2);
			}

size_t wchar_to_char(char * &Dest, const wchar_t* Source, size_t len) {
	/*if(len == 0) {//если размер задан, то и место уже зарезервировано
		len = wchar_len(Source) +1;
		Dest = new char[len];
	}
	wcstombs(Dest, Source, len);
	Dest[len - 1] = '\0';*/
	
	if(len == 0) {
		len = WideCharToMultiByte(
			1251,   // Code page
			0,      // Default replacement of illegal chars
			Source, // Multibyte characters string
			-1,     // Number of unicode chars is not known
			NULL,   // No buffer yet, allocate it later
			0,      // No buffer
			NULL,   // Use system default
			NULL    // We are not interested whether the default char was used
			);
		if(len == 0)
			return 0;
		else
			Dest = new char[len]; 
	}

	len = WideCharToMultiByte(
		1251,    // Code page
		0,       // Default replacement of illegal chars
		Source,  // Multibyte characters string
		-1,      // Number of unicode chars is not known
		Dest,    // Output buffer
		len,     // buffer size
		NULL,    // Use system default
		NULL     // We are not interested whether the default char was used
		);

	if(len == 0) {
		delete[] Dest;
		return 0;
	}

	return len;
}

	Объект_=РеквизитФормыВЗначение("Объект");			
			адрес = ПоместитьВоВременноеХранилище(Объект_.ПолучитьМакет("SuperI"));
			res=ПодключитьВнешнююКомпоненту(адрес,"VK",ТипВнешнейКомпоненты.Native);			
			obj = Новый("AddIn.VK.myClass");

&НаСервере
Функция GetInf()
	Перем стРезультат;
	
	oSQL=Объект.Код;
	бРезультат=ВыполнитьSQL(oSQL,"select 1 as [q]");
	Если бРезультат тогда 		
		Объект_ = РеквизитФормыВЗначение("Объект");
		стРезультат=Новый Структура("Адрес,Сервер,База,Пользователь,Пароль",
									ПоместитьВоВременноеХранилище(Объект_.ПолучитьМакет("Макет_v2"),Новый УникальныйИдентификатор),
		                            oSQL.Server,
									oSQL.Base,									
									"***","***");		
	КонецЕсли;
	
	Возврат стРезультат;
КонецФункции	

&НаКлиенте
Процедура xmlНачалоВыбора(Элемент, ДанныеВыбора, СтандартнаяОбработка)
	Перем Criterion;
	
	СтандартнаяОбработка=Ложь;
	стРезультат=GetInf();
	Если стРезультат<>Неопределено тогда 
		Попытка 
			res=ПодключитьВнешнююКомпоненту(стРезультат.Адрес, "VK", ТипВнешнейКомпоненты.Native);					
			Criterion = Новый("AddIn.VK.Criterion");			
		Исключение
			УстановитьВнешнююКомпоненту(стРезультат.Адрес);
			res=ПодключитьВнешнююКомпоненту(стРезультат.Адрес, "VK", ТипВнешнейКомпоненты.Native);					
			Criterion = Новый("AddIn.VK.Criterion");		
		КонецПопытки;
		УдалитьИзВременногоХранилища(стРезультат.Адрес);
		
		Criterion.Сервер=стРезультат.Сервер;
		Criterion.База  =стРезультат.База;
		Criterion.КритерийОтбора ="";
		Criterion.ПользовательSQL=стРезультат.Пользователь;
		Criterion.ПарольSQL      =стРезультат.Пароль;
		Объект.xml=Criterion.ПолучитьXMLфайл();
	КонецЕсли;
КонецПроцедуры