// Выполняет текст алгоритма.
//
// Параметры:
//  ТекстДляВыполнения – Строка;
//  _АлгоритмОбъект - СправочникОбъект
//  *СтруктураПараметров - Структура, *Неопределено.
//
Функция ВыполнитьАлгоритм(_ТекстДляВыполнения, _АлгоритмОбъект = Null, _Режим  = Null,
	_П0 = Null, _П1 = Null, _П2 = Null, _П3 = Null, _П4 = Null, _П5 = Null, _П6 = Null, _П7 = Null, _П8 = Null, _П9 = Null) Экспорт 
	
	Перем Результат;
	Выполнить(_ТекстДляВыполнения);
	Возврат Результат;
	
КонецФункции

Процедура ВыполнитьАлгоритмБезРезультата(_ТекстДляВыполнения) Экспорт 
	
	Выполнить(_ТекстДляВыполнения);
	
КонецПроцедуры

Функция ВычислитьВыражение(Выражение, лПараметры = Неопределено) Экспорт
	
	Возврат Вычислить(Выражение);
	
КонецФункции

Функция ПолучитьПриглашениеОткрытьОтладчикЛкс() Экспорт
	
	Возврат "Нажмите кнопку ""Подробно"", а затем ""Конфигуратор"", чтобы начать отладку!";
	
КонецФункции

Процедура ОткрытьОтладчикЛкс() Экспорт
	
	ВызватьИсключение ПолучитьПриглашениеОткрытьОтладчикЛкс();
	
КонецПроцедуры

#Если Не ТонкийКлиент И Не ВебКлиент Тогда

Функция ПолучитьПостроительТабличногоПоляСОтборомКлиентаЛкс(ТабличноеПоле) Экспорт

	ВременнныйПостроительЗапроса = Новый ПостроительЗапроса;
	ВременнныйПостроительЗапроса.ИсточникДанных = Новый ОписаниеИсточникаДанных(ТабличноеПоле.Значение);
	ЛксСкопироватьОтбор(ВременнныйПостроительЗапроса.Отбор, ТабличноеПоле.ОтборСтрок, Истина);
	Возврат ВременнныйПостроительЗапроса;

КонецФункции

Функция ПолучитьСтруктуруВыделенияТекстаЛкс() Экспорт
	
	Структура = Новый Структура();
	Структура.Вставить("НачальнаяСтрока");
	Структура.Вставить("НачальнаяКолонка");
	Структура.Вставить("КонечнаяСтрока");
	Структура.Вставить("КонечнаяКолонка");
	Возврат Структура;
		
КонецФункции

Функция ПолеТекста_ПолучитьДиапазонВыделенияЛкс(ПолеТекста) Экспорт
	
	СтруктуруВыделения = ПолучитьСтруктуруВыделенияТекстаЛкс();
	ПолеТекста.ПолучитьГраницыВыделения(СтруктуруВыделения.НачальнаяСтрока, СтруктуруВыделения.НачальнаяКолонка,
		СтруктуруВыделения.КонечнаяСтрока, СтруктуруВыделения.КонечнаяКолонка);
	Возврат СтруктуруВыделения;
	
КонецФункции

Функция ПолеТекста_УстановитьДиапазонВыделенияЛкс(Знач ПолеТекста, Знач СтруктуруВыделения) Экспорт
	
	ПолеТекста.УстановитьГраницыВыделения(СтруктуруВыделения.НачальнаяСтрока, СтруктуруВыделения.НачальнаяКолонка,
		СтруктуруВыделения.КонечнаяСтрока, СтруктуруВыделения.КонечнаяКолонка);
	Возврат Неопределено;
	
КонецФункции


// Копирует таблицу значений из исходной таблицы значений с удалением типа Null из описаний типов колонок.
// Параметры:
//  ОбработатьТолькоКолонки - Строка - имена колонок разделенные запятыми
//  НеОбрабатыватьКолонки - Строка - имена колонок разделенные запятыми
//
// Возвращаемое значение:
//  ТаблицаЗначений
//
Функция ПолучитьТаблицуСКолонкамиБезТипаNullЛкс(Знач Таблица, ЗагружатьДанныеВНовуюТаблицу = Истина, ОбрабатыватьТолькоКолонки = "", НеОбрабатыватьКолонки = "") Экспорт
	
	Результат = Новый ТаблицаЗначений;
	НовыеКолонки = Результат.Колонки;
	ИсходныеКолонки = Таблица.Колонки;
	ИменаОбрабатываемыхКолонок = Новый Массив();
	Если ОбрабатыватьТолькоКолонки <> "" Тогда
		ИменаОбрабатываемыхКолонок = ЛксПолучитьМассивИзСтрокиСРазделителем(ОбрабатыватьТолькоКолонки, ",", Истина);
	КонецЕсли; 
	ИменаНеобрабатываемыхКолонок = Новый Массив();
	Если НеОбрабатыватьКолонки <> "" Тогда
		ИменаНеобрабатываемыхКолонок = ЛксПолучитьМассивИзСтрокиСРазделителем(НеОбрабатыватьКолонки, ",", Истина);
	КонецЕсли; 
	Для Каждого Колонка Из ИсходныеКолонки Цикл
		Если Ложь
			Или (Истина
				И ОбрабатыватьТолькоКолонки <> "" 
				И ИменаОбрабатываемыхКолонок.Найти(Колонка.Имя) = Неопределено)
			Или (Истина
				И НеОбрабатыватьКолонки <> "" 
				И ИменаНеобрабатываемыхКолонок.Найти(Колонка.Имя) <> Неопределено)
		Тогда
			ОписаниеТипов = Колонка.ТипЗначения;
		Иначе
			ОписаниеТипов = Новый ОписаниеТипов(Колонка.ТипЗначения, , "NULL");
		КонецЕсли; 
		НовыеКолонки.Добавить(Колонка.Имя, ОписаниеТипов, Колонка.Заголовок, Колонка.Ширина);
	КонецЦикла;
	Если ЗагружатьДанныеВНовуюТаблицу Тогда
		ЛксЗагрузитьВТаблицуЗначений(Таблица, Результат);
	КонецЕсли; 
	Возврат Результат;
	
КонецФункции

Функция ЛиСсылочныйОбъектМетаданных(ОбъектМД) Экспорт
	
	Если ТипЗнч(Метаданные) <> Тип("Строка") Тогда
		ПолноеИмя = ОбъектМД.ПолноеИмя();
	Иначе
		ПолноеИмя = ОбъектМД;
	КонецЕсли; 
	МассивФрагментов = ЛксПолучитьМассивИзСтрокиСРазделителем(ПолноеИмя);
	КорневойТип = МассивФрагментов[0];
	Если ЛксЛиКорневойТипОбъектаБД(КорневойТип) Тогда
		Возврат Истина;
	ИначеЕсли Истина
		И МассивФрагментов.Количество() = 4 
		И КорневойТип = "ВнешнийИсточникДанных" 
	Тогда
		Возврат (ОбъектМД.ТипДанныхТаблицы = Метаданные.СвойстваОбъектов.ТипДанныхТаблицыВнешнегоИсточникаДанных.ОбъектныеДанные);
	Иначе
		Возврат Ложь;
	КонецЕсли; 
		
КонецФункции

Функция ЛиРегистровыйОбъектМетаданных(ОбъектМД) Экспорт
	
	Если ТипЗнч(Метаданные) <> Тип("Строка") Тогда
		ПолноеИмя = ОбъектМД.ПолноеИмя();
	Иначе
		ПолноеИмя = ОбъектМД;
	КонецЕсли; 
	МассивФрагментов = ЛксПолучитьМассивИзСтрокиСРазделителем(ПолноеИмя);
	КорневойТип = МассивФрагментов[0];
	Если ЛксЛиКорневойТипРегистраБД(КорневойТип) Тогда
		Возврат Истина;
	ИначеЕсли Истина
		И МассивФрагментов.Количество() = 4 
		И КорневойТип = "ВнешнийИсточникДанных" 
	Тогда
		Возврат (ОбъектМД.ТипДанныхТаблицы = Метаданные.СвойстваОбъектов.ТипДанныхТаблицыВнешнегоИсточникаДанных.НеобъектныеДанные);
	Иначе
		Возврат Ложь;
	КонецЕсли; 
		
КонецФункции

Функция ЛиТипВнешнегоИсточникаДанных(Метаданные) Экспорт
	
	Если ТипЗнч(Метаданные) <> Тип("Строка") Тогда
		ПолноеИмя = Метаданные.ПолноеИмя();
	Иначе
		ПолноеИмя = Метаданные;
	КонецЕсли; 
	КорневойТип = ЛксПолучитьПервыйФрагмент(ПолноеИмя);
	Возврат КорневойТип = "ВнешнийИсточникДанных"; 
		
КонецФункции

Функция ПолучитьИмяТипаИзМетаданныхЛкс(ОбъектМД, Расширение = "Ссылка") Экспорт 

	Если ТипЗнч(ОбъектМД) <> Тип("Строка") Тогда
		ПолноеИмя = ОбъектМД.ПолноеИмя();
	Иначе
		ПолноеИмя = ОбъектМД;
	КонецЕсли; 
	Фрагменты = ЛксПолучитьМассивИзСтрокиСРазделителем(ПолноеИмя);
	Если Фрагменты.Количество() = 4 Тогда
		СтрокаТипа = Фрагменты[0] + Фрагменты[2] + Расширение + "." + Фрагменты[1] + "." + Фрагменты[3];
	Иначе
		СтрокаТипа = Фрагменты[0] + Расширение + "." + Фрагменты[1];
	КонецЕсли; 
	Возврат СтрокаТипа;

КонецФункции // ПолучитьИмяТипаИзМетаданныхЛкс()

Функция ПолучитьИмяТаблицыИзМетаданныхЛкс(Знач ОбъектМД, ЛиТаблицаИзменений = Ложь, ЛиДвиженияССубконтоДляРегистраБухгалтерии = Истина,
	ТолькоРазрешенные = Истина) Экспорт 

	Если ТипЗнч(ОбъектМД) <> Тип("Строка") Тогда
		ПолноеИмя = ОбъектМД.ПолноеИмя();
	Иначе
		ПолноеИмя = ОбъектМД;
	КонецЕсли;
	Фрагменты = ЛксПолучитьМассивИзСтрокиСРазделителем(ПолноеИмя);
	Если ТипЗнч(ОбъектМД) = Тип("Строка") Тогда
		Если Фрагменты.Количество() > 1 Тогда
			ОбъектМД = Метаданные.НайтиПоПолномуИмени(Фрагменты[0] + "." + Фрагменты[1]);
		Иначе
			//ОбъектМД = Метаданные[Фрагменты[0]];
			ОбъектМД = Неопределено;
		КонецЕсли; 
	КонецЕсли;
	Если Истина
		И ТолькоРазрешенные
		И ОбъектМД <> Неопределено
		И Не ПравоДоступа("Чтение", ОбъектМД)
	Тогда
		Возврат Неопределено;
	КонецЕсли;
	Если Истина
		И Фрагменты[0] = "Константа" 
		И Фрагменты.Количество() = 2
		И Не ЛиТаблицаИзменений
	Тогда
		Если Ложь
			Или ирКэш.Получить().ВерсияПлатформы <= 802013
			Или Метаданные.РежимСовместимости = Метаданные.СвойстваОбъектов.РежимСовместимости.Версия8_1
			Или (Истина
				И ирКэш.Получить().ВерсияПлатформы > 802013
				И Метаданные.РежимСовместимости = Метаданные.СвойстваОбъектов.РежимСовместимости.Версия8_2_13)
		Тогда
			Фрагменты = ЛксПолучитьМассивИзСтрокиСРазделителем("Константы");
		КонецЕсли; 
	КонецЕсли; 
	Если Фрагменты.Количество() = 4 Тогда
		Если СтрокиРавныЛкс(Фрагменты[2], "ТабличнаяЧасть") Тогда
			Фрагменты.Удалить(2);
		КонецЕсли; 
	КонецЕсли; 
	ИмяТаблицы = ЛксПолучитьСтрокуСРазделителемИзМассива(Фрагменты, ".");
	Если Истина
		И ЛиПолноеИмяРегистраБухгалтерииЛкс(ПолноеИмя)
		И Не ЛиТаблицаИзменений
		И ЛиДвиженияССубконтоДляРегистраБухгалтерии
	Тогда
		//ИмяТаблицы = ИмяТаблицы + ".ДвиженияССубконто";
		ИмяТаблицы = ИмяТаблицы + ".ДвиженияССубконто(,, {Регистратор.*, НомерСтроки, Активность})";
	КонецЕсли; 
	Если ЛиТаблицаИзменений Тогда
		ИмяТаблицы = ИмяТаблицы + ".Изменения";
	КонецЕсли; 
	Возврат ИмяТаблицы;

КонецФункции // ПолучитьИмяТаблицыИзМетаданныхЛкс()

Функция ЛиПолноеИмяРегистраБухгалтерииЛкс(ПолноеИмяМД) Экспорт 
	
	Фрагменты = ЛксПолучитьМассивИзСтрокиСРазделителем(ПолноеИмяМД);
	Результат = Истина
		И Фрагменты.Количество() = 2
		И (Ложь
			Или Фрагменты[0] = "AccountingRegister"
			Или Фрагменты[0] = "РегистрБухгалтерии");
	Возврат Результат;
	
КонецФункции

// Создает тип из метаданных.
//
// Параметры:
//  Метаданные   – ОбъектМетаданных;
//  *Расширение  - Строка, "Ссылка" - расширение типа.
//
// Возвращаемое значение:
//  Тип.
//
Функция ПолучитьТипИзМетаданныхЛкс(ОбъектМД, Расширение = "Ссылка") Экспорт 

	Возврат Тип(ПолучитьИмяТипаИзМетаданныхЛкс(ОбъектМД, Расширение));

КонецФункции // ПолучитьТипИзМетаданных()

Функция ЛиОбщийРеквизитИспользуетсяВОбъектеМетаданныхЛкс(ОбщийРеквизит, ОбъектМетаданных) Экспорт
	
	ЭлементСостава = ОбщийРеквизит.Состав.Найти(ОбъектМетаданных);
	Результат = Истина
		И ЭлементСостава <> Неопределено 
		И (Ложь
			Или ЭлементСостава.Использование = Метаданные.СвойстваОбъектов.ИспользованиеОбщегоРеквизита.Использовать
			Или (Истина
				И ЭлементСостава.Использование = Метаданные.СвойстваОбъектов.ИспользованиеОбщегоРеквизита.Авто
				И ОбщийРеквизит.АвтоИспользование = Метаданные.СвойстваОбъектов.АвтоИспользованиеОбщегоРеквизита.Использовать));
	Возврат Результат;
	
КонецФункции

Функция ПолучитьАлгоритмОбъектПоИдентификаторуЛкс(Знач Алгоритм) Экспорт 

	Если ТипЗнч(Алгоритм) <> Тип("СправочникСсылка.ирАлгоритмы") Тогда
		Алгоритм = "" + Алгоритм;
		Если Найти(Алгоритм, "-") > 0 Тогда
			// Передан GUID
			Алгоритм = Справочники.ирАлгоритмы.ПолучитьСсылку(Новый УникальныйИдентификатор(Алгоритм));
		Иначе
			// Передано имя алгоритма
			Попытка
				Алгоритм = ПредопределенноеЗначение("Справочник.ирАлгоритмы." + Алгоритм);
			Исключение
			КонецПопытки; 
			Если ТипЗнч(Алгоритм) <> Тип("СправочникСсылка.ирАлгоритмы") Тогда
				Алгоритм = Справочники.ирАлгоритмы.НайтиПоНаименованию(Алгоритм, Истина);
			КонецЕсли; 
		КонецЕсли; 
	КонецЕсли;
	Если Не ЗначениеЗаполнено(Алгоритм) Тогда
		ВызватьИсключение "Алгоритм по идентификатору """ + Алгоритм + """ не найден";
	КонецЕсли; 
	Возврат Алгоритм.ПолучитьОбъект();

КонецФункции

Функция СериализоватьЗначениеЛкс(Значение, Знач СериализаторИлиФабрика = Неопределено) Экспорт

	ЗаписьXML = Новый ЗаписьXML;
	ЗаписьXML.УстановитьСтроку();
	Если ТипЗнч(Значение) = Тип("ОбъектXDTO") Тогда
		Если СериализаторИлиФабрика = Неопределено Тогда
			СериализаторИлиФабрика = ФабрикаXDTO;
		КонецЕсли; 
		СериализаторИлиФабрика.ЗаписатьXML(ЗаписьXML, Значение);		
	Иначе
		Если СериализаторИлиФабрика = Неопределено Тогда
			СериализаторИлиФабрика = СериализаторXDTO;
		КонецЕсли; 
		СериализаторИлиФабрика.ЗаписатьXML(ЗаписьXML, Значение);
	КонецЕсли; 
	Результат = ЗаписьXML.Закрыть();
	Возврат Результат;

КонецФункции // СериализоватьОбъектXDTO()

//Если объекту не назначена ссылка, назначает эту ссылку
Функция ПолучитьТочнуюСсылкуОбъектаЛкс(ОбъектБД) Экспорт

	Ссылка = ОбъектБД.Ссылка;
	Если Ссылка.Пустая() Тогда
		Ссылка = ОбъектБД.ПолучитьСсылкуНового();
		Если Ссылка.Пустая() Тогда
			Ссылка = XMLЗначение(ТипЗнч(Ссылка), "" + Новый УникальныйИдентификатор);
			ОбъектБД.УстановитьСсылкуНового(Ссылка);
		КонецЕсли;
	КонецЕсли;
	Возврат Ссылка;

КонецФункции

Функция ПолучитьСтроковыйЛитералИзМногострочногоТекстаЛкс(Знач Текст) Экспорт 

	Текст = Символы.ПС + Текст;
	Текст = СтрЗаменить(Текст, Символы.ПС, Символы.ПС + "|");
	Текст = СтрЗаменить(Текст, """", """""");
	Текст = """" + Текст + """";
	Возврат Текст;

КонецФункции // ПолучитьСтроковыйЛитералИзМногострочногоТекста()

Функция ПолучитьВсеСтрокиДереваЗначенийЛкс(СтрокаИлиДеревоЗначений) Экспорт 

	Если ТипЗнч(СтрокаИлиДеревоЗначений) = Тип("СтрокаДереваЗначений") Тогда
		ДеревоЗначений = СтрокаИлиДеревоЗначений.Владелец();
	Иначе
		ДеревоЗначений = СтрокаИлиДеревоЗначений;
	КонецЕсли; 
	Идентификатор = "_" + СтрЗаменить(Новый УникальныйИдентификатор, "-", "");
	ДеревоЗначений.Колонки.Добавить(Идентификатор);
	ВсеСтроки = СтрокаИлиДеревоЗначений.Строки.НайтиСтроки(Новый Структура(Идентификатор,), Истина);
	ДеревоЗначений.Колонки.Удалить(Идентификатор);
	Возврат ВсеСтроки;

КонецФункции // ПолучитьВсеСтрокиДереваЗначений()

Функция СериализацииРавныЛкс(Таблица1, Таблица2) Экспорт
	
	Хмл1 = СериализоватьЗначениеЛкс(Таблица1);
	Хмл2 = СериализоватьЗначениеЛкс(Таблица2);
	Возврат (Хмл1 = Хмл2);
	
КонецФункции

// ВариантОбрезания - 1 
// ВариантОбрезания - 2 
Функция ПолучитьИнформациюОбОшибкеБезВерхнегоМодуляЛкс(ИнформацияОбОшибке = Неопределено, ВариантОбрезания = 2) Экспорт
	
	Если ИнформацияОбОшибке = Неопределено Тогда
		ИнформацияОбОшибке = ИнформацияОбОшибке();
	КонецЕсли; 
	Если ВариантОбрезания = 1 Тогда
		ОписаниеОшибки = ИнформацияОбОшибке.Описание;
		Если ИнформацияОбОшибке.Причина <> Неопределено Тогда
			ОписаниеОшибки = ОписаниеОшибки + ": " + ПодробноеПредставлениеОшибки(ИнформацияОбОшибке.Причина);
		КонецЕсли; 
	ИначеЕсли Истина
		И ВариантОбрезания = 2 
		И ИнформацияОбОшибке.Причина <> Неопределено
	Тогда
		ОписаниеОшибки = ИнформацияОбОшибке.Описание + ": " + ПодробноеПредставлениеОшибки(ИнформацияОбОшибке.Причина);
	Иначе
		ОписаниеОшибки = ПодробноеПредставлениеОшибки(ИнформацияОбОшибке);
	КонецЕсли;
	Возврат ОписаниеОшибки;
	
КонецФункции

// Первая строка табличного документа содержит заголовки
Функция ПолучитьТаблицуИзТабличногоДокументаЛкс(Знач ТабличныйДокумент, ЛиПерваяСтрокаСодержитИменаКолонок = Истина, ДлинаСтрокиТипаКолонки = 150,
	ВычислятьНетипизированныеЗначения = Ложь, ЛиВтораяСтрокаСодержитТипыЗначений = Ложь) Экспорт
	
	#Если _ Тогда
		ТабличныйДокумент = Новый ТабличныйДокумент
	#КонецЕсли
	ТаблицаПриемник = Новый ТаблицаЗначений;
	НачальнаяСтрока = 1;
	Если ЛиПерваяСтрокаСодержитИменаКолонок Тогда
		НачальнаяСтрока = НачальнаяСтрока + 1;
	КонецЕсли; 
	Если ЛиВтораяСтрокаСодержитТипыЗначений Тогда
		НачальнаяСтрока = НачальнаяСтрока + 1;
	КонецЕсли; 
	ТипизированныеКолонки = Новый Соответствие;
	Для Счетчик = 1 По ТабличныйДокумент.ШиринаТаблицы Цикл
		Если ЛиПерваяСтрокаСодержитИменаКолонок Тогда
			ИмяКолонки = ТабличныйДокумент.Область(1, Счетчик).Текст;
		Иначе
			ИмяКолонки = "Колонка" + Счетчик;
		КонецЕсли; 
		Если ЛиВтораяСтрокаСодержитТипыЗначений Тогда
			ИменаТипов = ТабличныйДокумент.Область(2, Счетчик).Текст;
			ТипизированныеКолонки[Счетчик] = 1;
		Иначе
			ИменаТипов = "";
		КонецЕсли; 
		ТаблицаПриемник.Колонки.Добавить(ИмяКолонки, Новый ОписаниеТипов(ИменаТипов));
	КонецЦикла; 
	// Цикл перебора строк табличного  документа
	ВысотаТаблицы = ТабличныйДокумент.ВысотаТаблицы;
	//Индикатор = ОбщийИис.ПолучитьИндикаторПроцессаИис(ТабличныйДокумент.ВысотаТаблицы);
	Для НомерСтроки = НачальнаяСтрока По ВысотаТаблицы Цикл
		// Добавление строки результирующей таблицы
		НоваяСтрокаТЗ = ТаблицаПриемник.Добавить();
		Для НомерКолонки = 1 По ТабличныйДокумент.ШиринаТаблицы Цикл
			Область = ТабличныйДокумент.Область(НомерСтроки, НомерКолонки);
			ТекстЯчейки = Область.Текст;
			Если Не ЗначениеЗаполнено(ТекстЯчейки) Тогда
				Поддокумент = ТабличныйДокумент.ПолучитьОбласть(НомерСтроки, НомерКолонки);
				Если Поддокумент.Рисунки.Количество() > 0 Тогда
					ТекстЯчейки = Поддокумент.Рисунки[0].Картинка;
				КонецЕсли;
			КонецЕсли; 
			ЗначениеЯчейки = ТекстЯчейки;
			Если Ложь
				Или ВычислятьНетипизированныеЗначения 
				Или ТипизированныеКолонки[НомерКолонки] <> Неопределено
			Тогда
				Попытка
					ЗначениеЯчейки = Вычислить(ЗначениеЯчейки);
				Исключение
				КонецПопытки;
			КонецЕсли; 
			НоваяСтрокаТЗ[НомерКолонки - 1] = ЗначениеЯчейки;
		КонецЦикла;
	КонецЦикла;
	Возврат ТаблицаПриемник;

КонецФункции

Функция ПолучитьИдентификаторТипаЛкс(Тип) Экспорт 

	Результат = ЛксПолучитьСтрокуМеждуМаркерами("" + ЗначениеВСтрокуВнутр(Тип), ",", "}", Ложь);
	Возврат Результат;
	
КонецФункции

Функция ПолучитьПеременныеТекстаВстроенногоЯзыкаЛкс(Знач ТекстПрограммы = "") Экспорт

	Если ПустаяСтрока(ТекстПрограммы) Тогда
		ТекстПрограммы = ирНеглобальный.ПолучитьТекстИзБуфераОбменаОСЛкс();
	КонецЕсли; 
	Параметры = Новый Структура();
	ПолеВстроенногоЯзыка = Обработки.ирКлсПолеТекстовогоДокументаСКонтекстнойПодсказкой.Создать();
	ПолеВстроенногоЯзыка.ИнициализироватьНеинтерактивно();
	ПолеВстроенногоЯзыка.ЗаполнитьЛокальныеСвойстваИМетодыПоТексту(,,,, Истина, ТекстПрограммы);
	СтрокиЛокальныхПеременных = ПолеВстроенногоЯзыка.ТаблицаСлов.НайтиСтроки(Новый Структура("ТипСлова, Определение", "Свойство", "Статистический"));
	//СтрокиЛокальныхПеременных = ПолеВстроенногоЯзыка.ТаблицаСлов.НайтиСтроки(Новый Структура("ТипСлова", "Свойство"));
	Для Каждого СтрокаПеременной Из СтрокиЛокальныхПеременных Цикл
		Параметры.Вставить(СтрокаПеременной.Слово);
	КонецЦикла;
	Возврат Параметры;

КонецФункции


// КолонкиНабора - КоллекцияКолонокДереваЗначений, КоллекцияКолонокТаблицыЗначений, КоллекцияКолонокРезультатаЗапроса
Функция СоздатьИлиОбновитьНаборДанныхОбъектПоМетаданнымЛкс(Знач СхемаКомпоновкиДанных, Знач КолонкиНабора, Знач ИмяНабора = "Основной",
	Знач СоздаватьПапкиПолей = Ложь, СоздаватьРесурсыЧисловыхПолей = Ложь) Экспорт
	
	#Если _ Тогда
	    СхемаКомпоновкиДанных = Новый СхемаКомпоновкиДанных;
	#КонецЕсли
	Результат = СхемаКомпоновкиДанных.НаборыДанных.Найти(ИмяНабора);
	Если Результат = Неопределено Тогда
		Результат = СхемаКомпоновкиДанных.НаборыДанных.Добавить(Тип("НаборДанныхОбъектСхемыКомпоновкиДанных"));
	КонецЕсли;
	Результат.Имя = ИмяНабора;
	Результат.ИсточникДанных = СхемаКомпоновкиДанных.ИсточникиДанных[0].Имя;
	Результат.ИмяОбъекта = ИмяНабора;
	Для Каждого ЭлементМетаданных Из КолонкиНабора Цикл
		Если Ложь
			Или ТипЗнч(ЭлементМетаданных) = Тип("КолонкаДереваЗначений")
			Или ТипЗнч(ЭлементМетаданных) = Тип("КолонкаТаблицыЗначений")
		Тогда
			ИмяПоля = ЭлементМетаданных.Имя;
			ЗаголовокПоля = ЭлементМетаданных.Заголовок;
		ИначеЕсли Ложь
			Или ТипЗнч(ЭлементМетаданных) = Тип("КолонкаРезультатаЗапроса")
		Тогда
			ИмяПоля = ЭлементМетаданных.Имя;
			ЗаголовокПоля = ИмяПоля;
		ИначеЕсли Ложь
			Или ТипЗнч(ЭлементМетаданных) = Тип("ПолеНастройки")
		Тогда
			ИмяПоля = ЭлементМетаданных.Имя;
			ЗаголовокПоля = ЭлементМетаданных.Представление;
		ИначеЕсли Ложь
			Или ТипЗнч(ЭлементМетаданных) = Тип("ДоступноеПолеОтбораКомпоновкиДанных")
		Тогда
			ИмяПоля = "" + ЭлементМетаданных.Поле;
			ЗаголовокПоля = ЭлементМетаданных.Заголовок;
		Иначе
			Продолжить;
		КонецЕсли;
		Поле = Результат.Поля.Найти(ИмяПоля);
		Если Поле = Неопределено Тогда
			Поле = Результат.Поля.Добавить(Тип("ПолеНабораДанныхСхемыКомпоновкиДанных"));
		КонецЕсли;
		ПутьКДанным = ИмяПоля;
		Если СоздаватьПапкиПолей Тогда
			ПутьКДанным = Результат.Имя + "." + ПутьКДанным;
		КонецЕсли; 
		Поле.ПутьКДанным = ПутьКДанным;
		Поле.Поле = ИмяПоля;
		Поле.Заголовок = ЗаголовокПоля;
		Поле.ТипЗначения = ЭлементМетаданных.ТипЗначения;
		Если Истина
			И СоздаватьРесурсыЧисловыхПолей
			И Поле.ТипЗначения.СодержитТип(Тип("Число"))
		Тогда
			Ресурс = СхемаКомпоновкиДанных.ПоляИтога.Добавить();
			Ресурс.Выражение = "Сумма(" + ИмяПоля + ")";
			Ресурс.ПутьКДанным = ИмяПоля;
		КонецЕсли; 
	КонецЦикла;
	Возврат Результат;
	
КонецФункции

Процедура ЗаполнитьПараметрыСхемыПоЗапросуЛкс(Знач СхемаКомпоновкиДанных, Знач Запрос) Экспорт

	Для Каждого КлючИЗначение Из Запрос.Параметры Цикл
		ЗначениеПараметра = КлючИЗначение.Значение;
		Если ТипЗнч(ЗначениеПараметра) = Тип("Массив") Тогда
			Список = Новый СписокЗначений;
			Список.ЗагрузитьЗначения(ЗначениеПараметра);
			ЗначениеПараметра = Список;
		КонецЕсли;
		ПараметрСхемы = СхемаКомпоновкиДанных.Параметры.Найти(КлючИЗначение.Ключ);
		Если ПараметрСхемы = Неопределено Тогда
		 	ПараметрСхемы = СхемаКомпоновкиДанных.Параметры.Добавить();
		КонецЕсли; 
		ПараметрСхемы.Имя = КлючИЗначение.Ключ;
		ПараметрСхемы.ДоступенСписокЗначений = ТипЗнч(ЗначениеПараметра) = Тип("СписокЗначений");
		//Тип надо задавать, чтобы значение корректно записалось. Иначе ссылки будут преобразованы к строке.
		МассивТипов = Новый Массив;
		МассивТипов.Добавить(ТипЗнч(КлючИЗначение.Значение));
		Если Не ПараметрСхемы.ДоступенСписокЗначений Тогда
			ПараметрСхемы.ТипЗначения = Новый ОписаниеТипов(МассивТипов);
		КонецЕсли; 
		ПараметрСхемы.Значение = ЗначениеПараметра;
	КонецЦикла;
	
КонецПроцедуры

Функция СоздатьИлиОбновитьНаборДанныхЗапросПоЗапросуЛкс(Знач СхемаКомпоновкиДанных, Знач Запрос, Знач ИмяНабора = "Основной",
	Представления = Неопределено) Экспорт
	
	НаборДанных = ЛксДобавитьНаборДанныхЗапрос(СхемаКомпоновкиДанных.НаборыДанных, СхемаКомпоновкиДанных.ИсточникиДанных[0]);
	НаборДанных.АвтоЗаполнениеДоступныхПолей = Истина;
	НаборДанных.Запрос = Запрос.Текст;
	Если Представления <> Неопределено Тогда
		Для Каждого КлючИЗначение Из Представления Цикл
			ПолеНабора = НаборДанных.Поля.Найти(КлючИЗначение.Ключ);
			Если ПолеНабора = Неопределено Тогда
				ПолеНабора = НаборДанных.Поля.Добавить(Тип("ПолеНабораДанныхСхемыКомпоновкиДанных"));
			КонецЕсли;
			ПолеНабора.Поле = КлючИЗначение.Ключ;
			ПолеНабора.ПутьКДанным = КлючИЗначение.Ключ;
			ПолеНабора.Заголовок = КлючИЗначение.Значение;
		КонецЦикла;
	КонецЕсли; 
	ЗаполнитьПараметрыСхемыПоЗапросуЛкс(СхемаКомпоновкиДанных, Запрос);
	Возврат НаборДанных;
	
КонецФункции

// Представления - Структура
Функция ПолучитьСхемуКомпоновкиПоЗапросуЛкс(Знач ЗапросИлиТекст, ИмяНабораДанных = "НаборДанных1", Представления = Неопределено) Экспорт
	
	Схема = Новый СхемаКомпоновкиДанных;
	ЛксДобавитьЛокальныйИсточникДанных(Схема);
	Если ТипЗнч(ЗапросИлиТекст) = Тип("Строка") Тогда
		Запрос = Новый Запрос;
		Запрос.Текст = ЗапросИлиТекст;
	Иначе
		Запрос = ЗапросИлиТекст;
	КонецЕсли; 
	СоздатьИлиОбновитьНаборДанныхЗапросПоЗапросуЛкс(Схема, Запрос, ИмяНабораДанных, Представления);
	Возврат Схема;
	
КонецФункции

Функция ПолучитьСхемуКомпоновкиПоОбъектуМетаданныхЛкс(Знач ПолноеИмяИлиОбъектМД, ИмяНабораДанных = "НаборДанных1",
	ДобавитьАвтополеКоличествоСтрок = Истина, ПсевдонимТаблицы = "Т") Экспорт
	
	Если ТипЗнч(ПолноеИмяИлиОбъектМД) = Тип("Строка") Тогда
		ПолноеИмяМД = ПолноеИмяИлиОбъектМД;
	Иначе
		ПолноеИмяМД = ПолноеИмяИлиОбъектМД.ПолноеИмя();
	КонецЕсли; 
	Схема = Новый СхемаКомпоновкиДанных;
	ИсточникДанных = ЛксДобавитьЛокальныйИсточникДанных(Схема);
	НаборДанных = ЛксДобавитьНаборДанныхЗапрос(Схема.НаборыДанных, ИсточникДанных);
	#Если _ Тогда
	    НаборДанных = Схема.НаборыДанных.Добавить();
	#КонецЕсли
	НаборДанных.АвтоЗаполнениеДоступныхПолей = Истина;
	ПолноеИмяТаблицыБД = ПолучитьИмяТаблицыИзМетаданныхЛкс(ПолноеИмяМД);
	НаборДанных.Запрос = "ВЫБРАТЬ " + ПсевдонимТаблицы + ".* ИЗ " + ПолноеИмяТаблицыБД + " КАК " + ПсевдонимТаблицы;
	Если ДобавитьАвтополеКоличествоСтрок Тогда
		ДобавитьВСхемуКомпоновкиАвтополеКоличествоСтрок(Схема);
	КонецЕсли;
	// Антибаг платформы в режиме совместимости. Предопределенные реквизиты имеют англ. имена полей
	Если Метаданные.РежимСовместимости = Метаданные.СвойстваОбъектов.РежимСовместимости.Версия8_1 Тогда
		Построитель = Новый ПостроительЗапроса(НаборДанных.Запрос);
		Построитель.ЗаполнитьНастройки();
		Для Каждого ДоступноеПоле Из Построитель.ДоступныеПоля Цикл
		    ПолеНабора = НаборДанных.Поля.Добавить(Тип("ПолеНабораДанныхСхемыКомпоновкиДанных"));
			ПолеНабора.Поле = ДоступноеПоле.ПутьКДанным;
			//ПолеНабора.ПутьКДанным = ДоступноеПоле.ПутьКДанным;
			ПолеНабора.Заголовок = ДоступноеПоле.Представление;
		КонецЦикла;
	КонецЕсли; 
	Возврат Схема;
	
КонецФункции


Функция ПолучитьИндексКартинкиТипаТаблицыБДЛкс(ТипТаблицы) Экспорт
	
	ИндексКартинки = 14;
	Если ТипТаблицы = "Константы" Тогда
		ИндексКартинки = 2;
	ИначеЕсли ТипТаблицы = "Константа" Тогда
		ИндексКартинки = 2;
	//ИначеЕсли ТипТаблицы = "ТабличнаяЧасть" Тогда
	ИначеЕсли ЛксЛиТипВложеннойТаблицыБД(ТипТаблицы) Тогда
		ИндексКартинки = 20;
	ИначеЕсли ТипТаблицы = "Изменения" Тогда
		ИндексКартинки = 27;
	ИначеЕсли ТипТаблицы = "ВиртуальнаяТаблица" Тогда
		ИндексКартинки = 28;
	ИначеЕсли ТипТаблицы = "ВнешнийИсточникДанных" Тогда
		ИндексКартинки = 29;
	ИначеЕсли ТипТаблицы = "Справочник" Тогда
		ИндексКартинки = 3;
	ИначеЕсли ТипТаблицы = "Перечисление" Тогда
		ИндексКартинки = 4;
	ИначеЕсли ТипТаблицы = "Документ" Тогда
		ИндексКартинки = 5;
	ИначеЕсли ТипТаблицы = "ЖурналДокументов" Тогда
		ИндексКартинки = 6;
	ИначеЕсли ТипТаблицы = "Последовательность" Тогда
		ИндексКартинки = 7;
	ИначеЕсли ТипТаблицы = "РегистрНакопления" Тогда
		ИндексКартинки = 8;
	ИначеЕсли ТипТаблицы = "РегистрСведений" Тогда
		ИндексКартинки = 9;
	ИначеЕсли ТипТаблицы = "РегистрБухгалтерии" Тогда
		ИндексКартинки = 10;
	ИначеЕсли ТипТаблицы = "РегистрРасчета" Тогда
		ИндексКартинки = 11;
	ИначеЕсли ТипТаблицы = "ПланОбмена" Тогда
		ИндексКартинки = 19;
	ИначеЕсли ТипТаблицы = "Задача" Тогда
		ИндексКартинки = 17;
	ИначеЕсли ТипТаблицы = "БизнесПроцесс" Тогда
		ИндексКартинки = 18;
	ИначеЕсли ТипТаблицы = "РегистрРасчета" Тогда
		ИндексКартинки = 26;
	ИначеЕсли ТипТаблицы = "ПланВидовРасчета" Тогда
		ИндексКартинки = 25;
	ИначеЕсли ТипТаблицы = "ПланВидовХарактеристик" Тогда
		ИндексКартинки = 22;
	ИначеЕсли ТипТаблицы = "Перечисление" Тогда
		ИндексКартинки = 23;
	ИначеЕсли ТипТаблицы = "ПланСчетов" Тогда
		ИндексКартинки = 24;
	ИначеЕсли ирНеглобальный.СтрокиРавныЛкс(ТипТаблицы, "Table") Тогда
		ИндексКартинки = 3;
	КонецЕсли;
	Возврат ИндексКартинки;
	
КонецФункции

Функция НайтиЭлементКоллекцииПоЗначениюСвойстваЛкс(Знач Коллекция, Знач Свойство, Знач Значение, Знач ТипЭлемента = Неопределено) Экспорт
	
	Структура = Новый Структура(Свойство);
	Для каждого Элемент Из Коллекция Цикл
		Если Истина
			И ТипЭлемента <> Неопределено
			И ТипЗнч(Элемент) <> ТипЭлемента 
		Тогда
			Продолжить;
		КонецЕсли;
		ЗаполнитьЗначенияСвойств(Структура, Элемент, Свойство); 
		Если Структура[Свойство] = Значение Тогда
			Результат = Элемент;
			Прервать;
		КонецЕсли;
	КонецЦикла;
	Возврат Результат;
	
КонецФункции

Функция НайтиДобавитьЭлементНастроекКомпоновкиПоПредставлениюЛкс(Знач ЭлементыНастройки, Знач Представление = "", Знач ПроверятьУникальность = Истина,
	Знач ИспользованиеДляНового = Истина) Экспорт
	
	Попытка
		ЭлементыНастройки = ЭлементыНастройки.Элементы;
	Исключение
	КонецПопытки;
	Если ТипЗнч(ЭлементыНастройки) = Тип("КоллекцияЭлементовОтбораКомпоновкиДанных") Тогда
		ТипЭлемента = Тип("ЭлементОтбораКомпоновкиДанных");
	ИначеЕсли ТипЗнч(ЭлементыНастройки) = Тип("КоллекцияЭлементовУсловногоОформленияКомпоновкиДанных") Тогда
		ТипЭлемента = Неопределено;
	КонецЕсли;
	Если ПроверятьУникальность Тогда
		ЭлементНастроек = НайтиЭлементКоллекцииПоЗначениюСвойстваЛкс(ЭлементыНастройки, "Представление", Представление, ТипЭлемента);
	КонецЕсли;
	Если ЭлементНастроек = Неопределено Тогда
		Если ТипЭлемента <> Неопределено Тогда
			ЭлементНастроек = ЭлементыНастройки.Добавить(ТипЭлемента);
		Иначе
			ЭлементНастроек = ЭлементыНастройки.Добавить();
		КонецЕсли;
		ЭлементНастроек.Представление = Представление;
		ЭлементНастроек.Использование = ИспользованиеДляНового;
	КонецЕсли;
	Возврат ЭлементНастроек;
	
КонецФункции

Функция НайтиДобавитьЭлементНастроекКомпоновкиПоПолюЛкс(Знач ЭлементыНастройки, Знач Поле = "", Знач ПроверятьУникальность = Истина,
	Знач ИспользованиеДляНового = Истина) Экспорт
	
	Если ТипЗнч(Поле) = Тип("Строка") Тогда
		Поле = Новый ПолеКомпоновкиДанных(Поле);
	КонецЕсли;
	Попытка
		ЭлементыНастройки = ЭлементыНастройки.Элементы;
	Исключение
	КонецПопытки;
	Если      ТипЗнч(ЭлементыНастройки) = Тип("КоллекцияЭлементовПорядкаКомпоновкиДанных") Тогда
		ТипЭлемента = Тип("ЭлементПорядкаКомпоновкиДанных");
	ИначеЕсли ТипЗнч(ЭлементыНастройки) = Тип("КоллекцияВыбранныхПолейКомпоновкиДанных") Тогда
		ТипЭлемента = Тип("ВыбранноеПолеКомпоновкиДанных");
	ИначеЕсли ТипЗнч(ЭлементыНастройки) = Тип("КоллекцияПолейГруппировкиКомпоновкиДанных") Тогда
		ТипЭлемента = Тип("ПолеГруппировкиКомпоновкиДанных");
	ИначеЕсли ТипЗнч(ЭлементыНастройки) = Тип("КоллекцияЭлементовУсловногоОформленияКомпоновкиДанных") Тогда
		ТипЭлемента = Неопределено;
	//ИначеЕсли ТипЗнч(ЭлементыНастройки) = Тип("КоллекцияЭлементовОтбораКомпоновкиДанных") Тогда
	//	ТипЭлемента = Тип("ЭлементОтбораКомпоновкиДанных");
	КонецЕсли;
	Если ПроверятьУникальность Тогда
		ЭлементНастроек = НайтиЭлементКоллекцииПоЗначениюСвойстваЛкс(ЭлементыНастройки, "Поле", Поле, ТипЭлемента);
	КонецЕсли;
	Если ЭлементНастроек = Неопределено Тогда
		Если ТипЭлемента <> Неопределено Тогда
			ЭлементНастроек = ЭлементыНастройки.Добавить(ТипЭлемента);
		Иначе
			ЭлементНастроек = ЭлементыНастройки.Добавить();
		КонецЕсли;
		ЭлементНастроек.Поле = Поле;
		ЭлементНастроек.Использование = ИспользованиеДляНового;
	КонецЕсли;
	Возврат ЭлементНастроек;
	
КонецФункции

Функция НайтиДобавитьЭлементСтруктурыГруппировкаКомпоновкиЛкс(Знач Группировки, Знач Поле = "") Экспорт
	
	Если ТипЗнч(Поле) = Тип("Строка") Тогда
		Поле = Новый ПолеКомпоновкиДанных(Поле);
	КонецЕсли;
	ЭлементСуществует = Ложь;
	Для Каждого Группировка Из Группировки Цикл
		Поля = Группировка.ПоляГруппировки.Элементы;
		Если Ложь
			Или (Истина
				И Поля.Количество() = 0
				И "" + Поле = "")
			Или (Истина
				И Поля.Количество() = 1
				И Поля[0].Поле = Поле)
		Тогда
			ЭлементСуществует = Истина;
			Прервать;
		КонецЕсли;
	КонецЦикла;
	Если Не ЭлементСуществует Тогда
		Группировка = Группировки.Добавить(Тип("ГруппировкаКомпоновкиДанных"));
		Группировка.Выбор.Элементы.Добавить(Тип("АвтоВыбранноеПолеКомпоновкиДанных"));
		Группировка.Порядок.Элементы.Добавить(Тип("АвтоЭлементПорядкаКомпоновкиДанных"));
		Если "" + Поле <> "" Тогда
			ПолеГруппировки = Группировка.ПоляГруппировки.Элементы.Добавить(Тип("ПолеГруппировкиКомпоновкиДанных"));
			ПолеГруппировки.Поле = Поле;
		КонецЕсли;
	КонецЕсли;
	Группировка.Использование = Истина;
	Возврат Группировка;
	
КонецФункции

Функция НайтиЭлементОтбораКомпоновкиЛкс(Знач Отбор, Знач ИменаПолей, Знач НайденныеЭлементы = Неопределено, Знач ТолькоВключенныеНаРавенствоЗначению = Ложь,
	Знач ВключатьПодчиненные = Ложь) Экспорт
	
	Если ТипЗнч(Отбор) = Тип("ОтборКомпоновкиДанных") Тогда
		ЭлементыОтбора = Отбор.Элементы;
	Иначе
		ЭлементыОтбора = Отбор;
	КонецЕсли;
	Если ТипЗнч(ИменаПолей) = Тип("Строка") Тогда
		МассивИменПолей = ЛксПолучитьМассивИзСтрокиСРазделителем(ИменаПолей, ",", Истина);
	Иначе
		МассивИменПолей = ИменаПолей;
	КонецЕсли;
	МассивПолей = Новый Массив;
	Для Каждого ИмяПоля Из МассивИменПолей Цикл
		МассивПолей.Добавить(Новый ПолеКомпоновкиДанных(ИмяПоля));
	КонецЦикла;
	МассивПолейПуст = МассивПолей.Количество() = 0;
	Если НайденныеЭлементы = Неопределено Тогда
		НайденныеЭлементы = Новый Соответствие;
	КонецЕсли;
	Для Каждого ЭлементОтбора ИЗ ЭлементыОтбора Цикл
		Если Истина
			И ТипЗнч(ЭлементОтбора) = Тип("ЭлементОтбораКомпоновкиДанных")
			И (Ложь
				Или Не ТолькоВключенныеНаРавенствоЗначению
				Или (Истина
					И ЭлементОтбора.Использование
					И ЭлементОтбора.ВидСравнения = ВидСравненияКомпоновкиДанных.Равно
					И ТипЗнч(ЭлементОтбора.ЛевоеЗначение)   = Тип("ПолеКомпоновкиДанных")
					И ТипЗнч(ЭлементОтбора.ПравоеЗначение) <> Тип("ПолеКомпоновкиДанных")))
		Тогда
			Если Ложь
				Или МассивПолейПуст
				Или МассивПолей.Найти(ЭлементОтбора.ЛевоеЗначение) <> Неопределено 
			Тогда
				НайденныеЭлементы.Вставить("" + ЭлементОтбора.ЛевоеЗначение, ЭлементОтбора);
			КонецЕсли;
		ИначеЕсли Истина
			И ВключатьПодчиненные
			И ТипЗнч(ЭлементОтбора) = Тип("ГруппаЭлементовОтбораКомпоновкиДанных")
		Тогда
			НайтиЭлементОтбораКомпоновкиЛкс(ЭлементОтбора.Элементы, МассивИменПолей, НайденныеЭлементы, ТолькоВключенныеНаРавенствоЗначению);
		КонецЕсли;
	КонецЦикла;
	Если МассивИменПолей.Количество() = 1 Тогда
		Результат = НайденныеЭлементы[МассивИменПолей[0]];
	Иначе
		Результат = НайденныеЭлементы;
	КонецЕсли;
	Возврат Результат;
	
КонецФункции

Функция НайтиДобавитьЭлементОтбораКомпоновкиЛкс(Знач ЭлементыОтбора, Знач Поле = "", Знач Значение, Знач Сравнение = "", Знач ДоступныеПоляОтбора = Неопределено,
	Знач ПроверятьУникальность = Истина) Экспорт
	
	Если ТипЗнч(ЭлементыОтбора) = Тип("НастройкиКомпоновкиДанных") Тогда
		ЭлементыОтбора = ЭлементыОтбора.Отбор;
	КонецЕсли;
	Если ТипЗнч(ЭлементыОтбора) = Тип("ОтборКомпоновкиДанных") Тогда
		ДоступныеПоляОтбора = ЭлементыОтбора.ДоступныеПоляОтбора;
		ЭлементыОтбора = ЭлементыОтбора.Элементы;
	Иначе
		ЭлементыОтбора = ЭлементыОтбора;
	КонецЕсли;
	Если ТипЗнч(Поле) = Тип("Строка") Тогда
		Поле = Новый ПолеКомпоновкиДанных(Поле);
	КонецЕсли;
	Если ПроверятьУникальность Тогда
		ЭлементОтбора = НайтиЭлементОтбораКомпоновкиЛкс(ЭлементыОтбора, "" + Поле);
	КонецЕсли;
	Если ЭлементОтбора = Неопределено Тогда
		ЭлементОтбора = ЭлементыОтбора.Добавить(Тип("ЭлементОтбораКомпоновкиДанных"));
		ЭлементОтбора.ЛевоеЗначение = Поле;
	КонецЕсли;
	Если ТипЗнч(Значение) = Тип("Массив") Тогда
		СписокЗначений = Новый СписокЗначений;
		СписокЗначений.ЗагрузитьЗначения(Значение);
		Значение = СписокЗначений;
	КонецЕсли;
	
	// Вид сравнения
	Если ТипЗнч(Сравнение) = Тип("ВидСравненияКомпоновкиДанных") Тогда
	Иначе
		Если ТипЗнч(Значение) = Тип("СписокЗначений") Тогда
			Сравнение = ВидСравненияКомпоновкиДанных.ВСписке;
		Иначе
			Сравнение = ВидСравненияКомпоновкиДанных.Равно;
		КонецЕсли;
	КонецЕсли;
	Если Истина
		И Сравнение = ВидСравненияКомпоновкиДанных.Равно
		И Значение = Неопределено
		И ДоступныеПоляОтбора <> Неопределено
	Тогда
		ДоступноеПолеОтбора = ДоступныеПоляОтбора.НайтиПоле(Поле);
		Если ДоступноеПолеОтбора <> Неопределено Тогда
			Значение = ДоступноеПолеОтбора.Тип.ПривестиЗначение(Значение);
			Если Истина
				И Значение = ""
				И ДоступноеПолеОтбора.Тип.КвалификаторыСтроки.Длина = 0
			Тогда
				Сравнение = ВидСравненияКомпоновкиДанных.Содержит;
			КонецЕсли;
		КонецЕсли;
	КонецЕсли;
	
	ЭлементОтбора.ВидСравнения = Сравнение;
	ЭлементОтбора.ПравоеЗначение = Значение;
	ЭлементОтбора.Использование = Истина;
	Возврат ЭлементОтбора;
	
КонецФункции

// Таблица - ТаблицаЗначений, ТабличнаяЧасть
Функция ПолучитьНеуникальныеЗначенияКолонкиТаблицыЛкс(Таблица, ИмяКолонки, ИгнорироватьРегистрДляПростогоСтрокогоТипа = Истина) Экспорт 

	Если ТипЗнч(Таблица) = Тип("ТаблицаЗначений") Тогда
		КопияТаблицы = Таблица.Скопировать(, ИмяКолонки);
	Иначе
		КопияТаблицы = Таблица.Выгрузить(, ИмяКолонки);
	КонецЕсли; 
	Типы = КопияТаблицы.Колонки[ИмяКолонки].ТипЗначения.Типы();
	Если Истина
		И Типы.Количество() = 1
		И Типы[0] = Тип("Строка")
		И ИгнорироватьРегистрДляПростогоСтрокогоТипа 
	Тогда
		ИмяКолонкиНрег = ИмяКолонки + "_Нрег777233464645";
		КопияТаблицы.Колонки.Добавить(ИмяКолонкиНрег);
		Для Каждого СтрокаКопииТаблицы Из КопияТаблицы Цикл
			СтрокаКопииТаблицы[ИмяКолонкиНрег] = НРег(СтрокаКопииТаблицы[ИмяКолонки]);
		КонецЦикла;
	Иначе
		ИмяКолонкиНрег = ИмяКолонки;
	КонецЕсли; 
	КолонкаКоличества = ИмяКолонки + "7773534765"; //гарантировано уникальное имя колонки
	КопияТаблицы.Колонки.Добавить(КолонкаКоличества);
	КопияТаблицы.ЗаполнитьЗначения(1, КолонкаКоличества);
	КопияТаблицы.Свернуть(ИмяКолонкиНрег, КолонкаКоличества);
	КопияТаблицы.Сортировать(КолонкаКоличества + " Убыв");
	МассивНеуникальных = Новый Массив;
	Для Индекс = 0 По КопияТаблицы.Количество() - 1 Цикл
		СтрокаКопии = КопияТаблицы[Индекс];
		Если СтрокаКопии[КолонкаКоличества] > 1 Тогда
			МассивНеуникальных.Добавить(СтрокаКопии[ИмяКолонкиНрег]);
		КонецЕсли; 
	КонецЦикла;
	Возврат МассивНеуникальных;

КонецФункции // ПолучитьНеуникальныеЗначенияКолонки()

Функция ПолучитьСтруктуруКлючаТаблицыБДЛкс(Знач ПолноеИмяТаблицыБД, ВключатьНомерСтроки = Истина, ВернутьСтруктуру = Истина) Экспорт
	
	ТипТаблицы = ирНеглобальный.ПолучитьТипТаблицыБДЛкс(ПолноеИмяТаблицыБД);
	МассивФрагментов = ЛксПолучитьМассивИзСтрокиСРазделителем(ПолноеИмяТаблицыБД);
	СписокПолей = Новый СписокЗначений;
	Если ЛксЛиКорневойТипОбъектаБД(ТипТаблицы) Тогда
		СписокПолей.Добавить(Новый ОписаниеТипов(СтрЗаменить(ПолноеИмяТаблицыБД, ".", "Ссылка.")), "Ссылка");
	ИначеЕсли ЛксЛиКорневойТипРегистраБД(ТипТаблицы) Тогда
		НаборЗаписей = Новый (СтрЗаменить(ПолноеИмяТаблицыБД, ".", "НаборЗаписей."));
		Для Каждого ЭлементОтбора Из НаборЗаписей.Отбор Цикл
			СписокПолей.Добавить(ЭлементОтбора.ТипЗначения, ЭлементОтбора.Имя);
		КонецЦикла;
		Если ВключатьНомерСтроки Тогда
			ОбъектМД = Метаданные.НайтиПоПолномуИмени(ПолноеИмяТаблицыБД);
			Если Ложь
				Или ТипТаблицы <> "РегистрСведений"
				Или ОбъектМД.РежимЗаписи = Метаданные.СвойстваОбъектов.РежимЗаписиРегистра.ПодчинениеРегистратору
			Тогда
				СписокПолей.Добавить(Новый ОписаниеТипов("Число"), "НомерСтроки");
			КонецЕсли; 
		КонецЕсли; 
	ИначеЕсли ЛксЛиКорневойТипПоследовательности(ТипТаблицы) Тогда
		НаборЗаписей = Новый (СтрЗаменить(ПолноеИмяТаблицыБД, ".", "НаборЗаписей."));
		Для Каждого ЭлементОтбора Из НаборЗаписей.Отбор Цикл
			СписокПолей.Добавить(ЭлементОтбора.ТипЗначения, ЭлементОтбора.Имя);
		КонецЦикла;
		Если ВключатьНомерСтроки Тогда
			СписокПолей.Добавить(Новый ОписаниеТипов("Дата"), "Период");
		КонецЕсли; 
	ИначеЕсли ЛксЛиТипВложеннойТаблицыБД(ТипТаблицы) Тогда
		СписокПолей.Добавить(Новый ОписаниеТипов(МассивФрагментов[0] + "Ссылка." + МассивФрагментов[1]), "Ссылка");
		Если ВключатьНомерСтроки Тогда
			СписокПолей.Добавить(Новый ОписаниеТипов("Число"), "НомерСтроки");
		КонецЕсли; 
	ИначеЕсли ТипТаблицы = "Изменения" Тогда
		ВызватьИсключение "Тип таблицы """ + ТипТаблицы + """ не поддерживается";
	КонецЕсли;
	Если ВернутьСтруктуру Тогда
		Результат = Новый Структура();
		Для Каждого ЭлементСписка Из СписокПолей Цикл
			Результат.Вставить(ЭлементСписка.Представление, ЭлементСписка.Значение);
		КонецЦикла;
	Иначе
		Результат = СписокПолей;
	КонецЕсли; 
	Возврат Результат;
	
КонецФункции

Функция ПолучитьXMLКлючОбъектаБДЛкс(Знач ОбъектДанных, Знач ИспользоватьСсылкуДляСсылочных = Ложь) Экспорт
	
	Если ОбъектДанных = Неопределено Тогда
		Результат = "Неопределено";
		Возврат Результат;
	КонецЕсли;
	ПредставлениеОбъекта = "";
	Если ТипЗнч(ОбъектДанных) = Тип("УдалениеОбъекта") Тогда
		Класс = "Удаление";
	Иначе
		Попытка
			ЭтоНовый = ОбъектДанных.ЭтоНовый();
			Класс = "Ссылочный";
			ПредставлениеОбъекта = "" + ОбъектДанных + ",";
		Исключение
			Попытка
				УникальныйИдентификатор = ОбъектДанных.УникальныйИдентификатор();
				Класс = "Ссылочный";
			Исключение
				Попытка
					Пустышка = ОбъектДанных.Модифицированность();
					Класс = "НаборЗаписей";
				Исключение
					Попытка
						Пустышка = ОбъектДанных.Значение;
						Класс = "Константы";
					Исключение
						Класс = "Примитив";
					КонецПопытки;
				КонецПопытки;
			КонецПопытки;
		КонецПопытки;
		Если Истина
			И Класс = "Ссылочный"
			И ИспользоватьСсылкуДляСсылочных
		Тогда
			Результат = ОбъектДанных;
			Возврат Результат;
		КонецЕсли;
	КонецЕсли; 
	XMLКлюч = "" + XMLТипЗнч(ОбъектДанных).ИмяТипа + "(";
	Если Класс = "Ссылочный" Тогда
		Если ЭтоНовый = Истина Тогда
			УникальныйИдентификатор = "!" + ОбъектДанных.ПолучитьСсылкуНового().УникальныйИдентификатор();
		КонецЕсли;
		Если УникальныйИдентификатор = Неопределено Тогда
			УникальныйИдентификатор = ОбъектДанных.Ссылка.УникальныйИдентификатор();
		КонецЕсли; 
		XMLКлюч = XMLКлюч + ПредставлениеОбъекта + УникальныйИдентификатор;
	ИначеЕсли Класс = "Удаление" Тогда
		XMLКлюч = XMLКлюч + ПолучитьXMLКлючОбъектаБДЛкс(ОбъектДанных.Ссылка);
	ИначеЕсли Класс = "НаборЗаписей" Тогда
		ПредставлениеОтбора = "";
		Разделитель = ", ";
		Для Каждого ЭлементОтбора Из ОбъектДанных.Отбор Цикл
			Если ЭлементОтбора.Использование Тогда
				ПредставлениеОтбора = ПредставлениеОтбора + Разделитель + ЭлементОтбора.Имя 
					+ ":" + ПолучитьXMLКлючОбъектаБДЛкс(ЭлементОтбора.Значение);
			КонецЕсли;
		КонецЦикла;
		XMLКлюч = XMLКлюч + Сред(ПредставлениеОтбора, СтрДлина(Разделитель) + 1);
	ИначеЕсли Класс = "Константы" Тогда
		//
	Иначе
		// Примитивный тип
		XMLКлюч = XMLКлюч + ОбъектДанных;
	КонецЕсли;
	XMLКлюч = XMLКлюч + ")";
	Результат = XMLКлюч;
	Возврат Результат;
	
КонецФункции

Функция ПолучитьТабличныеЧастиОбъектаЛкс(Объект) Экспорт
	
	Если ТипЗнч(Объект) = Тип("ОбъектМетаданных") Тогда
		мдОбъекта = Объект;
		ОбъектБД = Неопределено;
	Иначе
		мдОбъекта = Объект.Метаданные();
		ОбъектБД = Объект;
	КонецЕсли; 
	СтруктураТЧ = Новый Структура();
	ЭтоСправочник = Метаданные.Справочники.Индекс(мдОбъекта) >= 0;
	Для Каждого МетаТЧ из мдОбъекта.ТабличныеЧасти Цикл
		// Для реквизитов справочников, принадлежащих только группе или только элементу нужно игнорировать те объекты, для которых эти реквизиты не используются
		Если Истина
			И ЭтоСправочник 
			И ОбъектБД <> Неопределено
		Тогда
			Если Ложь
				Или (Истина
					И ОбъектБД.ЭтоГруппа 
					И МетаТЧ.Использование = Метаданные.СвойстваОбъектов.ИспользованиеРеквизита.ДляЭлемента)
				Или (Истина
					И Не ОбъектБД.ЭтоГруппа
					И МетаТЧ.Использование = Метаданные.СвойстваОбъектов.ИспользованиеРеквизита.ДляГруппы) 
			Тогда
				Продолжить
			КонецЕсли;
		КонецЕсли;
		СтруктураТЧ.Вставить(МетаТЧ.Имя, МетаТЧ.Представление());
	КонецЦикла; 
	Если Метаданные.ПланыСчетов.Индекс(мдОбъекта) >= 0 Тогда
		Если мдОбъекта.ВидыСубконто <> Неопределено Тогда
			СтруктураТЧ.Вставить("ВидыСубконто", "Виды субконто");
		КонецЕсли; 
	КонецЕсли;
	Если Метаданные.ПланыВидовРасчета.Индекс(мдОбъекта) >= 0 Тогда
		Если мдОбъекта.ЗависимостьОтВидовРасчета <> Метаданные.СвойстваОбъектов.ИспользованиеБазыПланаВидовРасчета.НеИспользовать Тогда
			СтруктураТЧ.Вставить("БазовыеВидыРасчета", "Базовые виды расчета");
		КонецЕсли; 
		СтруктураТЧ.Вставить("ВедущиеВидыРасчета", "Ведущие виды расчета");
		Если мдОбъекта.ИспользованиеПериодаДействия Тогда
			СтруктураТЧ.Вставить("ВытесняющиеВидыРасчета", "Вытесняющие виды расчета");
		КонецЕсли; 
	КонецЕсли;
	Возврат СтруктураТЧ;
	
КонецФункции

Функция ЛиСтрокаСодержитВсеПодстрокиЛкс(Знач Строка, Знач Подстроки) Экспорт 
	
	Если ТипЗнч(Подстроки) = Тип("Строка") Тогда
		Подстроки = ЛксПолучитьМассивИзСтрокиСРазделителем(НРег(Подстроки), " ", Истина);
	КонецЕсли; 
	НСтрока = НРег(Строка);
	Для Каждого Фрагмент Из Подстроки Цикл
		Если Найти(НСтрока, Фрагмент) = 0 Тогда
			Возврат Ложь;
		КонецЕсли; 
	КонецЦикла;
	Возврат Истина;
	
КонецФункции

Функция ПолучитьСтрокуТаблицыБДПоКлючуЛкс(ПолноеИмяТаблицы, СтруктураКлюча) Экспорт 
	
	Запрос = Новый Запрос;
	ТекстЗапроса = "ВЫБРАТЬ Т.* ИЗ " + ПолноеИмяТаблицы + " КАК Т ГДЕ ИСТИНА ";
	Для Каждого КлючИЗначение Из СтруктураКлюча Цикл
		ТекстЗапроса = ТекстЗапроса + " И Т." + КлючИЗначение.Ключ + " = &" + КлючИЗначение.Ключ;
	КонецЦикла; 
	ЛксСкопироватьУниверсальнуюКоллекцию(СтруктураКлюча, Запрос.Параметры);
	Запрос.Текст = ТекстЗапроса;
	СтрокаРезультата = Запрос.Выполнить().Выгрузить()[0];
	Возврат СтрокаРезультата;
	
КонецФункции

Функция ПолучитьТипТаблицыБДЛкс(ПолноеИмяТаблицыБД) Экспорт

	МассивФрагментов = ЛксПолучитьМассивИзСтрокиСРазделителем(ПолноеИмяТаблицыБД);
	ТипТаблицы = МассивФрагментов[0];
	Если МассивФрагментов.Количество() > 2 Тогда
		//ТипТаблицы = МассивФрагментов[2];
		////Если МассивФрагментов[2] = "Изменения" Тогда
		////	ТипТаблицы = МассивФрагментов[2];
		////Иначе
		////	Если ЛксЛиКорневойТипОбъектаБД(МассивФрагментов[0]) Тогда
		////		//ТипТаблицы = "ТабличнаяЧасть";
		////		ТипТаблицы = МассивФрагментов[2];
		////	КонецЕсли; 
		////КонецЕсли; 
		ОбъектМД = НайтиОбъектМетаДанныхПоПолномуИмениТаблицыБДЛкс(ПолноеИмяТаблицыБД);
		Если ЛксЛиКорневойТипОбъектаБД(МассивФрагментов[0]) Тогда
			Если ОбъектМД = Неопределено Тогда
				ТипТаблицы = МассивФрагментов[2];
			Иначе
				ТипТаблицы = "ТабличнаяЧасть";
			КонецЕсли; 
		//ИначеЕсли ирНеглобальный.СтрокиРавныЛкс(МассивФрагментов[2], "ДвиженияССубконто") Тогда
		//	ТипТаблицы = МассивФрагментов[0];
		Иначе
			ТипТаблицы = "ВиртуальнаяТаблица";
		КонецЕсли; 
	КонецЕсли;
	Возврат ТипТаблицы;

КонецФункции

// Присваивает ячейке по указателю значение. Если после этого ячейка получает другое значение, то ячейке присваивается ее старое значение. 
Функция БезопасноПрисвоитьПроизвольнуюСсылкуЛкс(П1, П2) Экспорт

	СтароеП1 = П1;
	П1 = П2;
	Если П1 <> П2 Тогда
		П1 = СтароеП1;
		Возврат Ложь;
	КонецЕсли; 
	Возврат Истина;

КонецФункции // БезопасноПрисвоитьПроизвольнуюСсылку()

// Ищет все экземпляры значения ЧтоЗаменять в объекте и заменяет их на НаЧтоЗаменять 
Функция ЗаменитьЗначениеВОбъектеБДЛкс(Объект, ЧтоЗаменять, НаЧтоЗаменять) Экспорт

	ОбъектМД = Объект.Метаданные();
	Компоновщик = ирКэш.ПолучитьКомпоновщикТаблицыМетаданныхЛкс(ОбъектМД.ПолноеИмя());
	#Если _ Тогда
	    Компоновщик = Новый КомпоновщикНастроекКомпоновкиДанных;
	#КонецЕсли
	ОбъектИзменен = Ложь;
	Для Каждого ДоступноеПоле Из Компоновщик.Настройки.ДоступныеПоляВыбора.Элементы Цикл
		Если ДоступноеПоле.Папка Тогда
			Попытка
				ТабличнаяЧасть = Объект["" + ДоступноеПоле.Поле];
			Исключение
				// Сюда например попадаем в случае системной папки СистемныеПоля
				ТабличнаяЧасть = Неопределено;
			КонецПопытки; 
			Если ТабличнаяЧасть <> Неопределено Тогда
				Для Каждого ПолеРеквизита Из ДоступноеПоле.Элементы Цикл
					ИмяРеквизита = "" + ЛксПолучитьПоследнийФрагмент(ПолеРеквизита.Поле);
					Если ирНеглобальный.СтрокиРавныЛкс(ИмяРеквизита, "Ссылка") Тогда
						Продолжить;
					КонецЕсли; 
					Если ПолеРеквизита.Тип.СодержитТип(ТипЗнч(ЧтоЗаменять)) Тогда
						СтрокиТабЧасти = ТабличнаяЧасть.НайтиСтроки(Новый Структура(ИмяРеквизита, ЧтоЗаменять));
						Для Каждого СтрокаТабЧасти Из СтрокиТабЧасти Цикл
							ОбъектИзменен = БезопасноПрисвоитьПроизвольнуюСсылкуЛкс(СтрокаТабЧасти[ИмяРеквизита], НаЧтоЗаменять) Или ОбъектИзменен;
						КонецЦикла; 
					КонецЕсли;
				КонецЦикла;
			КонецЕсли; 
		Иначе
			ИмяРеквизита = "" + ДоступноеПоле.Поле;
			Если ирНеглобальный.СтрокиРавныЛкс(ИмяРеквизита, "Ссылка") Тогда
				Продолжить;
			КонецЕсли; 
			Если ДоступноеПоле.Тип.СодержитТип(ТипЗнч(ЧтоЗаменять)) И Объект[ИмяРеквизита] = ЧтоЗаменять Тогда
				ОбъектИзменен = БезопасноПрисвоитьПроизвольнуюСсылкуЛкс(Объект[ИмяРеквизита], НаЧтоЗаменять) Или ОбъектИзменен;
			КонецЕсли;
		КонецЕсли; 
	КонецЦикла;
	Возврат ОбъектИзменен;

КонецФункции // ВыполнитьЗаменуЗначенияВОбъектеБДЛкс()


// ЛиНаходитьОбразующий - Булево - находить ближайший объект метаданных, если точный найти не удается
Функция НайтиОбъектМетаДанныхПоПолномуИмениТаблицыБДЛкс(ПолноеИмяТаблицыБД, ЛиНаходитьОбразующий = Ложь) Экспорт
	
	Результат = Неопределено;
	Если Не ПустаяСтрока(ПолноеИмяТаблицыБД) Тогда
		Фрагменты = ЛксПолучитьМассивИзСтрокиСРазделителем(ПолноеИмяТаблицыБД);
		ОбразующийМД = Метаданные.НайтиПоПолномуИмени(Фрагменты[0] + "." + Фрагменты[1]);
		Если Ложь
			Или ОбразующийМД = Неопределено
			Или Фрагменты.Количество() = 2 
		Тогда
			Результат = ОбразующийМД;
		Иначе
			Если ЛксЛиКорневойТипОбъектаБД(Фрагменты[0]) Тогда
				Если Фрагменты.Количество() = 3 Тогда
					МетаТЧ = ОбразующийМД.ТабличныеЧасти.Найти(Фрагменты[2]);
					Если МетаТЧ <> Неопределено Тогда
						Результат = МетаТЧ;
					ИначеЕсли ЛиНаходитьОбразующий Тогда
						// ВидыСубконто, Изменения
						Результат = ОбразующийМД;
					КонецЕсли; 
				КонецЕсли; 
			КонецЕсли; 
		КонецЕсли; 
	КонецЕсли;
	Возврат Результат;
	
КонецФункции // ЛксПолучитьМетаданные()

Функция ПолучитьТекстЗапросаПоВыбраннымМетаданнымЛкс(МассивПолныхИменМД, ЛиТаблицыИзменения = Ложь) Экспорт
	
	ЛитералЗаменыОтсутствующихПолей = "НЕОПРЕДЕЛЕНО"; // NULL нельзя использовать из-за ошибок платформы 8.2.14
	
	// Сначала определим общие реквизиты
	ТипыТаблицБД = Новый Структура;
	Для Каждого ПолноеИмяМетаданных Из МассивПолныхИменМД Цикл
		ТипТаблицы = ирНеглобальный.ПолучитьТипТаблицыБДЛкс(ПолноеИмяМетаданных);
		ТипыТаблицБД.Вставить(ТипТаблицы);
	КонецЦикла; 
	ПроверяемыеПоля = Новый Массив;
	Если ТипыТаблицБД.Количество() = 1 Тогда
		ирКэш.Получить().ИнициализацияОписанияМетодовИСвойств();
		СтрокаКорневогоТипа = ирКэш.Получить().ПолучитьСтрокуТипаМетаОбъектов(ТипТаблицы);
		Если СтрокаКорневогоТипа <> Неопределено Тогда
			СтрокаВида = ирКэш.Получить().ТаблицаИменЭлементовКоллекций.Найти(СтрокаКорневогоТипа.Множественное, "ИмяКоллекции");
			Если СтрокаВида <> Неопределено Тогда
				ИмяОбщегоТипа = ТипТаблицы + "." + СтрокаВида.ИмяЭлементаКоллекции;
				СтрокиИменПолей = ирКэш.Получить().ТаблицаКонтекстов.НайтиСтроки(Новый Структура("ТипКонтекста, ЯзыкПрограммы", ИмяОбщегоТипа, 1));
				Для Каждого СтрокаСлова Из СтрокиИменПолей Цикл
					Если Ложь
						Или СтрокаСлова.ТипСлова = "Таблица"
					Тогда
						Продолжить;
					КонецЕсли; 
					ПроверяемыеПоля.Добавить(СтрокаСлова.Слово);
				КонецЦикла;
			КонецЕсли; 
		КонецЕсли; 
	КонецЕсли; 
	Текст = "";
	
	// Находим максимум общих реквизитов, определенных в метаданных
	ОбщиеМетаПоля = Новый Массив;
	ЭтоПервыйПроход = Истина;
	Для Каждого ПолноеИмяМетаданных Из МассивПолныхИменМД Цикл
		ОбъектМетаданных = Метаданные.НайтиПоПолномуИмени(ПолноеИмяМетаданных);
		
		КоллекцияПолей = Новый Массив();
		КомпоновщикТаблицы = ирКэш.ПолучитьКомпоновщикТаблицыМетаданныхЛкс(ПолноеИмяМетаданных);
		Для Каждого ДоступноеПоле Из КомпоновщикТаблицы.Настройки.ДоступныеПоляВыбора.Элементы Цикл
			Если ДоступноеПоле.Папка Тогда
				Продолжить;
			КонецЕсли;
			ИмяПоля = "" + ДоступноеПоле.Поле;
			Если Ложь
				Или ПроверяемыеПоля.Найти(ИмяПоля) <> Неопределено
			Тогда
				Продолжить;
			КонецЕсли; 
			КоллекцияПолей.Добавить(ИмяПоля);
		КонецЦикла; 

		Если ЭтоПервыйПроход Тогда
			Для Каждого ИмяПоля Из КоллекцияПолей Цикл
				ОбщиеМетаПоля.Добавить(ИмяПоля);
			КонецЦикла;
		Иначе
			НачальноеКоличество = ОбщиеМетаПоля.Количество(); 
			Для СчетчикОбщиеМетаПоля = 1 По НачальноеКоличество Цикл
				ИмяПоля = ОбщиеМетаПоля[НачальноеКоличество - СчетчикОбщиеМетаПоля];
				Если КоллекцияПолей.Найти(ИмяПоля) = Неопределено Тогда
					ОбщиеМетаПоля.Удалить(НачальноеКоличество - СчетчикОбщиеМетаПоля);
				КонецЕсли;
			КонецЦикла;
			Если ОбщиеМетаПоля.Количество() = 0 Тогда
				Прервать;
			КонецЕсли; 
		КонецЕсли; 
		ЭтоПервыйПроход = Ложь;
	КонецЦикла;
	ТекстОбщихМетаПолей = "";
	Для Каждого ИмяПоля Из ОбщиеМетаПоля Цикл
		Если ЛиТаблицыИзменения Тогда
			ИмяПоля = "Ссылка." + ИмяПоля;
		КонецЕсли; 
		ТекстОбщихМетаПолей = ТекстОбщихМетаПолей + ", Т." + ИмяПоля;
	КонецЦикла; 
	
	#Если Клиент Тогда
		Индикатор = ЛксПолучитьИндикаторПроцесса(МассивПолныхИменМД.Количество(), "Генерация текста запроса");
	#КонецЕсли
	Для Каждого ПолноеИмяМетаданных Из МассивПолныхИменМД Цикл
		#Если Клиент Тогда
			ЛксОбработатьИндикатор(Индикатор);
		#КонецЕсли
		ИмяТаблицы = ПолноеИмяМетаданных;
		Если ЛиТаблицыИзменения Тогда
			ЕстьТаблицаИзменений = ЕстьТаблицаИзмененийОбъектаМетаданных(ПолноеИмяМетаданных);
			Если ЕстьТаблицаИзменений Тогда
				ИмяТаблицы = ИмяТаблицы + ".Изменения";
			Иначе
				Продолжить;
			КонецЕсли;
		Иначе
			ТекстНеобязательныхПолей = "";
			КомпоновщикТаблицы = ирКэш.ПолучитьКомпоновщикТаблицыМетаданныхЛкс(ПолноеИмяМетаданных);
			ПоляТаблицы = КомпоновщикТаблицы.Настройки.ДоступныеПоляВыбора.Элементы;
			Для Каждого ПроверяемоеПоле Из ПроверяемыеПоля Цикл
				Если ПоляТаблицы.Найти(ПроверяемоеПоле) = Неопределено Тогда
					ТекстНеобязательныхПолей = ТекстНеобязательныхПолей + ", " + ЛитералЗаменыОтсутствующихПолей + " КАК " + ПроверяемоеПоле;
				Иначе
					ТекстНеобязательныхПолей = ТекстНеобязательныхПолей + ", Т." + ПроверяемоеПоле;
				КонецЕсли; 
			КонецЦикла; 
		КонецЕсли; 
		Если Текст <> "" Тогда
			Текст = Текст + " 
			|ОБЪЕДИНИТЬ ВСЕ
			|";
		КонецЕсли;
		Текст = Текст + "ВЫБРАТЬ """ + ПолноеИмяМетаданных + """ КАК _ПолноеИмяТаблицы" + ТекстНеобязательныхПолей + ТекстОбщихМетаПолей + " ИЗ " + ИмяТаблицы + " КАК Т";
	КонецЦикла;
	Возврат Текст;
	
КонецФункции

Функция ЕстьТаблицаИзмененийОбъектаМетаданных(ПолноеИмяИлиОбъектМетаданных) Экспорт

	ЕстьТаблицаИзменений = Ложь;
	Если ТипЗнч(ПолноеИмяИлиОбъектМетаданных) = Тип("Строка") Тогда
		ОбъектМетаданных = Метаданные.НайтиПоПолномуИмени(ПолноеИмяИлиОбъектМетаданных);
	Иначе
		ОбъектМетаданных = ПолноеИмяИлиОбъектМетаданных;
	КонецЕсли; 
	Для Каждого МетаПланОбмена Из Метаданные.ПланыОбмена Цикл
		Если МетаПланОбмена.Состав.Содержит(ОбъектМетаданных) Тогда
			ЕстьТаблицаИзменений = Истина;
			Прервать;
		КонецЕсли; 
	КонецЦикла; 
	Возврат ЕстьТаблицаИзменений;

КонецФункции

Функция СериализоватьДополнительныеСвойстваОбъектаЛкс(Объект) Экспорт 

	Структура = Новый Структура;
	Попытка
		ОбменДанными = Объект.ОбменДанными;
	Исключение
	КонецПопытки; 
	Если ОбменДанными <> Неопределено Тогда
		Узлы = Новый Массив;
		Для Каждого Получатель Из ОбменДанными.Получатели Цикл
			Узлы.Добавить(Получатель);
		КонецЦикла; 
		Получатели = Новый Структура;
		Получатели.Вставить("Автозаполнение", ОбменДанными.Получатели.Автозаполнение);
		Получатели.Вставить("Узлы", Узлы);
		СтруктураОбменаДанными = Новый Структура;
		СтруктураОбменаДанными.Вставить("Загрузка", ОбменДанными.Загрузка); 
		СтруктураОбменаДанными.Вставить("Отправитель", ОбменДанными.Отправитель); 
		СтруктураОбменаДанными.Вставить("Получатели", Получатели);
		Структура.Вставить("ОбменДанными", СтруктураОбменаДанными);
	КонецЕсли; 
	Структура.Вставить("ДополнительныеСвойства", Объект.ДополнительныеСвойства);
	Возврат Структура;

КонецФункции // СериализоватьПараметрыОбменаДанными()
 
Процедура ВосстановитьДополнительныеСвойстваОбъектаЛкс(Объект, СтруктураДополнительныхСвойств) Экспорт 

	Если СтруктураДополнительныхСвойств.Свойство("ОбменДанными") Тогда
		ОбменДанными = Объект.ОбменДанными;
		СтруктураОбменаДанными = СтруктураДополнительныхСвойств.ОбменДанными;
		ЗаполнитьЗначенияСвойств(ОбменДанными, СтруктураОбменаДанными); 
		ЗаполнитьЗначенияСвойств(ОбменДанными.Получатели, ОбменДанными.Получатели);
		ОбменДанными.Получатели.Очистить();
		Для Каждого Получатель Из СтруктураОбменаДанными.Получатели.Узлы Цикл
			ОбменДанными.Получатели.Добавить(Получатель);
		КонецЦикла; 
	КонецЕсли; 
	ЛксСкопироватьУниверсальнуюКоллекцию(СтруктураДополнительныхСвойств.ДополнительныеСвойства, Объект.ДополнительныеСвойства);

КонецПроцедуры // ВосстановитьПараметрыОбменаДаннымиЛкс()
 
Процедура ЗаписатьОбъектЛкс(Объект, НаСервере = Ложь, РежимЗаписи = Неопределено) Экспорт 
	
	Если НаСервере Тогда
		ДополнительныеСвойства = СериализоватьДополнительныеСвойстваОбъектаЛкс(Объект);
		ХМЛ = СохранитьОбъектВВидеСтрокиXMLЛкс(Объект);
		ирСервер.ЗаписатьОбъектЛкс(ХМЛ, ДополнительныеСвойства, РежимЗаписи);
	Иначе
		Если РежимЗаписи = Неопределено Тогда
			Объект.Записать();
		Иначе
			Объект.Записать(РежимЗаписи);
		КонецЕсли; 
	КонецЕсли; 
	
КонецПроцедуры

Процедура УдалитьОбъектЛкс(Объект, НаСервере = Ложь) Экспорт 
	
	Если НаСервере Тогда
		ДополнительныеСвойства = СериализоватьДополнительныеСвойстваОбъектаЛкс(Объект);
		ХМЛ = СохранитьОбъектВВидеСтрокиXMLЛкс(Объект);
		ирСервер.УдалитьОбъектЛкс(ХМЛ, ДополнительныеСвойства);
	Иначе
		Объект.Удалить();
	КонецЕсли; 
	
КонецПроцедуры

Процедура УстановитьПометкуУдаленияОбъектаЛкс(Объект, НаСервере = Ложь, ЗначениеПометки = Истина) Экспорт 
	
	Если НаСервере Тогда
		ДополнительныеСвойства = СериализоватьДополнительныеСвойстваОбъектаЛкс(Объект);
		ХМЛ = СохранитьОбъектВВидеСтрокиXMLЛкс(Объект);
		ирСервер.УстановитьПометкуУдаленияОбъектаЛкс(ХМЛ, ДополнительныеСвойства, ЗначениеПометки);
	Иначе
		//Если РежимЗаписи = Неопределено Тогда
		//	Объект.УстановитьПометкуУдаления(ЗначениеПометки);
		//Иначе
			Объект.УстановитьПометкуУдаления(ЗначениеПометки);
		//КонецЕсли; 
	КонецЕсли; 
	
КонецПроцедуры

// Источник - http://infostart.ru/public/125988/
Функция ВыбратьПоГруппировкамЛкс(Выборка, Группировки, СИерархией = Ложь) Экспорт

	МетаВыборка = Новый Соответствие;
	
	врОбходРезультата = ОбходРезультатаЗапроса.ПоГруппировкам;
	Если СИерархией Тогда
		врОбходРезультата = ОбходРезультатаЗапроса.ПоГруппировкамСИерархией;
	КонецЕсли;
	МетаВыборка.Вставить("ОбходРезультата", врОбходРезультата);
	
	МассивГруппировок = Новый Массив;
	врСтрГруппировки = Группировки;
	Пока Истина Цикл
		Поз = Найти( врСтрГруппировки, "," );
		Если Поз = 0 Тогда
			МассивГруппировок.Добавить(СокрЛП(врСтрГруппировки));
			Прервать;
		КонецЕсли;
		МассивГруппировок.Добавить( СокрЛП( Лев(врСтрГруппировки,Поз-1) ) );
		врСтрГруппировки = Сред( врСтрГруппировки, Поз+1 );
	КонецЦикла;
	
	МетаВыборка.Вставить("Группировки", МассивГруппировок);
	
	врВыборка = Выборка;
	Для пц=0 По МассивГруппировок.Количество()-2 Цикл
		врВыборкаУровня = врВыборка.Выбрать(врОбходРезультата, МассивГруппировок[пц]);
		МетаВыборка.Вставить("_Выборка"+Строка(пц), врВыборкаУровня);
		Если не врВыборкаУровня.Следующий() Тогда
			Прервать;
		КонецЕсли;
		врВыборка = врВыборкаУровня;
	КонецЦикла;
	врВыборкаУровня = врВыборка.Выбрать(врОбходРезультата, МассивГруппировок[пц]);
	МетаВыборка.Вставить("Выборка", врВыборкаУровня);
	МетаВыборка.Вставить("_Выборка"+Строка(пц), врВыборкаУровня);
	
	Возврат МетаВыборка;

КонецФункции // ВыбратьПоГруппировкамЛкс

// Источник - http://infostart.ru/public/125988/
Функция СледующийПоГруппировкамЛкс(МетаВыборка, Уровень = Неопределено) Экспорт

	Если Уровень = Неопределено Тогда
		Уровень = МетаВыборка["Группировки"].Количество()-1;
	КонецЕсли;
	
	Если Уровень < 0 Тогда
		Возврат Ложь;
	КонецЕсли;
	
	врВыборка = МетаВыборка["_Выборка"+Строка(Уровень)];
	
	Если врВыборка.Следующий() Тогда
		Возврат Истина;
	КонецЕсли;
	
	Если СледующийПоГруппировкамЛкс(МетаВыборка, Уровень-1) Тогда
		МассивГруппировок = МетаВыборка["Группировки"];
		врВыборкаРодитель = МетаВыборка["_Выборка"+Строка(Уровень-1)];
		врВыборка = врВыборкаРодитель.Выбрать(МетаВыборка["ОбходРезультата"],МассивГруппировок[Уровень]);
		МетаВыборка["_Выборка"+Строка(Уровень)] = врВыборка;
		Если Уровень = МассивГруппировок.Количество()-1 Тогда
			МетаВыборка["Выборка"] = врВыборка;
		КонецЕсли;
		Возврат СледующийПоГруппировкамЛкс(МетаВыборка, Уровень);
	Иначе
		Возврат Ложь;
	КонецЕсли;

КонецФункции // зфСледующийПоГруппировкам

// ИспользоватьОбщийКаталогНастроек - использовать значение ключа ConfLocation из файла conf.cfg
Функция ПолучитьКаталогНастроекПриложения1СЛкс(ИспользоватьОбщийКаталогНастроек = Истина, СоздатьЕслиОтсутствует = Ложь, НаСервере = Ложь) Экспорт
	
	Если НаСервере Тогда
		Результат = ирСервер.ПолучитьКаталогНастроекПриложения1СЛкс(ИспользоватьОбщийКаталогНастроек, СоздатьЕслиОтсутствует);
	Иначе
		КаталогКонфигурацииПриложения = КаталогПрограммы() + "conf";
		Если ИспользоватьОбщийКаталогНастроек Тогда
			ФайлУказатель = Новый Файл(КаталогКонфигурацииПриложения + "\conf.cfg");
			Если ФайлУказатель.Существует() Тогда
				ТекстовыйДокумент = Новый ТекстовыйДокумент;
				ТекстовыйДокумент.Прочитать(ФайлУказатель.ПолноеИмя);
				Текст = ТекстовыйДокумент.ПолучитьТекст();
				НовыйКаталогКонфигурацииПриложения = ЛксПолучитьСтрокуМеждуМаркерами(Текст, "ConfLocation=", Символы.ПС);
				НовыйКаталог = Новый Файл(НовыйКаталогКонфигурацииПриложения);
				Если НовыйКаталог.Существует() Тогда
					КаталогКонфигурацииПриложения = НовыйКаталогКонфигурацииПриложения;
				КонецЕсли;
			КонецЕсли;
		КонецЕсли;
		Если СоздатьЕслиОтсутствует Тогда
			Файл = Новый Файл(КаталогКонфигурацииПриложения);
			Если Не Файл.Существует() Тогда
				СоздатьКаталог(КаталогКонфигурацииПриложения);
			КонецЕсли; 
		КонецЕсли; 
		Результат = КаталогКонфигурацииПриложения;
	КонецЕсли; 
	Возврат Результат;
	
КонецФункции

Функция ПолучитьИмяФайлаАктивнойНастройкиТехноЖурналаЛкс(НаСервере = Ложь) Экспорт
	
	Если НаСервере Тогда
		Результат = ирСервер.ПолучитьИмяФайлаАктивнойНастройкиТехноЖурналаЛкс();
	Иначе
		КаталогКонфигурацииПриложения = ПолучитьКаталогНастроекПриложения1СЛкс(Ложь);
		Результат = КаталогКонфигурацииПриложения + "\logcfg.xml";
		Файл = Новый Файл(Результат);
		Если Файл.Существует() Тогда
			Возврат Результат;
		КонецЕсли; 
		КаталогКонфигурацииПриложения = ПолучитьКаталогНастроекПриложения1СЛкс(Истина);
		Результат = КаталогКонфигурацииПриложения + "\logcfg.xml";
		Файл = Новый Файл(Результат);
		Если Файл.Существует() Тогда
			Возврат Результат;
		КонецЕсли;
		Результат = Неопределено;
	КонецЕсли; 
	Возврат Результат;
	
КонецФункции

Функция ПолучитьКаталогТехножурналаЛкс(НаСервере = Ложь) Экспорт

	ИмяФайлаНастроекЖурнала = ирНеглобальный.ПолучитьИмяФайлаАктивнойНастройкиТехноЖурналаЛкс(НаСервере);
	Если ЗначениеЗаполнено(ИмяФайлаНастроекЖурнала) Тогда
		ТекстХМЛ = ПрочитатьТекстИзФайлаЛкс(ИмяФайлаНастроекЖурнала, , НаСервере);
		ЧтениеХМЛ = Новый ЧтениеXML;
		ЧтениеХМЛ.УстановитьСтроку(ТекстХМЛ);
		ПостроительДом = Новый ПостроительDOM();
		Попытка
			ДокументДОМ = ПостроительДом.Прочитать(ЧтениеХМЛ);
		Исключение
			Сообщить("Ошибка чтения настройки техножурнала: " + ОписаниеОшибки(), СтатусСообщения.Внимание);
		КонецПопытки;
		Если ДокументДОМ <> Неопределено Тогда
			Узлы = ДокументДом.ПолучитьЭлементыПоИмени("log");
			Если Узлы.Количество() > 0 Тогда
				Атрибут = Узлы.Элемент(0).Атрибуты.ПолучитьИменованныйЭлемент("location");
				Если Атрибут <> Неопределено Тогда
					Результат = Атрибут.ТекстовоеСодержимое;
				КонецЕсли; 
			КонецЕсли;
		КонецЕсли; 
	КонецЕсли; 
	Возврат Результат;

КонецФункции

Функция ЛиТехножурналВключенЛкс(НаСервере = Ложь, ВыводитьСообщения = Ложь) Экспорт

	//ИмяФайлаАктивнойНастройки = ирНеглобальный.ПолучитьИмяФайлаАктивнойНастройкиТехноЖурналаЛкс(НаСервере);
	//ТехножурналВключен = ЗначениеЗаполнено(ИмяФайлаАктивнойНастройки);
	КаталогЖурнала = ПолучитьКаталогТехножурналаЛкс(НаСервере);
	Если ЗначениеЗаполнено(КаталогЖурнала) Тогда
		Если Не ЛиКаталогТехножурналаСодержитБлокирующиеФайлыЛкс(КаталогЖурнала, НаСервере, ВыводитьСообщения) Тогда
			Возврат Истина;
		КонецЕсли;
	КонецЕсли; 
	Если ВыводитьСообщения Тогда
		Если НаСервере Тогда
			Сообщить("Техножурнал на сервере не включен", СтатусСообщения.Внимание);
		Иначе
			Сообщить("Техножурнал на клиенте не включен", СтатусСообщения.Внимание);
		КонецЕсли; 
	КонецЕсли; 
	Возврат Ложь;

КонецФункции

Функция ЛиКаталогТехножурналаСодержитБлокирующиеФайлыЛкс(КаталогЖурнала, НаСервере = Ложь, ВыводитьСообщения = Истина) Экспорт

	Если НаСервере Тогда
		Результат = ирСервер.ЛиКаталогТехножурналаСодержитБлокирующиеФайлыЛкс(КаталогЖурнала);
	Иначе
		Результат = Ложь;
		БлокирующиеФайлы = НайтиФайлы(КаталогЖурнала, "*.*");
		Для Каждого БлокирующийФайл Из БлокирующиеФайлы Цикл
			Если Не БлокирующийФайл.ЭтоКаталог() Тогда
				Если ВыводитьСообщения Тогда
					ТекстСообщения = "В корне каталога """ + КаталогЖурнала + """ техножурнала ";
					Если НаСервере Тогда
						ТекстСообщения = ТекстСообщения + "сервера";
					Иначе
						ТекстСообщения = ТекстСообщения + "клиента";
					КонецЕсли; 
					Сообщить(ТекстСообщения + " обнаружены блокирующие файлы. Для работы журнала их необходимо удалить.",
						СтатусСообщения.Внимание);
				КонецЕсли; 
				Результат = Истина;
				Прервать;
			КонецЕсли;
		КонецЦикла;
	КонецЕсли; 
	Возврат Результат;

КонецФункции

Функция ЛиКлиентЗапущенНаКомпьютереСервераЛкс() Экспорт 
	
	Результат = НРег(ирСервер.ПолучитьИмяКомпьютераЛкс()) = НРег(ИмяКомпьютера());
	Возврат Результат;
	
КонецФункции

Функция ЗаписатьТекстВФайлЛкс(ПолноеИмяФайла, Текст, Кодировка = Неопределено, НаСервере = Ложь) Экспорт
	
	Если НаСервере Тогда
		ирСервер.ЗаписатьТекстВФайлЛкс(ПолноеИмяФайла, Текст, Кодировка);
	Иначе
		ТекстовыйДокумент = Новый ТекстовыйДокумент;
		ТекстовыйДокумент.УстановитьТекст(Текст);
		ТекстовыйДокумент.Записать(ПолноеИмяФайла, Кодировка);
	КонецЕсли; 
	
КонецФункции

Функция ПрочитатьТекстИзФайлаЛкс(ПолноеИмяФайла, Кодировка = Неопределено, НаСервере = Ложь) Экспорт
	
	Если НаСервере Тогда
		Результат = ирСервер.ПрочитатьТекстИзФайлаЛкс(ПолноеИмяФайла, Кодировка);
	Иначе
		ТекстовыйДокумент = Новый ТекстовыйДокумент;
		ТекстовыйДокумент.Прочитать(ПолноеИмяФайла, Кодировка);
		Результат = ТекстовыйДокумент.ПолучитьТекст();
	КонецЕсли; 
	Возврат Результат;
	
КонецФункции

Функция НайтиИменаФайловЛкс(Путь, Маска = Неопределено, ИскатьВПодкаталогах = Истина, НаСервере = Ложь) Экспорт
	
	Если НаСервере Тогда
		Результат = ирСервер.НайтиИменаФайловЛкс(Путь, Маска, ИскатьВПодкаталогах);
	Иначе
		Файлы = НайтиФайлы(Путь, Маска, ИскатьВПодкаталогах);
		Результат = Новый Массив;
		Для Каждого Файл Из Файлы Цикл
			Результат.Добавить(Файл.ПолноеИмя);
		КонецЦикла; 
	КонецЕсли; 
	Возврат Результат;
	
КонецФункции

// Параметры:
//   ВерсияПлатформы - Строка(0,П)
//
Функция ПолучитьКаталогПустойИнфобазыЛкс(Знач ВерсияПлатформы = "") Экспорт
	
	Если Не ЗначениеЗаполнено(ВерсияПлатформы) Тогда
		ВерсияПлатформы = ирКэш.Получить().ИДВерсииПлатформы;
	КонецЕсли;
	ShellApplication = Новый COMobject("Shell.Application");
	КаталогПустойИнфобазы  = ShellApplication.NameSpace(28).Self.Path;
	КаталогПустойИнфобазы = КаталогПустойИнфобазы + "\1C\1Cv" + ВерсияПлатформы + "\EmptyDB";
	Результат = КаталогПустойИнфобазы;
	Возврат Результат;
	
КонецФункции

// Параметры:
//   СоздаватьБазуВСлучаеОтсутствия - Булево
//
Функция ПолучитьСтрокуСоединенияПустойИнфобазыЛкс(ВерсияПлатформы = "", Знач СоздаватьБазуВСлучаеОтсутствия = Истина) Экспорт
	
	КаталогПустойИнфобазы = ПолучитьКаталогПустойИнфобазыЛкс(ВерсияПлатформы);
	Если СоздаватьБазуВСлучаеОтсутствия Тогда
		ФайлПустойИнфобазы = Новый Файл(КаталогПустойИнфобазы + "\1CV8.1CD");
		Если Не ФайлПустойИнфобазы.Существует() Тогда
			СтрокаПараметров = "CREATEINFOBASE File=" + КаталогПустойИнфобазы + ";";
			//СтрокаПараметров = СтрокаПараметров + " /AddInList ууууу";
			ИмяФайлаЛога = ПолучитьИмяВременногоФайла();
			СтрокаПараметров = СтрокаПараметров + " /out" + ИмяФайлаЛога;
			СтрокаЗапуска = """" + КаталогПрограммы() + "1cv8.exe"" " + СтрокаПараметров;
			ирКэш.Получить().ЗапуститьСкрытоеПриложениеИДождатьсяЗавершения(СтрокаЗапуска); //ВыполнитьСкрытуюКомандуОС
		КонецЕсли;
	КонецЕсли;
	СтрокаСоединения = "File=""" + КаталогПустойИнфобазы + """;";
	Результат = СтрокаСоединения;
	Возврат Результат;
	
КонецФункции

// Создает COM объект клиента 1C и подключает его к базе по указанной строке соединения.
// Параметры:
//  СтрокаСоединения - Строка
//  ИмяПользователя - Строка
//  ПарольПользователя - Строка
//  ТипКомОбъекта - Строка, *"Application" - "Application" или "ComConnector"
//  Видимость - Булево - для Application
//  ОбработатьИсключениеПодключения - Булево, *Ложь - при Истина исключение обрабатывается внутри метода и возвращется его описание в качестве результата
//  ИмяСервераПроцессов - Строка - имя сервера, на котором создавать COM объект
//  
// Возвращаемое значение:
//  COMОбъект - клиента 1C, Строка - описание исключения
//
Функция СоздатьСеансИнфобазы1С8Лкс(Знач СтрокаСоединения = "", Знач ИмяПользователя = "", Знач ПарольПользователя = "",
	Знач ТипКомОбъекта = "Application", Знач Видимость = Ложь, Знач ОбработатьИсключениеПодключения = Ложь,
	ОписаниеОшибки = "", ИмяСервераПроцессов = "") Экспорт
	
	ДопСтрокаСоединения = "Usr=""" + ИмяПользователя + """;" + "Pwd=""" + ПарольПользователя + """;";
	Соединение = Новый COMОбъект("v" + ирКэш.Получить().ИДВерсииПлатформы + "." + ТипКомОбъекта, ИмяСервераПроцессов);
	
	Если Не ЗначениеЗаполнено(СтрокаСоединения) Тогда
		СтрокаСоединения = СтрокаСоединенияИнформационнойБазы();
	КонецЕсли; 
	ПолнаяСтрокаСоединения = СтрокаСоединения + ДопСтрокаСоединения;
	Попытка
		РезультатСоединения = Соединение.Connect(ПолнаяСтрокаСоединения);
	Исключение
		Если ОбработатьИсключениеПодключения Тогда
			ОписаниеОшибки = ОписаниеОшибки();
			Возврат ОписаниеОшибки;
		Иначе
			ВызватьИсключение;
		КонецЕсли;
	КонецПопытки;
	Если ТипКомОбъекта = "Application" Тогда
		Соединение.Visible = Видимость;
		Результат = Соединение;
	ИначеЕсли ТипКомОбъекта = "ComConnector" Тогда
		Результат = РезультатСоединения;
	КонецЕсли;
	Возврат Результат;
	
КонецФункции

Процедура СчитатьПорциюДинамическойВыборкиВТаблицуЛкс(Выборка, ТаблицаПриемник, Знач РазмерПорции = 999) Экспорт

	#Если _ Тогда
	    Пустышка = Новый запрос;
		Выборка = Пустышка.Выполнить();
	#КонецЕсли
	КоличествоРезультата = Выборка.Количество();
	Несчитано = КоличествоРезультата - ТаблицаПриемник.Количество();
	Если Ложь
		Или РазмерПорции > Несчитано 
		Или РазмерПорции = 0
	Тогда
		РазмерПорции = Несчитано;
	КонецЕсли; 
	Если Несчитано = РазмерПорции Тогда
		ПредставлениеПроцесса = "Загрузка выборки";
	Иначе
		ПредставлениеПроцесса = "Загрузка порции выборки";
	КонецЕсли;
	#Если Клиент Тогда
		Индикатор = ЛксПолучитьИндикаторПроцесса(РазмерПорции, ПредставлениеПроцесса);
	#КонецЕсли 
	КолонкиВложенныхТаблиц = Новый Массив();
	Для Каждого Колонка Из Выборка.Владелец().Колонки Цикл
		Если Колонка.ТипЗначения.СодержитТип(Тип("РезультатЗапроса")) Тогда
			КолонкиВложенныхТаблиц.Добавить(Колонка.Имя);
		КонецЕсли; 
	КонецЦикла;
	ЕстьКолонкиВложенныхТаблиц = КолонкиВложенныхТаблиц.Количество() > 0;
	Пока Выборка.Следующий() Цикл
		#Если Клиент Тогда
			ЛксОбработатьИндикатор(Индикатор);
		#КонецЕсли 
		НоваяСтрока = ТаблицаПриемник.Добавить();
		ЗаполнитьЗначенияСвойств(НоваяСтрока, Выборка);
		Если ЕстьКолонкиВложенныхТаблиц Тогда
			Для Каждого КолонкаВложеннойТаблицы Из КолонкиВложенныхТаблиц Цикл
				НоваяСтрока[КолонкаВложеннойТаблицы] = Выборка[КолонкаВложеннойТаблицы].Выгрузить();
			КонецЦикла; 
		КонецЕсли; 
		Если РазмерПорции > 0 Тогда
			РазмерПорции = РазмерПорции - 1;
			Если РазмерПорции = 0 Тогда
				Прервать;
			КонецЕсли; 
		КонецЕсли; 
	КонецЦикла; 

КонецПроцедуры // СчитатьПорциюРезультата()

// Параметры:
//   XML - 
//   Тип - 
//   ИспользоватьXDTO - 
//   СообщатьОбОшибках - 
//
Функция ВосстановитьОбъектИзСтрокиXMLЛкс(Знач XML = "", Знач Тип = "", Знач ИспользоватьXDTO = Истина, Знач СообщатьОбОшибках = Истина) Экспорт
	
	Если ЗначениеЗаполнено(XML) Тогда
		ЧтениеXML = Новый ЧтениеXML;
		ЧтениеXML.УстановитьСтроку(XML);
		Попытка
			Если ИспользоватьXDTO Тогда
				Результат = СериализаторXDTO.ПрочитатьXML(ЧтениеXML);
			Иначе
				Результат = ПрочитатьXML(ЧтениеXML);
			КонецЕсли;
		Исключение
			Если СообщатьОбОшибках Тогда
				Сообщить(ОписаниеОшибки(), СтатусСообщения.Важное);
			КонецЕсли;
		КонецПопытки;
	КонецЕсли;
	Если Результат = Неопределено Тогда
		Результат = Новый (Тип);
	КонецЕсли;
	Возврат Результат;
	
КонецФункции

Функция ВосстановитьНастройкуКомпоновкиИзСтрокиXMLЛкс(Знач XML = "", Знач СообщатьОбОшибках = Истина) Экспорт
	
	Результат = ирНеглобальный.ВосстановитьОбъектИзСтрокиXMLЛкс(XML, Тип("НастройкиКомпоновкиДанных"), , СообщатьОбОшибках);
	Возврат Результат;
	
КонецФункции

// Параметры:
//   Объект - 
//   ИспользоватьXDTO - 
//
Функция СохранитьОбъектВВидеСтрокиXMLЛкс(Знач Объект, Знач ИспользоватьXDTO = Истина) Экспорт
	
	Поток = Новый ЗаписьXML;
	Поток.УстановитьСтроку();
	Если ИспользоватьXDTO Тогда
		СериализаторXDTO.ЗаписатьXML(Поток, Объект);
	Иначе
		ЗаписатьXML(Поток, Объект);
	КонецЕсли;
	Результат = Поток.Закрыть();
	Возврат Результат;
	
КонецФункции

Функция ЗаписатьОбъектДляОтладкиЛкс(Объект) Экспорт
	
	#Если Не Клиент Тогда
		Если ТранзакцияАктивна() Тогда
			СтрокаХМЛ = СохранитьОбъектВВидеСтрокиXMLЛкс(Объект);
			Параметры = Новый Массив();
			Параметры.Добавить(СтрокаХМЛ);
			ФоновоеЗадание = ФоновыеЗадания.Выполнить("ирНеглобальный.ЗаписатьОбъектДляОтладкиЛкс", Параметры);
		Иначе
	#КонецЕсли 
			Если ТипЗнч(Объект) = Тип("Строка") Тогда 
				Объект = ВосстановитьОбъектИзСтрокиXMLЛкс(Объект);
			КонецЕсли; 
			Объект.Записать();
	#Если Не Клиент Тогда
		КонецЕсли; 
	#КонецЕсли 
	
КонецФункции

// ТаблицаПараметров - ТаблицаЗначений 
Функция НайтиДобавитьПараметрСсылкуВТаблицуЛкс(ТаблицаПараметров, ИмяКолонкиИмени = "Имя", ИмяКолонкиЗначения = "Значение", ЗначениеПараметра,
	ИмяПараметра = Неопределено) Экспорт

	Строки = ТаблицаПараметров.НайтиСтроки(Новый Структура(ИмяКолонкиИмени, ЗначениеПараметра));
	Если Строки.Количество() > 0 Тогда
		Результат = Строки[0];
	Иначе
		ОбъектМД = ЗначениеПараметра.Метаданные();
		//Префикс = НРег(Лев(ОбъектМД.Имя, 1));
		Префикс = "";
		Если ИмяПараметра = Неопределено Тогда
			ИмяПараметра = "" + ЗначениеПараметра;
		КонецЕсли; 
		Если Не ЗначениеЗаполнено(ИмяПараметра) Тогда
			ИмяПараметра = ОбъектМД.Имя + "Пустая";
		КонецЕсли; 
		ИмяПараметра = Префикс + ирКэш.Получить().ПолучитьИдентификаторИзПредставления(ИмяПараметра);
		СтруктураСвойствПараметра = Новый Структура;
		СтруктураСвойствПараметра.Вставить(ИмяКолонкиИмени, ИмяПараметра);
		
		Счетчик = 0;
		Пока ТаблицаПараметров.НайтиСтроки(СтруктураСвойствПараметра).Количество() > 0 Цикл
			Счетчик = Счетчик + 1;
			СтруктураСвойствПараметра[ИмяКолонкиИмени] = ИмяПараметра + Счетчик;
		КонецЦикла;
		
		СтруктураСвойствПараметра.Вставить("ЭтоВыражение", Ложь);
		СтруктураСвойствПараметра.Вставить(ИмяКолонкиЗначения, ЗначениеПараметра);
		СтрокаНовогоПараметра = ТаблицаПараметров.Добавить();
		ЗаполнитьЗначенияСвойств(СтрокаНовогоПараметра, СтруктураСвойствПараметра);
		Результат = СтрокаНовогоПараметра;
	КонецЕсли;
	Возврат Результат;

КонецФункции // ДобавитьПараметрЗначение()

Функция ПолучитьНаборЗаписейПоКлючуЛкс(ПолноеИмяРегистраИлиНаборЗаписей, СтруктураКлюча, ДобавитьИЗаполнитьСтрокуНабора = Ложь) Экспорт

	Если ТипЗнч(ПолноеИмяРегистраИлиНаборЗаписей) = Тип("Строка") Тогда
		НаборЗаписей = Новый (СтрЗаменить(ПолноеИмяРегистраИлиНаборЗаписей, ".", "НаборЗаписей."));
	Иначе
		НаборЗаписей = ПолноеИмяРегистраИлиНаборЗаписей;
	КонецЕсли;
	Для Каждого ЭлементОтбора Из НаборЗаписей.Отбор Цикл
		ЭлементОтбора.Использование = Истина;
		ЭлементОтбора.Значение = СтруктураКлюча[ЭлементОтбора.ПутьКДанным];
	КонецЦикла;
	Если ДобавитьИЗаполнитьСтрокуНабора Тогда
		ЗаполнитьЗначенияСвойств(НаборЗаписей.Добавить(), СтруктураКлюча); 
	КонецЕсли; 
	Возврат НаборЗаписей;

КонецФункции

// Получает копию таблицы значений с минимальными типами колонок для содержания всех данных.
// Параметры:
//   ТаблицаДанных - ТаблицаЗначений
//   СужатьТолькоПроизвольныеКолонки - Булево - обрабатывать только колонки с пустым (произвольным) типом
//
Функция ПолучитьТаблицуЗначенийСМинимальнымиТипамиКолонокЛкс(Знач ТаблицаДанных, СужатьТолькоПроизвольныеКолонки = Ложь) Экспорт
	
	ОставляемыеКолонки = "";
	СужаемыеКолонки = Новый Массив();
	Для Каждого КолонкаДанных Из ТаблицаДанных.Колонки Цикл
		Если Истина
			И СужатьТолькоПроизвольныеКолонки
			И КолонкаДанных.ТипЗначения.Типы().Количество() > 0
		Тогда
			ОставляемыеКолонки = ОставляемыеКолонки + "," + КолонкаДанных.Имя;
		Иначе
			СужаемыеКолонки.Добавить(КолонкаДанных);
		КонецЕсли; 
	КонецЦикла;
	Если ОставляемыеКолонки <> "" Тогда
		ТипизированнаяТаблица = ТаблицаДанных.Скопировать(, ОставляемыеКолонки);
	Иначе 
		ТипизированнаяТаблица = Новый ТаблицаЗначений;
	КонецЕсли; 
	//Состояние("Оптимизация типов колонок");
	МетаданныеТаблицыИзменены = Ложь;
	Для Каждого КолонкаДанных Из СужаемыеКолонки Цикл
		Типы = Новый Массив;
		ТаблицаКолонки = ТаблицаДанных.Скопировать(, КолонкаДанных.Имя);
		ТаблицаКолонки.Свернуть(КолонкаДанных.Имя);
		//Индикатор = УФ(сПолучитьИндикаторПроцесса, ТаблицаКолонки.Количество(), "Оптимизация типов колонки """ + КолонкаДанных.Имя + """");
		Для Каждого СтрокаДанных Из ТаблицаКолонки Цикл
			//ЛксОбработатьИндикатор(Индикатор);
			ТипЗначения = ТипЗнч(СтрокаДанных[КолонкаДанных.Имя]);
			Если Типы.Найти(ТипЗначения) = Неопределено Тогда
				Типы.Добавить(ТипЗначения);
			КонецЕсли;
		КонецЦикла;
		Если Типы.Количество() <> КолонкаДанных.ТипЗначения.Типы().Количество() Тогда
			МетаданныеТаблицыИзменены = Истина;
		КонецЕсли;
		ТипизированнаяТаблица.Колонки.Добавить(КолонкаДанных.Имя, Новый ОписаниеТипов(Типы), КолонкаДанных.Заголовок);
	КонецЦикла;
	
	Если МетаданныеТаблицыИзменены Тогда
		//Состояние("Загрузка таблицы данных");
		ЛксЗагрузитьВТаблицуЗначений(ТаблицаДанных, ТипизированнаяТаблица);
		//Состояние("");
	Иначе
		ТипизированнаяТаблица = ТаблицаДанных.Скопировать();
	КонецЕсли;
	Результат = ТипизированнаяТаблица;
	Возврат Результат;
	
КонецФункции

// ************************
// WMI

Функция ПолучитьСтруктуруИзЗначенияWMIЛкс(ЗначениеWMI) Экспорт
	
	Результат = Новый Структура;
	Для каждого СвойствоWMI из ЗначениеWMI Цикл
		Если ТипЗнч(СвойствоWMI.Value) = Тип("COMSafeArray") Тогда 
			ЗначениеСвойства = СвойствоWMI.Value.Выгрузить();// возможно массив надо будет переделать
		Иначе
			ЗначениеСвойства = СвойствоWMI.Value;
			//ИмяТипа = ирНеглобальный.ПолучитьИмяТипаИзКвалификаторовWMIЛкс(СвойствоWMI);
			//Если ирНеглобальный.СтрокиРавныЛкс(ИмяТипа, "Дата") Тогда
			Если СвойствоWMI.CIMTYPE = 101 Тогда  //datetime
				ЗначениеСвойства = ирНеглобальный.СтрокаДатыWMIВДатуЛкс(ЗначениеСвойства);
			КонецЕсли; 
		КонецЕсли;
		Результат.Вставить(СвойствоWMI.Name, ЗначениеСвойства);
	КонецЦикла;
	Возврат Результат;
	
КонецФункции

Функция ПолучитьИмяТипаИзКвалификаторовWMIЛкс(Свойство) Экспорт

	ИмяТипа = "";
	Попытка
		Квалификаторы = Свойство.Qualifiers_;
	Исключение
		// Нет у системных свойств
		Квалификаторы = Новый Массив();
	КонецПопытки;
	Для Каждого Квалификатор Из Квалификаторы Цикл
		Если ирНеглобальный.СтрокиРавныЛкс("CIMTYPE", Квалификатор.Name) Тогда
			ИмяТипа = Нрег(Квалификатор.Value);
			Прервать;
		КонецЕсли;
	КонецЦикла; 
	Если Ложь
		Или Найти(ИмяТипа, "int") > 0 
	Тогда
		ИмяТипа = "Число";
	ИначеЕсли Ложь
		Или Найти(ИмяТипа, "date") > 0 
		Или Найти(ИмяТипа, "time") > 0 
	Тогда
		ИмяТипа = "Дата";
	ИначеЕсли Ложь
		Или Найти(ИмяТипа, "sting") > 0 
		Или Найти(ИмяТипа, "char") > 0 
	Тогда
		ИмяТипа = "Строка";
	ИначеЕсли ТипЗнч(ИмяТипа) = Тип("COMОбъект") Тогда
		ИмяТипа = "COMОбъект.{WbemScripting.SwbemLocator}." + ИмяТипа;
	КонецЕсли; 

	Возврат ИмяТипа;

КонецФункции

Функция ПолучитьОписаниеЭлементаWMIЛкс(ЭлементКоллекции, ИмяСвойства = "Description") Экспорт

	ОписаниеЭлемента = "";
	Квалификаторы = ЭлементКоллекции.qualifiers_;
	Попытка
		КвалификаторОписание = Квалификаторы.item(ИмяСвойства);
	Исключение
		КвалификаторОписание = Неопределено;
	КонецПопытки;
	Если КвалификаторОписание <> Неопределено Тогда
		ОписаниеЭлемента = КвалификаторОписание.Value;
	КонецЕсли;
	Возврат ОписаниеЭлемента;

КонецФункции

Функция ПолучитьДокументациюСвойстваWMIЛкс(ИмяКласса, ИмяСвойства, СлужбаWMI = Неопределено) Экспорт

	Если СлужбаWMI = Неопределено Тогда
		СлужбаWMI = ирКэш.ПолучитьCOMОбъектWMIЛкс();
	КонецЕсли; 
	wbemFlagUseAmendedQualifiers = 131072; //&H20000
	ОписанияСвойств = СлужбаWMI.Get(ИмяКласса, wbemFlagUseAmendedQualifiers).Properties_;
	Попытка
		ОписаниеСвойства = ОписанияСвойств.item(ИмяСвойства);
	Исключение
		Возврат "";
	КонецПопытки;
	ТекстОписания = ПолучитьОписаниеЭлементаWMIЛкс(ОписаниеСвойства);
	ТипЗначений = ПолучитьОписаниеЭлементаWMIЛкс(ОписаниеСвойства, "CIMTYPE");
	Если ТипЗначений <> Неопределено Тогда
		ТекстОписания = ТекстОписания + "
		|Type: " + ТипЗначений;
	КонецЕсли;
	ЕдиницаИзмерения = ПолучитьОписаниеЭлементаWMIЛкс(ОписаниеСвойства, "Units");
	Если ЗначениеЗаполнено(ЕдиницаИзмерения) Тогда
		ТекстОписания = ТекстОписания + "
		|Unit: " + ЕдиницаИзмерения;
	КонецЕсли;
	Возврат ТекстОписания;

КонецФункции

Функция ПолучитьДокументациюМетодаWMIЛкс(ИмяКласса, ИмяМетода, СлужбаWMI = Неопределено) Экспорт

	Если СлужбаWMI = Неопределено Тогда
		СлужбаWMI = ирКэш.ПолучитьCOMОбъектWMIЛкс();
	КонецЕсли; 
	wbemFlagUseAmendedQualifiers = 131072; //&H20000
	ОписанияМетодов = СлужбаWMI.Get(ИмяКласса, wbemFlagUseAmendedQualifiers).Methods_;
	Попытка
		ОписаниеМетода = ОписанияМетодов.item(ИмяМетода);
	Исключение
		Возврат "";
	КонецПопытки;
	ТекстОписания = ПолучитьОписаниеЭлементаWMIЛкс(ОписаниеМетода);
	ТипЗначений = ПолучитьОписаниеЭлементаWMIЛкс(ОписаниеМетода, "CIMTYPE");
	Если ТипЗначений <> Неопределено Тогда
		ТекстОписания = ТекстОписания + "
		|Type: " + ТипЗначений;
	КонецЕсли;
	ЕдиницаИзмерения = ПолучитьОписаниеЭлементаWMIЛкс(ОписаниеМетода, "Units");
	Если ЗначениеЗаполнено(ЕдиницаИзмерения) Тогда
		ТекстОписания = ТекстОписания + "
		|Unit: " + ЕдиницаИзмерения;
	КонецЕсли;
	Возврат ТекстОписания;

КонецФункции

// Параметры:
//   СтрокаДаты - Строка(0,П)
//
Функция СтрокаДатыWMIВДатуЛкс(Знач СтрокаДаты = "") Экспорт
	
	Если Не ЗначениеЗаполнено(СтрокаДаты) Тогда
		Возврат Дата(1,1,1);
	Иначе
		Строка = Лев(СтрокаДаты, 4) + Сред(СтрокаДаты, 5, 2) + Сред(СтрокаДаты, 7, 2)
			+ Сред (СтрокаДаты, 9, 2) + Сред(СтрокаДаты, 11, 2) + Сред(СтрокаДаты, 13, 2);
		Результат = Дата(Строка) + Вычислить("0." + Сред(СтрокаДаты, 16, 6));
	КонецЕсли; 
	Возврат Результат;
	
КонецФункции

// WMI
// *************************

// ************************
// ADO

Функция ПолучитьКолонкиRecordsetADOЛкс(РезультатТаблица, РезультатRecordset, Типизировать1С = Неопределено) Экспорт

	Если РезультатТаблица = Неопределено Тогда
		РезультатТаблица = Новый ТаблицаЗначений;
	КонецЕсли; 
	мПлатформа = ирКэш.Получить();
	FieldКолонка = Новый Соответствие;
	Для каждого Field Из РезультатRecordset.Fields Цикл
		Если ПустаяСтрока(Field.Name) Тогда
			ИмяКолонки = ":?";
			Для о=1 По СтрДлина(Field.Name)-1 Цикл
				ИмяКолонки = ИмяКолонки + "?";
			КонецЦикла; 
		Иначе
			ИмяКолонки = Field.Name;
		КонецЕсли;
		Если Не ЛксЛиИмяПеременной(ИмяКолонки) Тогда
			ИмяКолонки = мПлатформа.ПолучитьИдентификаторИзПредставления(ИмяКолонки);
		КонецЕсли; 
		// контроль полей - двойников по именам
		НомерДвойника=0;
		Пока РезультатТаблица.Колонки.Найти(ИмяКолонки + Формат(НомерДвойника,"ЧГ=0")) <> Неопределено Цикл
			НомерДвойника = НомерДвойника + 1;
		КонецЦикла;
		ИмяКолонки = ИмяКолонки + Формат(НомерДвойника, "ЧГ=0");
		Если Типизировать1С = Истина Тогда
			Тип1С = ирНеглобальный.FieldADO_ПолучитьТип1C(Field);
		Иначе
			Тип1С = Неопределено;
		КонецЕсли;
		//Если Тип1С=Неопределено Тогда
		//	Колонка = РезультатТаблица.Колонки.Добавить(ИмяКолонки,,"["+Name+"]");
		//Иначе
			Колонка = РезультатТаблица.Колонки.Добавить(ИмяКолонки,Тип1С);
		//КонецЕсли;
		FieldКолонка.Вставить(Field, Колонка);
	КонецЦикла;
	Возврат FieldКолонка;

КонецФункции

// *** УСТАНОВКА ПАРАМЕТРОВ ЗАПРОСА ADO  ***

// подбирает описание типа 1С, соответствующее типу ADO
Функция ПреобразоватьТипADO_Тип1С(Type,Size,Precision0,NumericScale0) Экспорт
	Тип1С = Неопределено;
	Если Precision0 > 0 И NumericScale0 >= 0 Тогда
		Если Precision0 < NumericScale0 Тогда
			// кривой вариант настроек типа ADO (может иногда возвращаться провайдерами данных)
			Precision = Precision0 + NumericScale0;
		Иначе
			Precision = Precision0;
		КонецЕсли; 
		UseМаксЧисло = (Precision > 32); 
	Иначе
		// совсем кривой вариант
		UseМаксЧисло = Истина;
	КонецЕсли; 
	NumericScale = ?(NumericScale0 < 0, 0, NumericScale0);
	NumericScaleM = ?(NumericScale > 10, 10, NumericScale);
	Если 		Type =	intTypeADO("adEmpty")	Тогда 
	ИначеЕсли	Type =	intTypeADO("adSmallInt")Тогда
		Тип1С = Новый ОписаниеТипов("Число",	Новый КвалификаторыЧисла(5, 0, ДопустимыйЗнак.Любой));
	ИначеЕсли	Type =	intTypeADO("adInteger")	Тогда 
		Тип1С = Новый ОписаниеТипов("Число",	Новый КвалификаторыЧисла(10, 0, ДопустимыйЗнак.Любой));
	ИначеЕсли	Type =	intTypeADO("adSingle")	Тогда
		Если UseМаксЧисло Тогда
			// взвешанно-максимальный числовой тип
			Тип1С = Новый ОписаниеТипов("Число",Новый КвалификаторыЧисла(32, NumericScaleM, ДопустимыйЗнак.Любой));
		Иначе
			Тип1С = Новый ОписаниеТипов("Число",Новый КвалификаторыЧисла(Precision, NumericScale, ДопустимыйЗнак.Любой));
		КонецЕсли; 
	ИначеЕсли	Type =	intTypeADO("adDouble")	Тогда 
		Тип1С = Новый ОписаниеТипов("Число",	Новый КвалификаторыЧисла(Precision+NumericScale, NumericScale, ДопустимыйЗнак.Любой));
		Если UseМаксЧисло Тогда
			// взвешанно-максимальный числовой тип
			Тип1С = Новый ОписаниеТипов("Число",Новый КвалификаторыЧисла(32, NumericScaleM, ДопустимыйЗнак.Любой));
		Иначе
			Тип1С = Новый ОписаниеТипов("Число",Новый КвалификаторыЧисла(Precision, NumericScale, ДопустимыйЗнак.Любой));
		КонецЕсли; 
	ИначеЕсли	Type =	intTypeADO("adCurrency")Тогда 
		Если UseМаксЧисло Тогда
			// взвешанно-максимальный числовой тип
			Тип1С = Новый ОписаниеТипов("Число",Новый КвалификаторыЧисла(32, NumericScaleM, ДопустимыйЗнак.Любой));
		Иначе
			Тип1С = Новый ОписаниеТипов("Число",Новый КвалификаторыЧисла(Precision, NumericScale, ДопустимыйЗнак.Любой));
		КонецЕсли; 
	ИначеЕсли	Type =	intTypeADO("adDate")	Тогда 
		Тип1С = Новый ОписаниеТипов("Дата",   ,	Новый КвалификаторыДаты(ЧастиДаты.Дата));
	ИначеЕсли	Type =	intTypeADO("adBSTR")	Тогда 
		Тип1С = Новый ОписаниеТипов("Строка", ,	Новый КвалификаторыСтроки(Size, ДопустимаяДлина.Переменная));
	ИначеЕсли	Type =	intTypeADO("adIDispatch")Тогда 
	ИначеЕсли	Type =	intTypeADO("adError")	Тогда 
		Тип1С = Новый ОписаниеТипов("Число",	Новый КвалификаторыЧисла(Precision, 0, ДопустимыйЗнак.Неотрицательный));
	ИначеЕсли	Type =	intTypeADO("adBoolean")	Тогда 
		Тип1С = Новый ОписаниеТипов("Булево");
	ИначеЕсли	Type =	intTypeADO("adVariant")	Тогда 
	ИначеЕсли	Type =	intTypeADO("adIUnknown")Тогда 
	ИначеЕсли	Type =	intTypeADO("adDecimal")	Тогда 
		Тип1С = Новый ОписаниеТипов("Число",	Новый КвалификаторыЧисла(Precision, NumericScale, ДопустимыйЗнак.Любой));
	ИначеЕсли	Type =	intTypeADO("adTinyInt")	Тогда 	
		Тип1С = Новый ОписаниеТипов("Число",	Новый КвалификаторыЧисла(3, 0, ДопустимыйЗнак.Любой));
	ИначеЕсли	Type =	intTypeADO("adUnsignedTinyInt")Тогда 
		Тип1С = Новый ОписаниеТипов("Число",	Новый КвалификаторыЧисла(3, 0, ДопустимыйЗнак.Неотрицательный));
	ИначеЕсли	Type =	intTypeADO("adUnsignedSmallInt")Тогда 
		Тип1С = Новый ОписаниеТипов("Число",	Новый КвалификаторыЧисла(5, 0, ДопустимыйЗнак.Неотрицательный));
	ИначеЕсли	Type =	intTypeADO("adUnsignedInt")Тогда 
		Тип1С = Новый ОписаниеТипов("Число",	Новый КвалификаторыЧисла(10, 0, ДопустимыйЗнак.Неотрицательный));
	ИначеЕсли	Type =	intTypeADO("adBigInt")	Тогда 
		Тип1С = Новый ОписаниеТипов("Число",	Новый КвалификаторыЧисла(20, 0, ДопустимыйЗнак.Любой));
	ИначеЕсли	Type =	intTypeADO("adUnsignedBigInt")Тогда 
		Тип1С = Новый ОписаниеТипов("Число",	Новый КвалификаторыЧисла(20, 0, ДопустимыйЗнак.Неотрицательный));
	ИначеЕсли	Type =	intTypeADO("adFileTime")Тогда 
		Тип1С = Новый ОписаниеТипов("Число",	Новый КвалификаторыЧисла(Precision, 0, ДопустимыйЗнак.Неотрицательный));
	ИначеЕсли	Type =	intTypeADO("adGUID")	Тогда 
	ИначеЕсли	Type =	intTypeADO("adBinary")	Тогда 
	ИначеЕсли	Type =	intTypeADO("adChar")	Тогда 
		Тип1С = Новый ОписаниеТипов("Строка", ,	Новый КвалификаторыСтроки(Size, ДопустимаяДлина.Переменная));
	ИначеЕсли	Type =	intTypeADO("adWChar")	Тогда 
		Тип1С = Новый ОписаниеТипов("Строка", ,	Новый КвалификаторыСтроки(Size, ДопустимаяДлина.Переменная));
	ИначеЕсли	Type =	intTypeADO("adNumeric")	Тогда
		Если UseМаксЧисло Тогда
			// взвешанно-максимальный числовой тип
			Тип1С = Новый ОписаниеТипов("Число",Новый КвалификаторыЧисла(32, NumericScaleM, ДопустимыйЗнак.Любой));
		Иначе
			Тип1С = Новый ОписаниеТипов("Число",Новый КвалификаторыЧисла(Precision, NumericScale, ДопустимыйЗнак.Любой));
		КонецЕсли;
	ИначеЕсли	Type =	intTypeADO("adUserDefined")Тогда 
	ИначеЕсли	Type =	intTypeADO("adDBDate")	Тогда
		Тип1С = Новый ОписаниеТипов("Дата",   ,	Новый КвалификаторыДаты(ЧастиДаты.Дата));
	ИначеЕсли	Type =	intTypeADO("adDBTime")	Тогда 
		Тип1С = Новый ОписаниеТипов("Дата",   ,	Новый КвалификаторыДаты(ЧастиДаты.Время));
	ИначеЕсли	Type =	intTypeADO("adDBTimeStamp")Тогда 
		Тип1С = Новый ОписаниеТипов("Дата",   ,	Новый КвалификаторыДаты(ЧастиДаты.ДатаВремя));
	ИначеЕсли	Type =	intTypeADO("adChapter")	Тогда 
		Тип1С = Новый ОписаниеТипов("Число",	Новый КвалификаторыЧисла(Precision, 0, ДопустимыйЗнак.Неотрицательный));
	ИначеЕсли	Type =	intTypeADO("adPropVariant")Тогда 
	ИначеЕсли	Type =	intTypeADO("adVarNumeric")Тогда
		Если UseМаксЧисло Тогда
			// взвешанно-максимальный числовой тип
			Тип1С = Новый ОписаниеТипов("Число",Новый КвалификаторыЧисла(32, NumericScaleM, ДопустимыйЗнак.Любой));
		Иначе
			Тип1С = Новый ОписаниеТипов("Число",Новый КвалификаторыЧисла(Precision, NumericScale, ДопустимыйЗнак.Любой));
		КонецЕсли;
	ИначеЕсли	Type =	intTypeADO("adVarChar")	Тогда 
		Тип1С = Новый ОписаниеТипов("Строка", ,	Новый КвалификаторыСтроки(Size, ДопустимаяДлина.Переменная));
	ИначеЕсли	Type =	intTypeADO("adLongVarChar")Тогда 
		Тип1С = Новый ОписаниеТипов("Строка", ,	Новый КвалификаторыСтроки(0, ДопустимаяДлина.Переменная));
	ИначеЕсли	Type =	intTypeADO("adVarWChar")Тогда 
		Тип1С = Новый ОписаниеТипов("Строка", ,	Новый КвалификаторыСтроки(Size, ДопустимаяДлина.Переменная));
	ИначеЕсли	Type =	intTypeADO("adLongVarWChar")Тогда 
		Тип1С = Новый ОписаниеТипов("Строка", ,	Новый КвалификаторыСтроки(0, ДопустимаяДлина.Переменная));
	ИначеЕсли	Type =	intTypeADO("adVarBinary")Тогда 
	ИначеЕсли	Type =	intTypeADO("adLongVarBinary")Тогда 
	ИначеЕсли	Type =  intTypeADO("AdArray")	Тогда 
	Иначе // Тип1С = Неопределено;
	КонецЕсли; 
	Возврат Тип1С;
КонецФункции // ПреобразоватьТипADO_Тип1С()

// возвращает описание типа 1С, соответствующее типу объекта ADODB.Field
// значение Неопределено соответствует значению произвольного типа 1С
Функция FieldADO_ПолучитьТип1C(FieldADO) Экспорт
	Попытка
		Type = FieldADO.Type;
		DefinedSize = FieldADO.DefinedSize;
		Precision = FieldADO.Precision;
		NumericScale = FieldADO.NumericScale;
	Исключение
		Возврат Неопределено;
	КонецПопытки;
	Возврат ПреобразоватьТипADO_Тип1С(Type,DefinedSize,Precision,NumericScale);
КонецФункции

// возвращает описание типа 1С, соответствующее типу объекта ADODB.Parameter
// значение Неопределено соответствует значению произвольного типа 1С
Функция ParameterADO_ПолучитьТип1C(ParameterADO) Экспорт
	Попытка
		Type = ParameterADO.Type;
		Size = ParameterADO.Size;
		Precision = ParameterADO.Precision;
		NumericScale = ParameterADO.NumericScale;
	Исключение
		Возврат Неопределено;
	КонецПопытки;
	Возврат ПреобразоватьТипADO_Тип1С(Type,Size,Precision,NumericScale);
КонецФункции

// возвращает структуру с полями объекта ADODB.Field
Функция FieldADO(стрName,стрType,чисDefinedSize,чисPrecision,чисNumericScale,Value=Неопределено) Экспорт
	ПолеADO = Новый Структура("Name,Type,DefinedSize,Precision,NumericScale,Value");
	ТипЧисло = Тип("Число");
	Если стрName <> Неопределено Тогда
		ПолеADO.Вставить("Name",СокрЛП(стрName));
	КонецЕсли; 
	Если стрType <> Неопределено Тогда
		Если ТипЗнч(стрType) = ТипЧисло Тогда
			// дополнительный контроль числа на допустимое значение
			ПолеADO.Вставить("Type",intTypeADO(strTypeADO(стрType)));
		Иначе
			ПолеADO.Вставить("Type",intTypeADO(стрType));
		КонецЕсли; 
	КонецЕсли; 
	Если чисDefinedSize <> Неопределено Тогда
		Если ТипЗнч(чисDefinedSize)=ТипЧисло Тогда
			ПолеADO.Вставить("DefinedSize",Цел(чисDefinedSize));
		Иначе
			ПолеADO.Вставить("DefinedSize",0);
		КонецЕсли; 
	КонецЕсли; 
	Если чисPrecision <> Неопределено Тогда
		Если ТипЗнч(чисPrecision)=ТипЧисло Тогда
			ПолеADO.Вставить("Precision",Цел(чисPrecision));
		Иначе
			ПолеADO.Вставить("Precision",0);
		КонецЕсли; 
	КонецЕсли; 
	Если чисNumericScale <> Неопределено Тогда
		Если ТипЗнч(чисNumericScale)=ТипЧисло Тогда
			ПолеADO.Вставить("NumericScale",Цел(чисNumericScale));
		Иначе
			ПолеADO.Вставить("NumericScale",0);
		КонецЕсли; 
	КонецЕсли; 
	Если Value <> Неопределено Тогда
		ПолеADO.Вставить("Value",Value);
	КонецЕсли; 
	Возврат ПолеADO;
КонецФункции

// возвращает структуру с полями объекта ADODB.Parameter
Функция ParameterADO(стрName,стрDirection,стрType,чисSize,чисNumericScale,чисPrecision,чисAttributes=0,Value=Неопределено) Экспорт
	ПараметрADO = Новый Структура("Name,Direction,Type,Size,NumericScale,Precision,Attributes,Value");
	ТипЧисло = Тип("Число");
	Если стрName <> Неопределено Тогда
		ПараметрADO.Вставить("Name",СокрЛП(стрName));
	КонецЕсли;
	Если чисAttributes <> Неопределено Тогда
		Если ТипЗнч(чисAttributes)=ТипЧисло И чисAttributes > 0 Тогда
			ПараметрADO.Вставить("Attributes",Цел(чисAttributes));
		КонецЕсли; 
	КонецЕсли; 
	Если стрDirection <> Неопределено Тогда
		Если ТипЗнч(стрDirection) = ТипЧисло Тогда
			// дополнительный контроль числа на допустимое значение
			ПараметрADO.Вставить("Direction",intDirectionParADO(strDirectionParADO(стрDirection)));
		Иначе
			ПараметрADO.Вставить("Direction",intDirectionParADO(стрDirection));
		КонецЕсли; 
	КонецЕсли; 
	Если стрType <> Неопределено Тогда
		Если ТипЗнч(стрType) = ТипЧисло Тогда
			// дополнительный контроль числа на допустимое значение
			ПараметрADO.Вставить("Type",intTypeADO(strTypeADO(стрType)));
		Иначе
			ПараметрADO.Вставить("Type",intTypeADO(стрType));
		КонецЕсли; 
	КонецЕсли; 
	Если чисSize <> Неопределено Тогда
		Если ТипЗнч(чисSize)=ТипЧисло Тогда
			ПараметрADO.Вставить("Size",Цел(чисSize));
		Иначе
			ПараметрADO.Вставить("Size",0);
		КонецЕсли; 
	КонецЕсли; 
	Если чисNumericScale <> Неопределено Тогда
		Если ТипЗнч(чисNumericScale)=ТипЧисло Тогда
			ПараметрADO.Вставить("NumericScale",Цел(чисNumericScale));
		Иначе
			ПараметрADO.Вставить("NumericScale",0);
		КонецЕсли; 
	КонецЕсли; 
	Если чисPrecision <> Неопределено Тогда
		Если ТипЗнч(чисPrecision)=ТипЧисло Тогда
			ПараметрADO.Вставить("Precision",Цел(чисPrecision));
		Иначе
			ПараметрADO.Вставить("Precision",0);
		КонецЕсли; 
	КонецЕсли; 
	Если Value <> Неопределено Тогда
		ПараметрADO.Вставить("Value",Value);
	КонецЕсли; 
	Возврат ПараметрADO;
КонецФункции

Функция DigitDECtoHEX(ЦыфраD)
	Если ЦыфраD=0 Тогда
		Возврат "0";
	ИначеЕсли ЦыфраD>=1 И ЦыфраD<=9 Тогда
		Возврат ""+ЦыфраD;
	ИначеЕсли ЦыфраD=10 Тогда
		Возврат "A";
	ИначеЕсли ЦыфраD=11 Тогда
		Возврат "B";
	ИначеЕсли ЦыфраD=12 Тогда
		Возврат "C";
	ИначеЕсли ЦыфраD=13 Тогда
		Возврат "D";
	ИначеЕсли ЦыфраD=14 Тогда
		Возврат "E";
	ИначеЕсли ЦыфраD=15 Тогда
		Возврат "F";
	Иначе
		Возврат "?";
	КонецЕсли; 
КонецФункции

Функция DigitHEXtoDEC(ЦыфраH)
	Если ЦыфраH="0" ИЛИ ЦыфраH="1" ИЛИ ЦыфраH="2" ИЛИ ЦыфраH="3" ИЛИ ЦыфраH="4" ИЛИ ЦыфраH="5" ИЛИ ЦыфраH="6" ИЛИ ЦыфраH="7" ИЛИ ЦыфраH="8" ИЛИ ЦыфраH="9" Тогда
		Возврат Цел(ЦыфраH);
	ИначеЕсли ЦыфраH="a" ИЛИ ЦыфраH="A" Тогда
		Возврат 10;
	ИначеЕсли ЦыфраH="b" ИЛИ ЦыфраH="B" Тогда
		Возврат 11;
	ИначеЕсли ЦыфраH="c" ИЛИ ЦыфраH="C" Тогда
		Возврат 12;
	ИначеЕсли ЦыфраH="d" ИЛИ ЦыфраH="D" Тогда
		Возврат 13;
	ИначеЕсли ЦыфраH="e" ИЛИ ЦыфраH="E" Тогда
		Возврат 14;
	ИначеЕсли ЦыфраH="f" ИЛИ ЦыфраH="F" Тогда
		Возврат 15;
	Иначе
		Возврат -1;
	КонецЕсли; 
КонецФункции

Функция СтрокаHEXtoINT(Знач СтрокаH) Экспорт
	ПрефиксH = Лев(СтрокаH,2);
	Если ПрефиксH="0x" 
	ИЛИ  ПрефиксH="0X"
	ИЛИ  ПрефиксH="0х"
	ИЛИ  ПрефиксH="0Х" Тогда
		СтрокаH=Сред(СтрокаH,3);
	КонецЕсли;
	Если ПустаяСтрока(СтрокаH) Тогда
		Возврат 0;
	КонецЕсли;
	ДлинаH=СтрДлина(СтрокаH);
	ЧислоD=0;
	Для о = 1 По ДлинаH Цикл
		ЦыфраH = Сред(СтрокаH,о,1);
		ЦифраD = DigitHEXtoDEC(ЦыфраH);
		Если ЦифраD<0 Тогда
			Возврат -1; // нарушение формата 16-тиричного числа
		КонецЕсли; 
		ЧислоD = 16*ЧислоD + ЦифраD;
	КонецЦикла; 
	Возврат ЧислоD;
КонецФункции

// преобразует 16-тиричную строку в COMSafeArray
Функция СтрокаHEXtoCOMSafeArray(Знач СтрокаH) Экспорт
	ПрефиксH = Лев(СтрокаH,2);
	Если ПрефиксH="0x" 
	ИЛИ  ПрефиксH="0X"
	ИЛИ  ПрефиксH="0х"
	ИЛИ  ПрефиксH="0Х" Тогда
		СтрокаH=Сред(СтрокаH,3);
	КонецЕсли;
	Байты =СтрДлина(СтрокаH);
	Байты = 2*Окр(Байты/2,0,1);
	ArrayДанные = Новый Массив;
	Поза=1;
	Для о=1 По Байты Цикл
		ДваБайт = Сред(СтрокаH,Поза,2);
		ЗначInt = СтрокаHEXtoINT(ДваБайт);
		Если ЗначInt<0 Тогда
			Возврат Неопределено;
		КонецЕсли; 
		ArrayДанные.Добавить(ЗначInt);
		Поза=Поза+2;
	КонецЦикла; 
	Array = Новый COMSafeArray(ArrayДанные,"VT_UI1",Байты/2);
	Возврат Array;
КонецФункции

// преобразует объект УникальныйИдентификатор в COMSafeArray
Функция GUIDToCOMSafeArray(GUID) Экспорт
	ГУИД = СтрЗаменить(GUID,"-",Символы.ПС);
	Если СтрЧислоСтрок(ГУИД)<>5 Тогда
		// нарушена каноническая структура строки ГУИД: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx (8-4-4-4-12)
		Возврат Неопределено; // вдруг ...
	КонецЕсли;
	
	// Соответсвие байтов в поле BINARY(16) с частями ГУИД: 4,5,3,2,1		- проверено для 1с-8.1.14
	СтрокаH = СтрПолучитьСтроку(ГУИД,4) + СтрПолучитьСтроку(ГУИД,5)+ СтрПолучитьСтроку(ГУИД,3)+ СтрПолучитьСтроку(ГУИД,2)+ СтрПолучитьСтроку(ГУИД,1);
	//Сообщить("ГУИД		=	"+ГУИД);
	//Сообщить("СтрокаH	=	"+СтрокаH);
	
	Возврат СтрокаHEXtoCOMSafeArray(СтрокаH);
КонецФункции 

// преобразует значение уникального идентификатора ссылки в COMSafeArray
Функция СсылкаToCOMSafeArray(Ссылка) Экспорт
	Попытка
		ГУИД = СокрЛП(Ссылка.УникальныйИдентификатор());
	Исключение
		// переданное значение не ссылка
		Возврат Неопределено;
	КонецПопытки;
	
	Возврат GUIDToCOMSafeArray(ГУИД);
КонецФункции

// преобразоваение значения COMSafeArray, содержащие 2-байтовые целые в шестнадцатиричную строку   
Функция BinaryCOMSafeArrayToHEX(Array) Экспорт
	
	СтрHEX="";
	Если ТипЗнч(Array)<>Тип("COMSafeArray") Тогда
		Возврат "?COMSafeArray?";
	КонецЕсли;
	
	Массив=Array.Выгрузить();
	Для каждого Слово Из Массив Цикл
		Если ТипЗнч(Слово)=Тип("Число") Тогда
			Слово=Цел(Слово);
			Если (Слово<0)ИЛИ(Слово>255) Тогда
				СтрHEX=СтрHEX+"??";
			Иначе
				Байт1=Слово%16;
				Байт2=Цел(Слово/16);
				СтрHEX=СтрHEX+DigitDECtoHEX(Байт2)+DigitDECtoHEX(Байт1);
			КонецЕсли; 
		Иначе
			СтрHEX=СтрHEX+"??";
		КонецЕсли; 
	КонецЦикла; 
	
	Возврат "0x"+СтрHEX;
КонецФункции

// возвращает свойства параметра ADO из переданной структуры 
// с автоматическим подбором значений свойств по значению 1С (если свойство неопределено)
Процедура ParameterADOСвойства(стТипADO,Значение1С,ЗначениеADO,Direction,Type,Precision,NumericScale,Size,Attributes,ADOUtils=Неопределено)
	Перем ТипЗначения1С;
	
	Если ТипЗнч(стТипADO)=Тип("Структура") Тогда
		стТипADO.Свойство("Direction",Direction);
		стТипADO.Свойство("Type",Type);
		стТипADO.Свойство("Precision",Precision);
		стТипADO.Свойство("NumericScale",NumericScale);
		стТипADO.Свойство("Size",Size);
		стТипADO.Свойство("Attributes",Attributes);
		стТипADO.Свойство("ТипЗначения1С",ТипЗначения1С);
	КонецЕсли;
	
	Если Истина
		И ТипЗнч(ТипЗначения1С) = Тип("ОписаниеТипов") 
		И ТипЗначения1С.Типы().Количество() > 0 
		И НЕ ТипЗначения1С.СодержитТип(ТипЗнч(Значение1С)) 
	Тогда 
		// приведем значение 1С к указанному типу (актуально для значений Null, возвращаемых запросами 1С)
		Значение1С = ТипЗначения1С.ПривестиЗначение(Значение1С);
	КонецЕсли; 
	
	Если Direction=Неопределено Тогда
		Direction=1; // 1 - входящий(Default) ... или 0 - неизвестно ???
	КонецЕсли;
	
	Тип1С=ТипЗнч(Значение1С);
	Попытка
		Ссылка = Значение1С.Ссылка;
	Исключение
		Ссылка = Неопределено;
		Попытка
			// перечисления стоят особняком среди "ссылочных" типов
			МетаДата = Значение1С.Метаданные();
			Если Метаданные.Перечисления.Содержит(МетаДата) Тогда
				Ссылка = Значение1С;
			КонецЕсли; 
		Исключение
		КонецПопытки;
	КонецПопытки;
	
	Если Type=Неопределено Тогда
		//  попытаемся подобрать по типу 1С
		Если Тип1С=Тип("Число") Тогда
			//Type = 4;		// adSingle
			//Type = 5;		// adDouble
			//Type = 14;	// adDecimal
			//Type = 131;	// adNumeric
			//Type = 139;	// adVarNumeric
			Если Цел(Значение1С)=Значение1С Тогда
				Если ?(Значение1С<0,-1,1)*Значение1С <= 2147483647 Тогда // 2^32-1
					Type = intTypeADO("adInteger"); // 3 
				Иначе
					Type = intTypeADO("adBigInt");	// 20
				КонецЕсли;
			Иначе
				Type = 14;	// adDecimal
			КонецЕсли; 
		ИначеЕсли Тип1С=Тип("Строка") Тогда
			//Type = 129;	// adChar
			//Type = 130;	// adWChar
			//Type = 200;	// adVarChar
			//Type = 201;	// adLongVarChar
			//Type = 202;	// adVarWChar
			//Type = 203;	// adLongVarWChar
			Если СтрДлина(Значение1С)<=4000 Тогда
				Type = intTypeADO("adVarChar");	// 200 
			Иначе
				Type = intTypeADO("adLongVarChar"); // 201 
			КонецЕсли; 
		ИначеЕсли Тип1С=Тип("Дата") Тогда
			//Type = 134;	// adDBTime
			Если НачалоДня(Значение1С)=Значение1С Тогда
				Type = intTypeADO("adDBDate");		// 133 
			Иначе
				Type = intTypeADO("adDBTimeStamp"); // 135 
			КонецЕсли; 
		ИначеЕсли Тип1С=Тип("Булево") Тогда
			Type = intTypeADO("adBoolean");	// 11
		ИначеЕсли Тип1С=Тип("УникальныйИдентификатор") Тогда
			Type = intTypeADO("adBinary");	// 128
			Size = 16;
		Иначе
			Если Ссылка <> Неопределено Тогда
				// ссылочный тип - преобразуем в COMSafeArray
				Type = intTypeADO("adBinary");	// 128
				Size = 16;
			Иначе
				Type = intTypeADO("adEmpty");	// 0? (Default)
			КонецЕсли; 
		КонецЕсли;
	КонецЕсли;
	
	// ADOUtils.V8DateToDBDate( Дата )				// с учетом YearOffset
	// ADOUtils.BooleanParameter( Значение )		// COMSafeArray(1)
	// ADOUtils.TypeParameter( Значение )			// COMSafeArray(1)	*_TYPE
	// ADOUtils.TableNumberParameter( Значение )	// COMSafeArray(4)	*_RTRef 
	// ADOUtils.DataVersionParameter( Значение )	// COMSafeArray(8)  _Version
	// ADOUtils.RRefParameter( Значение )			// COMSafeArray(16)	*IDRRef	
	
	Если Ложь
		Или Type = intTypeADO("adBinary") // 128
		Или Type = intTypeADO("adVarBinary") 
	Тогда // 204
		//Если ADOUtils = Неопределено Тогда
		//	ADOUtils = ПолучитьADOUtils();
		//	Если ADOUtils = Неопределено Тогда
		//		ADOUtils = Null; // для избежания повторных инициализаций
		//	КонецЕсли; 
		//КонецЕсли; 
		Если Ссылка <> Неопределено Тогда
			// ссылочный тип - преобразуем в COMSafeArray(16)
			ЗначениеADO = СсылкаToCOMSafeArray(Ссылка);
			//Если ADOUtils = Неопределено ИЛИ ADOUtils = Null Тогда
			//	ЗначениеADO = СсылкаToCOMSafeArray(Ссылка);
			//Иначе
			//	ЗначениеADO = ADOUtils.RRefParameter(Ссылка);
			//КонецЕсли; 
		ИначеЕсли Тип1С=Тип("УникальныйИдентификатор") Тогда
			// ГУИД - преобразуем в COMSafeArray(16)
			ЗначениеADO = GUIDToCOMSafeArray(Значение1С);
		ИначеЕсли Тип1С=Тип("Булево") Тогда
			// Булево - преобразуем в COMSafeArray(1)
			ЗначениеADO = СтрокаHEXtoCOMSafeArray(?(Значение1С,"0x01","0x00"));
			//Если ADOUtils = Неопределено ИЛИ ADOUtils = Null Тогда
			//	ЗначениеADO = СтрокаHEXtoCOMSafeArray(?(Значение1С,"0x01","0x00"));
			//Иначе
			//	ЗначениеADO = ADOUtils.BooleanParameter(Значение1С);
			//КонецЕсли; 
		Иначе
		КонецЕсли; 
	КонецЕсли;
		
	Если Precision=Неопределено Тогда
		Если Ложь
			Или Type = intTypeADO("adDecimal")		// 14 
			ИЛИ Type = intTypeADO("adNumeric")		// 131
			ИЛИ Type = intTypeADO("adVarNumeric")		// 139
		Тогда
			Precision = СтрДлина(СтрЗаменить(Строка(Значение1С)," ",""));
		КонецЕсли; 
	КонецЕсли;
	
	Если NumericScale=Неопределено Тогда
		Если Ложь
			Или Type = intTypeADO("adDecimal")		// 14 
			ИЛИ Type = intTypeADO("adNumeric")		// 131
			ИЛИ Type = intTypeADO("adVarNumeric")		// 139
		Тогда
			NumericScale = СтрДлина(Строка(Значение1С-Цел(Значение1С)));
		КонецЕсли; 
	КонецЕсли; 
	
	Если Size=Неопределено Тогда
		Если Ложь
			Или Type = intTypeADO("adChar")			// 129 
			ИЛИ  Type = intTypeADO("adWChar")			// 130
			ИЛИ  Type = intTypeADO("adVarChar")		// 200
			//ИЛИ  Type = intTypeADO("adLongVarChar")	// 201
			ИЛИ  Type = intTypeADO("adVarWChar")		// 202
			//ИЛИ  Type = intTypeADO("adLongVarWChar")	// 203
		Тогда
			Size = СтрДлина(Значение1С);
		КонецЕсли; 
	КонецЕсли;
КонецПроцедуры

// создает массив объектов ADODB.Parameter по списку параметров ADO и по списку типов ADO
Функция ParametersArrayПолучить(стПараметры,стПарТипADO, ADOUtils = Неопределено) Экспорт
	ParametersArray = Новый Массив;
	
	ТипаМассив = Тип("Массив");
	ТипаСоответствие = Тип("Соответствие");
	
	cтПараметрыТип = ТипЗнч(стПараметры);
	cтПарТипADOТип = ТипЗнч(стПарТипADO);
	
	Если стПараметры = Неопределено Тогда
		Возврат ParametersArray;
	ИначеЕсли cтПараметрыТип = ТипаМассив ИЛИ cтПараметрыТип = ТипаСоответствие Тогда
		Если стПарТипADO <> Неопределено И cтПарТипADOТип <> cтПараметрыТип Тогда
			ВызватьИсключение( 
			"Тип значения списка типов параметров ADO ('"+cтПарТипADOТип+"') не равен
			|типу значения списка параметров запроса ('"+cтПараметрыТип+"') !");
		КонецЕсли; 
	Иначе
		ВызватьИсключение( 
		"Не предусмотренный тип значения списка параметров запроса ('"+cтПараметрыТип+"') !");
	КонецЕсли;
	
	ОбъектЗапрос = Новый COMОбъект("ADODB.Command");
	
	Индекс = 0;
	Для каждого Параметр Из стПараметры Цикл
		Если cтПараметрыТип = ТипаМассив Тогда
			ПараметрИмя = Неопределено;
			Значение1С = Параметр;
		ИначеЕсли cтПараметрыТип = ТипаСоответствие Тогда
			ПараметрИмя = СокрЛП(Параметр.Ключ);
			Значение1С = Параметр.Значение;
		Иначе
			Продолжить;
		КонецЕсли; 
		Индекс = Индекс + 1;
		стТипADO=Неопределено;
		Если cтПарТипADOТип=ТипаМассив Тогда
			Если Индекс<=стПарТипADO.Количество()-1 Тогда
				стТипADO = стПарТипADO.Получить(Индекс);
			КонецЕсли; 
		ИначеЕсли cтПарТипADOТип = ТипаСоответствие Тогда
			стТипADO = стПарТипADO.Получить(Параметр.Ключ);
		КонецЕсли; 
		
		ЗначениеADO = Неопределено;
		Attributes = Неопределено;
		Direction = Неопределено;
		Type = Неопределено; 
		Precision = Неопределено;
		NumericScale = Неопределено;
		Size = Неопределено; // прочитаем свойства параметра ADO по полученной структуре типа и значению 1С
		ParameterADOСвойства(стТипADO,Значение1С,ЗначениеADO,Direction,Type,Precision,NumericScale,Size,Attributes,ADOUtils);
		
		// создадим параметр ADO и заполним его свойства
		Parameter = ОбъектЗапрос.CreateParameter();
		Если НЕ ПустаяСтрока(Type) Тогда
			Parameter.Type=Type;
		КонецЕсли; 
		Если НЕ ПустаяСтрока(Direction) Тогда
			Parameter.Direction=Direction;
		КонецЕсли; 
		Если НЕ ПустаяСтрока(Size) Тогда
			Parameter.Size=Size;
		КонецЕсли;
		Если НЕ ПустаяСтрока(Attributes) Тогда
			Parameter.Attributes=Attributes;
		КонецЕсли;
		Если НЕ ПустаяСтрока(ПараметрИмя) Тогда
			Parameter.Name = ПараметрИмя;
		КонецЕсли;
		Если ЗначениеADO = Неопределено Тогда
			Parameter.Value=Значение1С; // преобразование не явное
		Иначе
			Parameter.Value=ЗначениеADO; 
		КонецЕсли; 
		
		// добавим в массив
		ParametersArray.Добавить(Parameter);
	КонецЦикла;
	
	Возврат ParametersArray;
КонецФункции // ParametersArrayПолучить()

// формирует массив или соответствие со значениями параметров запроса из строки таблицы значений
Функция стПараметры_Получить_ТЗ(тзПараметры,СтрокаПараметров,NamedParameters,Знач ParametersPrefix) Экспорт 
	Если NamedParameters=Истина Тогда
		ParametersPrefix=СокрЛП(ParametersPrefix);
		стПараметры=Новый Соответствие;
		Для каждого Колонка Из тзПараметры.Колонки Цикл
			стПараметры.Вставить(ParametersPrefix+Колонка.Имя,СтрокаПараметров.Получить(тзПараметры.Колонки.Индекс(Колонка)));
		КонецЦикла;
	Иначе
		стПараметры=Новый Массив;
		Для каждого Колонка Из тзПараметры.Колонки Цикл
			стПараметры.Добавить(СтрокаПараметров.Получить(тзПараметры.Колонки.Индекс(Колонка)));
		КонецЦикла;
	КонецЕсли; 
	Возврат стПараметры;
КонецФункции // стПараметры_Получить_ТЗ()

// добавляет и устанавливает объект ADODB.Parameter в коллекцию параметров
// если не заданы свойства параметра ADO, делается попытка их подбора по типу значения 1С
Функция ADODBCommand_УстановитьПараметрПо1С(ОбъектЗапрос,Инициализация,Индекс,Name,стТипADO,Значение1С,ADOUtils,ЕррорИнфо) Экспорт
	ЗначениеADO=Неопределено;
	Attributes=Неопределено;
	Direction=Неопределено;
	Type=Неопределено; 
	Precision=Неопределено;
	NumericScale=Неопределено;
	Size=Неопределено; // прочитаем свойства параметра ADO из переданной структуры по значению 1С
	ParameterADOСвойства(стТипADO,Значение1С,ЗначениеADO,Direction,Type,Precision,NumericScale,Size,Attributes,ADOUtils);
		
	ЕррорИнфо="";
	Попытка
		Если ОбъектЗапрос.Prepared = Ложь ИЛИ Инициализация <> Ложь Тогда
			// инициализация параметров запроса
			Добавить = Ложь;
			Если Name = Неопределено Тогда
				// по переданному индексу параметра
				Parameter = ОбъектЗапрос.CreateParameter();
				Добавить = Истина; // создаем без имени
			Иначе
				// по переданному имени параметра
				Попытка
					// если уже есть параметр с именем - используем его
					Parameter = ОбъектЗапрос.Parameters.Item(Name);
				Исключение
					Parameter = Неопределено;
				КонецПопытки;
				Если Parameter = Неопределено Тогда
					// если нет - создаем с указанным именем
					Parameter = ОбъектЗапрос.CreateParameter();
					Parameter.Name = Name;
					Добавить = Истина;
				КонецЕсли;
			КонецЕсли; 
			Если НЕ ПустаяСтрока(Type) Тогда
				Parameter.Type=Type;
			КонецЕсли; 
			Если НЕ ПустаяСтрока(Direction) Тогда
				Parameter.Direction=Direction;
			КонецЕсли; 
			Если НЕ ПустаяСтрока(Size) Тогда
				Parameter.Size=Size;
			КонецЕсли;
			Если НЕ ПустаяСтрока(Attributes) И Attributes <> 0 Тогда
				Parameter.Attributes=Attributes;
			КонецЕсли;
			Если Добавить = Истина Тогда
				ОбъектЗапрос.Parameters.Append(Parameter);
			КонецЕсли; 
		Иначе
			// установка параметра предварительно подготовленного параметризованного запроса 
			Если Name = Неопределено Тогда
				// по переданному индексу параметра
				Parameter = ОбъектЗапрос.Parameters.Item(Индекс);
			Иначе
				// по переданному имени параметра
				Parameter = ОбъектЗапрос.Parameters.Item(Name);
			КонецЕсли; 
		КонецЕсли; 
		Если ЗначениеADO = Неопределено Тогда
			Parameter.Value=Значение1С; // преобразование не явное
		Иначе
			Parameter.Value=ЗначениеADO; 
		КонецЕсли; 
	Исключение
		ЕррорИнфо=ОписаниеОшибки();
		Возврат Ложь;
	КонецПопытки;
	
	Возврат Истина;
КонецФункции

// ^^^ УСТАНОВКА ПАРАМЕТРОВ ЗАПРОСА ADO  ^^^

// *** ПЕРЕЧИСЛЕНИЯ ADO ***

// возвращает строковое представление типа параметра ADO(свойства Direction) по его числовому значению 
Функция strDirectionParADO(intTypeADO) Экспорт  
	intType = Цел(intTypeADO);  
	Если intType = 0 Тогда Возврат "adParamUnknown";			// Direction unknown		     
	ИначеЕсли intType = 1 Тогда Возврат "adParamInput";			// Input parameter (Default)
	ИначеЕсли intType = 2 Тогда Возврат "adParamOutput";		// Output parameter
	ИначеЕсли intType = 3 Тогда Возврат "adParamInputOutput";	// Input and output parameter
	ИначеЕсли intType = 4 Тогда Возврат "adParamReturnValue";	// Return value 
	Иначе Возврат "adParamInput"; // как 1 
	КонецЕсли;                                            
 КонецФункции

// возвращает числовое значения типа параметра ADO(свойства Direction) по его числовому представлению
Функция intDirectionParADO(strTypeADO) Экспорт  
	strType = НРег(strTypeADO);  
	Если strType = Нрег("adParamUnknown") Тогда Возврат 0;			// Direction unknown		     
	ИначеЕсли strType = Нрег("adParamInput") Тогда Возврат 1;		// Input parameter (Default)
	ИначеЕсли strType = Нрег("adParamOutput") Тогда Возврат 2;		// Output parameter
	ИначеЕсли strType = Нрег("adParamInputOutput") Тогда Возврат 3;	// Input and output parameter
	ИначеЕсли strType = Нрег("adParamReturnValue") Тогда Возврат 4;	// Return value 
	Иначе Возврат 1; // adParamInput
	КонецЕсли;                                            
 КонецФункции
 
// возвращает строковое представление типа значения ADO по его числовому значению  
Функция strTypeADO(intTypeADO) Экспорт
	intType = Цел(intTypeADO);
	Если	  intType = 0 Тогда Возврат "adEmpty";			// no value
	ИначеЕсли intType = 2 Тогда Возврат "adSmallInt";		// 2-byte signed integer
	ИначеЕсли intType = 3 Тогда Возврат "adInteger";		// 4-byte signed integer
	ИначеЕсли intType = 4 Тогда Возврат "adSingle";			// single-precision floating-point value
	ИначеЕсли intType = 5 Тогда Возврат "adDouble";			// double-precision floating-point value
	ИначеЕсли intType = 6 Тогда Возврат "adCurrency";		// currency value
	ИначеЕсли intType = 7 Тогда Возврат "adDate";			// number of days since December 30, 1899 + the fraction of a day
	ИначеЕсли intType = 8 Тогда Возврат "adBSTR"; 			// null-terminated character string
	ИначеЕсли intType = 9 Тогда Возврат "adIDispatch";		// pointer to an IDispatch interface on a COM object(currently not supported by ADO)
	ИначеЕсли intType = 10 Тогда Возврат "adError";			// 32-bit error code
	ИначеЕсли intType = 11 Тогда Возврат "adBoolean"; 		// boolean value
	ИначеЕсли intType = 12 Тогда Возврат "adVariant";		// automation Variant(currently not supported by ADO)
	ИначеЕсли intType = 13 Тогда Возврат "adIUnknown";		// pointer to an IUnknown interface on a COM object(currently not supported by ADO)
	ИначеЕсли intType = 14 Тогда Возврат "adDecimal";		// exact numeric value with a fixed precision and scale
	ИначеЕсли intType = 16 Тогда Возврат "adTinyInt";			// 1-byte signed integer
	ИначеЕсли intType = 17 Тогда Возврат "adUnsignedTinyInt";	// 1-byte unsigned integer	
	ИначеЕсли intType = 18 Тогда Возврат "adUnsignedSmallInt";	// 2-byte unsigned integer
	ИначеЕсли intType = 19 Тогда Возврат "adUnsignedInt";		// 4-byte unsigned integer
	ИначеЕсли intType = 20 Тогда Возврат "adBigInt";			// 8-byte signed integer
	ИначеЕсли intType = 21 Тогда Возврат "adUnsignedBigInt";	// 8-byte unsigned integer
		
	ИначеЕсли intType = 64 Тогда Возврат "adFileTime"; 		// number of 100-nanosecond intervals since January 1,1601
	ИначеЕсли intType = 72 Тогда Возврат "adGUID";			// globally unique identifier (GUID)
		
	ИначеЕсли intType = 128 Тогда Возврат "adBinary";		// binary value
	ИначеЕсли intType = 129 Тогда Возврат "adChar";			// string value
	ИначеЕсли intType = 130 Тогда Возврат "adWChar";		// null-terminated Unicode character string
	ИначеЕсли intType = 131 Тогда Возврат "adNumeric";		// exact numeric value with a fixed precision and scale
	ИначеЕсли intType = 132 Тогда Возврат "adUserDefined";	// user-defined variable
	ИначеЕсли intType = 133 Тогда Возврат "adDBDate";		// date value (yyyymmdd)
	ИначеЕсли intType = 134 Тогда Возврат "adDBTime";		// time value (hhmmss)
	ИначеЕсли intType = 135 Тогда Возврат "adDBTimeStamp";	// date/time stamp (yyyymmddhhmmss plus a fraction in billionths)
	ИначеЕсли intType = 136 Тогда Возврат "adChapter";		// 4-byte chapter value that identifies rows in a child rowset
	ИначеЕсли intType = 138 Тогда Возврат "adPropVariant";	// automation PROPVARIANT
	ИначеЕсли intType = 139 Тогда Возврат "adVarNumeric";	// numeric value(Parameter object only)
		
	ИначеЕсли intType = 200 Тогда Возврат "adVarChar";		// string value (Parameter object only)
	ИначеЕсли intType = 201 Тогда Возврат "adLongVarChar";	// long string value
	ИначеЕсли intType = 202 Тогда Возврат "adVarWChar";		// null-terminated Unicode character string
	ИначеЕсли intType = 203 Тогда Возврат "adLongVarWChar";	// long null-terminated Unicode string value
	ИначеЕсли intType = 204 Тогда Возврат "adVarBinary";	// binary value (Parameter object only)		
	ИначеЕсли intType = 205 Тогда Возврат "adLongVarBinary"; // long binary value
	ИначеЕсли intType = 8192 Тогда Возврат "AdArray";	// 0x2000, flag value combined with another data type constant, indicates an array of that other data type	
	Иначе Возврат "adEmpty"; // как 0
	КонецЕсли;
КонецФункции

// возвращает числовое значение типа значения ADO по его строковому представлению 
Функция intTypeADO(strTypeADO) Экспорт
	strType = НРег(strTypeADO);
	Если	  strType = НРег("adEmpty") Тогда Возврат 0;		// no value
	ИначеЕсли strType = НРег("adSmallInt") Тогда Возврат 2;		// 2-byte signed integer
	ИначеЕсли strType = НРег("adInteger") Тогда Возврат 3;		// 4-byte signed integer
	ИначеЕсли strType = НРег("adSingle") Тогда Возврат 4;		// single-precision floating-point value
	ИначеЕсли strType = НРег("adDouble") Тогда Возврат 5;		// double-precision floating-point value
	ИначеЕсли strType = НРег("adCurrency") Тогда Возврат 6;		// currency value
	ИначеЕсли strType = НРег("adDate") Тогда Возврат 7;			// number of days since December 30, 1899 + the fraction of a day
	ИначеЕсли strType = НРег("adBSTR") Тогда Возврат 8; 		// null-terminated character string
	ИначеЕсли strType = НРег("adIDispatch") Тогда Возврат 9;	// pointer to an IDispatch interface on a COM object(currently not supported by ADO)
	ИначеЕсли strType = НРег("adError") Тогда Возврат 10;		// 32-bit error code
	ИначеЕсли strType = НРег("adBoolean") Тогда Возврат 11; 	// boolean value
	ИначеЕсли strType = НРег("adVariant") Тогда Возврат 12;		// automation Variant(currently not supported by ADO)
	ИначеЕсли strType = НРег("adIUnknown") Тогда Возврат 13;	// pointer to an IUnknown interface on a COM object(currently not supported by ADO)
	ИначеЕсли strType = НРег("adDecimal") Тогда Возврат 14;		// exact numeric value with a fixed precision and scale
	ИначеЕсли strType = НРег("adTinyInt") Тогда Возврат 16;			// 1-byte signed integer
	ИначеЕсли strType = НРег("adUnsignedTinyInt") Тогда Возврат 17; // 1-byte unsigned integer	
	ИначеЕсли strType = НРег("adUnsignedSmallInt") Тогда Возврат 18;// 2-byte unsigned integer
	ИначеЕсли strType = НРег("adUnsignedInt") Тогда Возврат 19;		// 4-byte unsigned integer
	ИначеЕсли strType = НРег("adBigInt") Тогда Возврат 20;			// 8-byte signed integer
	ИначеЕсли strType = НРег("adUnsignedBigInt") Тогда Возврат 21;	// 8-byte unsigned integer
		
	ИначеЕсли strType = НРег("adFileTime") Тогда Возврат 64; 		// number of 100-nanosecond intervals since January 1,1601
	ИначеЕсли strType = НРег("adGUID") Тогда Возврат 72;			// globally unique identifier (GUID)
		
	ИначеЕсли strType = НРег("adBinary") Тогда Возврат 128;			// binary value
	ИначеЕсли strType = НРег("adChar") Тогда Возврат 129;			// string value
	ИначеЕсли strType = НРег("adWChar") Тогда Возврат 130;			// null-terminated Unicode character string
	ИначеЕсли strType = НРег("adNumeric") Тогда Возврат 131;		// exact numeric value with a fixed precision and scale
	ИначеЕсли strType = НРег("adUserDefined") Тогда Возврат 132;	// user-defined variable
	ИначеЕсли strType = НРег("adDBDate") Тогда Возврат 133;			// date value (yyyymmdd)
	ИначеЕсли strType = НРег("adDBTime") Тогда Возврат 134;			// time value (hhmmss)
	ИначеЕсли strType = НРег("adDBTimeStamp") Тогда Возврат 135;	// date/time stamp (yyyymmddhhmmss plus a fraction in billionths)
	ИначеЕсли strType = НРег("adChapter") Тогда Возврат 136;		// 4-byte chapter value that identifies rows in a child rowset
	ИначеЕсли strType = НРег("adPropVariant") Тогда Возврат 138;	// automation PROPVARIANT
	ИначеЕсли strType = НРег("adVarNumeric") Тогда Возврат 139;		// numeric value(Parameter object only)
		
	ИначеЕсли strType = НРег("adVarChar") Тогда Возврат 200;		// string value (Parameter object only)
	ИначеЕсли strType = НРег("adLongVarChar") Тогда Возврат 201;	// long string value
	ИначеЕсли strType = НРег("adVarWChar") Тогда Возврат 202;		// null-terminated Unicode character string
	ИначеЕсли strType = НРег("adLongVarWChar") Тогда Возврат 203;	// long null-terminated Unicode string value
	ИначеЕсли strType = НРег("adVarBinary") Тогда Возврат 204;		// binary value (Parameter object only)		
	ИначеЕсли strType = НРег("adLongVarBinary") Тогда Возврат 205;	// long binary value
	ИначеЕсли strType = НРег("AdArray") Тогда Возврат 8192;	// 0x2000, flag value combined with another data type constant, indicates an array of that other data type	
	Иначе Возврат 0; // adEmpty
	КонецЕсли;
КонецФункции

// возвращает числовое значение типа курсора по его строковому представлению 
Функция strCursorType(intValue) Экспорт
	Если ТипЗнч(intValue) = Тип("Число") Тогда
		intV = Цел(intValue);  
	Иначе
		intV = 0;  
	КонецЕсли; 
	Если intV = -1 Тогда Возврат "adOpenUnspecified";		// Does not specify the type of cursor		     
	ИначеЕсли intV = 0 Тогда Возврат "adOpenForwardOnly";	// Default. Uses a forward-only cursor. Like a static cursor, except... (Default)
	ИначеЕсли intV = 1 Тогда Возврат "adOpenKeyset";		// Uses a keyset cursor. Like a dynamic cursor, except...
	ИначеЕсли intV = 2 Тогда Возврат "adOpenDynamic";		// Uses a dynamic cursor
	ИначеЕсли intV = 3 Тогда Возврат "adOpenStatic";		// Uses a static cursor
	Иначе Возврат "adOpenForwardOnly"; // как 0 
	КонецЕсли;                                            
КонецФункции

// возвращает строковое представление типа курсора по его числовому значению 
Функция intCursorType(strValue) Экспорт
	strV = Нрег(strValue);  
	Если strV = Нрег("adOpenUnspecified") Тогда Возврат -1;		// Does not specify the type of cursor		     
	ИначеЕсли strV = Нрег("adOpenForwardOnly") Тогда Возврат 0;	// Default. Uses a forward-only cursor. Like a static cursor, except... (Default
	ИначеЕсли strV = Нрег("adOpenKeyset") Тогда Возврат 1;		// Uses a keyset cursor. Like a dynamic cursor, except...
	ИначеЕсли strV = Нрег("adOpenDynamic") Тогда Возврат 2;		// Uses a dynamic cursor
	ИначеЕсли strV = Нрег("adOpenStatic") Тогда Возврат 3;		// Uses a static cursor
	Иначе Возврат 0; // adOpenForwardOnly 
	КонецЕсли;                                            
КонецФункции 

// возвращает числовое значение местоположения курсора по его строковому представлению 
Функция strCursorLocation(intValue) Экспорт
	Если ТипЗнч(intValue) = Тип("Число") Тогда
		intV = Цел(intValue);  
	Иначе
		intV = 0;  
	КонецЕсли; 
	Если intV = 1 Тогда Возврат "adUseNone";			// Does not use cursor services		     
	ИначеЕсли intV = 2 Тогда Возврат "adUseServer";		// Uses a server-side cursor (Default)
	ИначеЕсли intV = 3 Тогда Возврат "adParamOutput";	// Uses a client-side cursor supplied by a local cursor library
	Иначе Возврат "adUseServer"; // как 2 
	КонецЕсли;                                            
КонецФункции

// возвращает строковое представление местоположения курсора по его числовому значению 
Функция intCursorLocation(strValue) Экспорт
	strV = Нрег(strValue);  
	Если strV = Нрег("adUseNone") Тогда Возврат 1;			// Does not use cursor services		     
	ИначеЕсли strV = Нрег("adUseServer") Тогда Возврат 2;	// Uses a server-side cursor (Default)
	ИначеЕсли strV = Нрег("adParamOutput") Тогда Возврат 3;	// Uses a client-side cursor supplied by a local cursor library
	Иначе Возврат 2; // adUseServer 
	КонецЕсли;                                            
КонецФункции 

// возвращает числовое значение типа блокировки данных по его строковому представлению 
Функция strLockType(intValue) Экспорт
	Если ТипЗнч(intValue) = Тип("Число") Тогда
		intV = Цел(intValue);  
	Иначе
		intV = 0;  
	КонецЕсли; 
	Если intV = -1 Тогда Возврат "adLockUnspecified";			// Unspecified type of lock. Clones inherits lock type from the original Recordset		     
	ИначеЕсли intV = 1 Тогда Возврат "adLockReadOnly";			// Read-only records
	ИначеЕсли intV = 2 Тогда Возврат "adLockPessimistic";		// Pessimistic locking, record by record. The provider lock records immediately after editing
	ИначеЕсли intV = 3 Тогда Возврат "adLockOptimistic";		// Optimistic locking, record by record. The provider lock records only when calling update
	ИначеЕсли intV = 4 Тогда Возврат "adLockBatchOptimistic";	// Optimistic batch updates. Required for batch update mode
	Иначе Возврат "adLockUnspecified"; // как -1 
	КонецЕсли;                                            
КонецФункции

// возвращает строковое представление типа блокировки данных по его числовому значению 
Функция intLockType(strValue) Экспорт
	strV = Нрег(strValue);  
	Если strV = Нрег("adLockUnspecified") Тогда Возврат -1;			// Unspecified type of lock		     
	ИначеЕсли strV = Нрег("adLockReadOnly") Тогда Возврат 1;		// Read-only records
	ИначеЕсли strV = Нрег("adLockPessimistic") Тогда Возврат 2;		// Pessimistic locking, record by record. The provider lock records immediately after editing
	ИначеЕсли strV = Нрег("adLockOptimistic") Тогда Возврат 3;		// Optimistic locking, record by record. The provider lock records only when calling update
	ИначеЕсли strV = Нрег("adLockBatchOptimistic") Тогда Возврат 4;	// Optimistic batch updates. Required for batch update mode
	Иначе Возврат -1; // adLockUnspecified 
	КонецЕсли;                                            
КонецФункции 

// возвращает числовое значение опции MarshalOptions по его строковому представлению 
Функция strMarshalOptions(intValue) Экспорт
	Если ТипЗнч(intValue) = Тип("Число") Тогда
		intV = Цел(intValue);  
	Иначе
		intV = 0;  
	КонецЕсли; 
	Если intV = 0 Тогда Возврат "adMarshalAll";						// Returns all rows (Default)		     
	ИначеЕсли intV = 1 Тогда Возврат "adMarshalModifiedOnly";		// Returns only modified rows 
	Иначе Возврат "adMarshalAll"; // как 0 
	КонецЕсли;                                            
КонецФункции

// возвращает строковое представление опции MarshalOptions по его числовому значению 
Функция intMarshalOptions(strValue) Экспорт
	strV = Нрег(strValue);  
	Если strV = Нрег("adMarshalAll") Тогда Возврат 0;				// Returns all rows (Default)		     
	ИначеЕсли strV = Нрег("adMarshalModifiedOnly") Тогда Возврат 1;	// Returns only modified rows
	Иначе Возврат 0; // adMarshalAll 
	КонецЕсли;                                            
КонецФункции 

// возвращает строковое представление типа команды ADO по его числовому значению 
Функция strCommandTypeADO(intTypeADO) Экспорт
	Если ТипЗнч(intTypeADO) = Тип("Число") Тогда
		intType = Цел(intTypeADO);  
	Иначе
		intType = 0;  
	КонецЕсли; 
	Если 	  intType = -1 Тогда Возврат "adCmdUnspecified";	// Unspecified type of command 
	ИначеЕсли intType = 1 Тогда Возврат "adCmdText";			// строка оператора T-SQL
	ИначеЕсли intType = 2 Тогда Возврат "adCmdTable";			// имя таблицы для выборки строк
	ИначеЕсли intType = 4 Тогда Возврат "adCmdStoredProc"; 		// имя хранимой процедуры
	ИначеЕсли intType = 8 Тогда Возврат "adCmdUnknown";			// неизвестно, проверять провайдером (Default)
	ИначеЕсли intType = 256 Тогда Возврат "adCmdFile";			// имя файла of a persistently stored Recordset (with Recordset.Open or Requery only)
	ИначеЕсли intType = 512 Тогда Возврат "adCmdTableDirect";	// имя таблицы whose columns are all returned   (with Recordset.Open or Requery only)
	Иначе Возврат "adCmdUnknown"; // как 8 
	КонецЕсли;
КонецФункции

// возвращает числовое значение типа команды ADO по его строковому представлению 
Функция intCommandTypeADO(strTypeADO) Экспорт
	strType = Нрег(strTypeADO);
	Если	  strType = Нрег("adCmdUnspecified") Тогда Возврат -1;	// Unspecified type of command 
	ИначеЕсли strType = Нрег("adCmdText") Тогда Возврат 1;			// строка оператора T-SQL
	ИначеЕсли strType = Нрег("adCmdTable") Тогда Возврат 2;			// имя таблицы для выборки строк
	ИначеЕсли strType = Нрег("adCmdStoredProc") Тогда Возврат 4; 	// имя хранимой процедуры
	ИначеЕсли strType = Нрег("adCmdUnknown") Тогда Возврат 8;		// неизвестно, проверять провайдером (Default)
	ИначеЕсли strType = Нрег("adCmdFile") Тогда Возврат 256;		// имя файла of a persistently stored Recordset (with Recordset.Open or Requery only)
	ИначеЕсли strType = Нрег("adCmdTableDirect") Тогда Возврат 512;	// имя таблицы whose columns are all returned   (with Recordset.Open or Requery only)
	Иначе Возврат 8; // adCmdUnknown
	КонецЕсли;
КонецФункции

// возвращает строковое представление типа команды ADO по его числовому значению 
Функция strExecuteOption(intValue) Экспорт
	Если ТипЗнч(intValue) = Тип("Число") Тогда
		intV = Цел(intValue);  
	Иначе
		intV = 0;  
	КонецЕсли; 
	Если	  intV = -1 Тогда Возврат "adOptionUnspecified";		// Unspecified command
	ИначеЕсли intV = 16 Тогда Возврат "adAsyncExecute";				// The command should execute asynchronously
	ИначеЕсли intV = 32 Тогда Возврат "adAsyncFetch"; 				// The remaining rows after specified in the CacheSize should be retrieved asynchronously
	ИначеЕсли intV = 64 Тогда Возврат "adAsyncFetchNonBlocking";	// The main thread never blocks while retrieving.
	ИначеЕсли intV = 128 Тогда Возврат "adExecuteNoRecords";		// Discard, not return retrieved rows (with Command or Connection.Execute only)
	ИначеЕсли intV = 256 Тогда Возврат "adExecuteStream";			// The results of a command execution is a stream (with Connection.Execute only)
	ИначеЕсли intV = 512 Тогда Возврат "adExecuteRecord";			// Return a single row as a Record object 
	Иначе Возврат "adOptionUnspecified"; // как -1
	КонецЕсли;
КонецФункции

// возвращает числовое значение типа команды ADO по его строковому представлению 
Функция intExecuteOption(strValue) Экспорт
	strV = Нрег(strValue);
	Если	  strV = Нрег("adOptionUnspecified") Тогда Возврат -1;	// Unspecified command
	ИначеЕсли strV = Нрег("adAsyncExecute") Тогда Возврат 16;		// The command should execute asynchronously
	ИначеЕсли strV = Нрег("adAsyncFetch") Тогда Возврат 32; 		// The remaining rows after specified in the CacheSize should be retrieved asynchronously
	ИначеЕсли strV = Нрег("adAsyncFetchNonBlocking") Тогда Возврат 64; // The main thread never blocks while retrieving
	ИначеЕсли strV = Нрег("adExecuteNoRecords") Тогда Возврат 128;	   // Discard, not return retrieved rows (with Command or Connection.Execute only)
	ИначеЕсли strV = Нрег("adExecuteStream") Тогда Возврат 256;		   // The results of a command execution is a stream (with Connection.Execute only)
	ИначеЕсли strV = Нрег("adExecuteRecord") Тогда Возврат 512;		   // Return a single row as a Record object 
	Иначе Возврат -1; // adOptionUnspecified
	КонецЕсли;
КонецФункции

// возвращает строковое представление опции аттрибутов параметра ADO по числовому значению опции 
Функция strParameterADOAttributes(intValue) Экспорт
	Если ТипЗнч(intValue) = Тип("Число") Тогда
		intV = Цел(intValue);  
	Иначе
		intV = 0;  
	КонецЕсли; 
	Если	  intV = 16 Тогда Возврат "adParamSigned";			// The parameter will accept signed values.
	ИначеЕсли intV = 64 Тогда Возврат "adParamNullAble";		// The parameter will accept null values.
	ИначеЕсли intV = 128 Тогда Возврат "adParamLong";			// The parameter will accept long binary data.
	Иначе Возврат "adParamSigned"; // как 16
	КонецЕсли;
КонецФункции

// возвращает числовое значение оцции аттрибутов параметра ADO по строковому представлению опции 
Функция intParameterADOAttributes(strValue) Экспорт
	strV = Нрег(strValue);
	Если strV = Нрег("adParamSigned") Тогда Возврат 16;			// The parameter will accept signed values.
	ИначеЕсли strV = Нрег("adParamNullAble") Тогда Возврат 64;	// The parameter will accept null values.
	ИначеЕсли strV = Нрег("adParamLong") Тогда Возврат 128;		// The parameter will accept long binary data.
	Иначе Возврат 16; // adParamSigned
	КонецЕсли;
КонецФункции

// ^^^ ПЕРЕЧИСЛЕНИЯ ADO ^^^

// ADO
// ************************

// В платформе все корневые элементы древовидных структур содержат в свойстве Родитель Неопределено.
// Поэтому возникает неудобство при работе с этим свойством, заключающееся в необходимости часто проверять его значение на Неопределено.
// Параметры:
//    СтрокаДерева - СтрокаДереваЗначений, <Элемент любого иерархического объекта, имеющий родителя> 
//    Дерево - <Иерархический объект, которому принадлежит элемент> - для дерева значений не нужно передавать
//
Функция ПолучитьРодителяСтрокиДереваЛкс(СтрокаДерева, Дерево = Неопределено) Экспорт
	
	Родитель = СтрокаДерева.Родитель;
	Если Родитель = Неопределено Тогда
		Если Дерево = Неопределено Тогда
			Родитель = СтрокаДерева.Владелец();
		Иначе
			Родитель = Дерево;
		КонецЕсли; 
	КонецЕсли;
	Возврат Родитель;

КонецФункции

#КонецЕсли

#Если Не ТонкийКлиент И Не ВебКлиент И Клиент Тогда

Функция ПолучитьКоординатыСтрокиДереваЛкс(СтрокаДерева, ИмяКлючевойКолонки = "") Экспорт
	
	Координаты = Новый Массив();
	Родитель = СтрокаДерева;
	Пока Родитель <> Неопределено Цикл
		Если ЗначениеЗаполнено(ИмяКлючевойКолонки) Тогда
			Координата = Родитель[ИмяКлючевойКолонки];
		Иначе
			Координата = ирНеглобальный.ПолучитьРодителяСтрокиДереваЛкс(Родитель).Строки.Индекс(Родитель);
		КонецЕсли; 
		Координаты.Вставить(0, Координата);
		Родитель = Родитель.Родитель;
	КонецЦикла;
	Возврат Координаты;
	
КонецФункции

Функция ПолучитьСтрокуДереваПоКоординатамЛкс(Дерево, Координаты, ИмяКлючевойКолонки = "") Экспорт
	
	СтрокаДерева = Дерево;
	Для Каждого Координата Из Координаты Цикл
		Если ЗначениеЗаполнено(ИмяКлючевойКолонки) Тогда
			СтрокаДерева = СтрокаДерева.Строки.Найти(Координата, ИмяКлючевойКолонки);
		Иначе
			СтрокаДерева = СтрокаДерева.Строки[Координата];
		КонецЕсли; 
	КонецЦикла; 
	Возврат СтрокаДерева;
	
КонецФункции

Процедура УстановитьТекстПоляСохраняяПозициюЛкс(ПолеТекстовогоДокумента, НовыйТекст) Экспорт
	
	НачальнаяКолонка = 0; НачальнаяСтрока = 0; КонечнаяКолонка = 0; КонечнаяСтрока = 0;
	ПолеТекстовогоДокумента.ПолучитьГраницыВыделения(НачальнаяСтрока, НачальнаяКолонка, КонечнаяСтрока, КонечнаяКолонка);
	ПолеТекстовогоДокумента.УстановитьТекст(НовыйТекст);
	ПолеТекстовогоДокумента.УстановитьГраницыВыделения(НачальнаяСтрока, НачальнаяКолонка, КонечнаяСтрока, КонечнаяКолонка);
		
КонецПроцедуры
	
Функция ПреобразоватьЗначениеИзSDBLЛкс(ЗначениеSDBL) Экспорт
	
	Фрагменты = ЛксПолучитьМассивИзСтрокиСРазделителем(ЗначениеSDBL, ":");
	ПолноеИмяМД = ПолучитьМетаданныеПоНомеруСсылочнойТаблицыЛкс(Фрагменты[0]);
	Если Не ЗначениеЗаполнено(ПолноеИмяМД) Тогда
		Возврат Неопределено;
	КонецЕсли; 
	СтруктураБД = ирКэш.ПолучитьСтруктуруХраненияБДЛкс(Ложь);
	
	// Этот способ не работал для перечислений
	//УникальныйИдентификатор = Новый УникальныйИдентификатор(ЛксПолучитьГУИДПрямойИзИнверсного(Фрагменты[1]));
	//Массив = Новый Массив();
	//Если ЗначениеЗаполнено(УникальныйИдентификатор) Тогда
	//	Массив.Добавить(УникальныйИдентификатор);
	//КонецЕсли; 
	//Значение = Новый (Тип(СтрЗаменить(ПолноеИмяМД, ".", "Ссылка.")), Массив);
	//
	ПустаяСсылка = Новый (Тип(СтрЗаменить(ПолноеИмяМД, ".", "Ссылка.")));
	ПустаяСсылкаВнутр = ЗначениеВСтрокуВнутр(ПустаяСсылка);
	ФрагментыПустойСсылки = ЛксПолучитьМассивИзСтрокиСРазделителем(ПустаяСсылкаВнутр, ":");
	СсылкаВнутр = ФрагментыПустойСсылки[0] + ":" + Фрагменты[1] + "}";
	Попытка
		Значение = ЗначениеИзСтрокиВнутр(СсылкаВнутр);
	Исключение
		// Например, если Фрагменты[1] содержит неверное число символов
		Значение = Неопределено;
	КонецПопытки;
	Возврат Значение;
	
КонецФункции

Функция ПолучитьМетаданныеПоНомеруСсылочнойТаблицыЛкс(СтрокаНомерТаблицы) Экспорт
	
	СтруктураХраненияБазыДанных = ирКэш.ПолучитьСтруктуруХраненияБДЛкс();
	#Если _ Тогда
	    СтруктураХраненияБазыДанных = Новый ТаблицаЗначений;
	#КонецЕсли
	СловарьШаблоновМетаданных = ирКэш.ПолучитьСловарьШаблоновМетаданных();
	Для Каждого СтрокаШаблона Из СловарьШаблоновМетаданных.НайтиСтроки(Новый Структура("Значение", 1)) Цикл
		ИмяКандидат = СтрЗаменить(СтрокаШаблона.Ключ, "1", СтрокаНомерТаблицы);
		СтрокаСтруктуры = СтруктураХраненияБазыДанных.Найти(ИмяКандидат, "КраткоеИмяТаблицыХранения");
		Если СтрокаСтруктуры <> Неопределено Тогда
			Возврат СтрокаСтруктуры.Метаданные;
		КонецЕсли; 
	КонецЦикла;
	
КонецФункции

Функция ПолучитьИндексКартинкиСловаПодсказкиЛкс(ДанныеСтроки) Экспорт

	Попытка
		ТипЗначения = ДанныеСтроки.ТипЗначения;
	Исключение
		ТипЗначения = Неопределено;
	КонецПопытки; 
	ИндексКартинки = -1;
	Если Ложь
		Или ДанныеСтроки.ТипСлова = "Ключевое слово"
		Или ДанныеСтроки.ТипСлова = "Конструкция"
	Тогда
		ИндексКартинки = 13;
	ИначеЕсли ТипЗначения = "Имя типа" Тогда
		ИндексКартинки = 12;
	ИначеЕсли ДанныеСтроки.ТипСлова = "Метод" Тогда
		Попытка
			Пустышка = ДанныеСтроки.Успех;
			ЕстьУспех = Истина;
		Исключение
			ЕстьУспех = Ложь;
		КонецПопытки;
		Если Ложь
			Или (Истина
				И ЕстьУспех
				И (Ложь
					Или ДанныеСтроки.ТаблицаСтруктурТипов = Неопределено
					Или ДанныеСтроки.ТаблицаСтруктурТипов.Количество() = 0
					Или ДанныеСтроки.ТаблицаСтруктурТипов[0].ИмяОбщегоТипа = ""))
			Или (Истина
				И Не ЕстьУспех
				И ДанныеСтроки.ТипЗначения = "")
		Тогда
			Если ДанныеСтроки.Определение = "Предопределенный" Тогда
				ИндексКартинки = 0;
			ИначеЕсли ДанныеСтроки.Определение = "Метаданные" Тогда
				ИндексКартинки = 6;
			//ИначеЕсли ДанныеСтроки.Определение = "Локальный" Тогда
			//	ИндексКартинки = 9;
			Иначе
				ИндексКартинки = 3;
			КонецЕсли;
		Иначе
			Если ДанныеСтроки.Определение = "Предопределенный" Тогда
				ИндексКартинки = 1;
			ИначеЕсли ДанныеСтроки.Определение = "Метаданные" Тогда
				ИндексКартинки = 7;
			//ИначеЕсли ДанныеСтроки.Определение = "Локальный" Тогда
			//	ИндексКартинки = 10;
			Иначе
				ИндексКартинки = 4;
			КонецЕсли;	
		КонецЕсли;
	ИначеЕсли ДанныеСтроки.ТипСлова = "Свойство" Тогда
		Если ДанныеСтроки.Определение = "Предопределенный" Тогда
			ИндексКартинки = 2;
		ИначеЕсли ДанныеСтроки.Определение = "Метаданные" Тогда
			ИндексКартинки = 8;
		//ИначеЕсли ДанныеСтроки.Определение = "Локальный" Тогда
		//	ИндексКартинки = 11;
		Иначе
			ИндексКартинки = 5;
		КонецЕсли;
	ИначеЕсли ДанныеСтроки.ТипСлова = "Таблица" Тогда
		ИндексКартинки = 14;
	ИначеЕсли ДанныеСтроки.ТипСлова = "Поле" Тогда
		Если ДанныеСтроки.Определение = "Предопределенный" Тогда
			ИндексКартинки = 15;
		Иначе
			ИндексКартинки = 16;
		КонецЕсли;
	ИначеЕсли ДанныеСтроки.ТипСлова = "Группа" Тогда
		ИндексКартинки = 18;
	КонецЕсли;
	Возврат ИндексКартинки;

КонецФункции

Процедура ОтладитьОбъектДляОтладки(Ссылка) Экспорт
	
	#Если _ Тогда
	    Ссылка = Справочники.ирОбъектыДляОтладки.ПустаяСсылка();
	#КонецЕсли
	
	Запрос = Новый Запрос;
	Запрос.Текст = "
	|ВЫБРАТЬ
	|	ирОбъектыДляОтладки.XML
	|ИЗ
	|	Справочник.ирОбъектыДляОтладки КАК ирОбъектыДляОтладки
	|ГДЕ
	|	ирОбъектыДляОтладки.Ссылка = &Ссылка
	|";
	Запрос.УстановитьПараметр("Ссылка", Ссылка);
	СтрокаРезультата = Запрос.Выполнить().Выгрузить()[0]; 
	
	ЧтениеXML = Новый ЧтениеXML;
	ЧтениеXML.УстановитьСтроку(СтрокаРезультата.XML);
	Попытка
		СтруктураПараметров = СериализаторXDTO.ПрочитатьXML(ЧтениеXML);
	Исключение
		ОписаниеОшибки = ОписаниеОшибки();
		Сообщить("Некорректный объект для отладки: " + ОписаниеОшибки, СтатусСообщения.Внимание);
		Возврат;
	КонецПопытки; 
	Объект = СтруктураПараметров.Объект;
	ТипОперации = СтруктураПараметров.ТипОперации;
	Если ТипОперации = "Отладить" Тогда
		Если ТипЗнч(Объект) = Тип("Структура") Тогда
			СтруктураЗапроса = Объект;
			Объект = Новый Запрос;
			Если Истина
				//И СтруктураЗапроса.Свойство("ВременныеТаблицы") 
				И СтруктураЗапроса.ВременныеТаблицы <> Неопределено
			Тогда
				Объект.МенеджерВременныхТаблиц = Новый МенеджерВременныхТаблиц;
				#Если Клиент Тогда
					ЛксСостояние("Подготовка временных таблиц");
				#КонецЕсли
				ТекстЗапросаПодготовки = "";
				Для Каждого КлючИЗначение Из СтруктураЗапроса.ВременныеТаблицы Цикл
					Если ТекстЗапросаПодготовки <> "" Тогда
						ТекстЗапросаПодготовки = ТекстЗапросаПодготовки + ";";
					КонецЕсли; 
					ТекстЗапросаПодготовки = ТекстЗапросаПодготовки + "ВЫБРАТЬ Т.* ПОМЕСТИТЬ " + КлючИЗначение.Ключ + " ИЗ &" + КлючИЗначение.Ключ + " КАК Т";
				КонецЦикла;
				Если ЗначениеЗаполнено(ТекстЗапросаПодготовки) Тогда
					Объект.Текст = ТекстЗапросаПодготовки;
					ЛксСкопироватьУниверсальнуюКоллекцию(СтруктураЗапроса.ВременныеТаблицы, Объект.Параметры);
					Объект.Выполнить();
				КонецЕсли; 
			КонецЕсли;
			Объект.Параметры.Очистить();
			Объект.Текст = СтруктураЗапроса.Текст;
			
			// Антибаг платформы 8.2.18. Некорректная серилизация моментов времени http://partners.v8.1c.ru/forum/thread.jsp?id=1159525#1159525
			//ЛксСкопироватьУниверсальнуюКоллекцию(СтруктураЗапроса.Параметры, Объект.Параметры);
			Для Каждого КлючИЗначение Из СтруктураЗапроса.Параметры Цикл
				Объект.Параметры.Вставить(КлючИЗначение.Ключ, ЗначениеИзСтрокиВнутр(КлючИЗначение.Значение));
			КонецЦикла;
		КонецЕсли; 
		Отладить(Объект, , СтруктураПараметров.НастройкаКомпоновки, СтруктураПараметров.ВнешниеНаборыДанных);
	ИначеЕсли ТипОперации = "Исследовать" Тогда
		Исследовать(Объект, , СтруктураПараметров.КакКоллекцию);
	КонецЕсли;

КонецПроцедуры

Процедура ПанельИнструментовОПодсистеме() Экспорт
	ЛксОткрытьСправкуПоПодсистеме(Обработки.ирДинамическийСписок.Создать());
КонецПроцедуры

// ОформляемыеКолонки - имена колонок, разделенные запятыми
Процедура ОтобразитьПустыеЗначенияВЯчейкахТабличногоПоля(ОформлениеСтроки, Знач ОформляемыеКолонки = "") Экспорт

	ОформляемыеКолонки = Новый Структура(ОформляемыеКолонки);
	НеФильтровтатьКолонки = (ОформляемыеКолонки.Количество() = 0);
	Для Каждого Ячейка Из ОформлениеСтроки.Ячейки Цикл
		Если Ложь
			Или НеФильтровтатьКолонки
			Или ОформляемыеКолонки.Свойство(Ячейка.Имя)
		Тогда
			ЗначениеЯчейки = Ячейка.Значение;
			Если Не ЗначениеЗаполнено(ЗначениеЯчейки) Тогда
				Ячейка.УстановитьТекст(ирКэш.Получить().мПолучитьПредставлениеПустогоЗначения(ЗначениеЯчейки));
				Ячейка.ЦветФона = WebЦвета.Роса;
			КонецЕсли;
		КонецЕсли; 
	КонецЦикла; 

КонецПроцедуры // ОтобразитьПустыеЗначенияВЯчейкахТабличногоПоля()

Процедура ПолеВвода_ОкончаниеВводаТекстаЛкс(Элемент, Текст, Значение, СтандартнаяОбработка, РасширенноеЗначение = Null, 
	ЛиТипСтрокаСлужебный = Ложь) Экспорт
	
	Если ТипЗнч(Элемент.Значение) = Тип("Строка") Тогда
		Типы = Элемент.ТипЗначения.Типы();
		Если Типы.Количество() > 1 Тогда
			ПредставлениеЗначения = ЛксПолучитьСтрокуМеждуМаркерами(Элемент.Значение, "(", ")");
			ЗначениеСсылки = ирНеглобальный.ПреобразоватьЗначениеИзSDBLЛкс(ПредставлениеЗначения);
			Если Истина
				И ЗначениеСсылки <> Неопределено 
				И Элемент.ТипЗначения.СодержитТип(ТипЗнч(ЗначениеСсылки)) 
			Тогда
				Ответ = КодВозвратаДиалога.Да;
				Если Не ЛиТипСтрокаСлужебный Тогда
					Ответ = Вопрос("Хотите вставить строку как ссылку?", РежимДиалогаВопрос.ДаНет,, КодВозвратаДиалога.Нет);
				КонецЕсли; 
				Если Ответ = КодВозвратаДиалога.Да Тогда
					Значение = ЗначениеСсылки;
					СтандартнаяОбработка = Ложь;					
				КонецЕсли;
			КонецЕсли;
			Если Истина
				И ЛиТипСтрокаСлужебный
				И СтандартнаяОбработка
				И ЗначениеЗаполнено(Элемент.Значение) 
			Тогда
				Значение = ""; 
				СтандартнаяОбработка = Ложь;
			КонецЕсли; 
		КонецЕсли; 
	КонецЕсли; 
	Менеджер = ЛксПолучитьМенеджер(Элемент.Значение);
	Если Менеджер <> Неопределено Тогда
		УникальныйИдентификатор = ирКэш.Получить().ПолучитьУникальныйИдентификаторИзСтроки(Текст);
		Если УникальныйИдентификатор <> Неопределено Тогда
			СтандартнаяОбработка = Ложь;
			Значение = Менеджер.ПолучитьСсылку(УникальныйИдентификатор);
		КонецЕсли;
	Иначе
		Если Ложь
			Или (Истина
				И РасширенноеЗначение <> Null
				И ТипЗнч(РасширенноеЗначение) <> ТипЗнч(Элемент.Значение))
			Или Элемент.ОграничениеТипа.ПривестиЗначение(Элемент.Значение) <> Элемент.Значение 
		Тогда
			// Откат
			СтандартнаяОбработка = Ложь;
			Значение = Новый СписокЗначений;
		КонецЕсли; 
	КонецЕсли;
	
КонецПроцедуры

// Результат - Булево - Истина если значение было изменено
Функция ОткрытьФормуПроизвольногоЗначенияЛкс(РасширенноеЗначение, РедактированиеРазрешено = Истина, СтандартнаяОбработка = Истина,
	ЗаголовокФормы = "") Экспорт 
	
	Результат = Ложь;
	ТипРасширенногоЗначения = ТипЗнч(РасширенноеЗначение);
	ХмлТип = XMLТипЗнч(РасширенноеЗначение);
	Если Ложь
		Или ТипРасширенногоЗначения = Тип("ТаблицаЗначений") 
		Или ТипРасширенногоЗначения = Тип("ДеревоЗначений") 
		Или ТипРасширенногоЗначения = Тип("МоментВремени")
		Или ТипРасширенногоЗначения = Тип("ТабличныйДокумент")
		Или ТипРасширенногоЗначения = Тип("Массив")
		Или ТипРасширенногоЗначения = Тип("Граница")
		Или ТипРасширенногоЗначения = Тип("Строка")
		Или ТипРасширенногоЗначения = Тип("УникальныйИдентификатор")
		Или ТипРасширенногоЗначения = Тип("Тип")
		Или ТипРасширенногоЗначения = Тип("ОписаниеТипов")
		Или ТипРасширенногоЗначения = Тип("СписокЗначений")
	Тогда
		СтандартнаяОбработка = Ложь;
		Если Ложь
			Или ТипРасширенногоЗначения = Тип("ТаблицаЗначений") 
			Или ТипРасширенногоЗначения = Тип("ДеревоЗначений") 
		Тогда
			ФормаРедактирования = ПолучитьФорму("Обработка.ирПлатформа.Форма.ТаблицаЗначений", , , РасширенноеЗначение);
		ИначеЕсли ТипРасширенногоЗначения = Тип("МоментВремени") Тогда
			ФормаРедактирования = ПолучитьФорму("Обработка.ирПлатформа.Форма.МоментВремени", , , РасширенноеЗначение);
		ИначеЕсли ТипРасширенногоЗначения = Тип("ТабличныйДокумент") Тогда
			ФормаРедактирования = ПолучитьФорму("Обработка.ирПлатформа.Форма.ТабличныйДокумент", , , РасширенноеЗначение);
		ИначеЕсли ТипРасширенногоЗначения = Тип("Граница") Тогда
			ФормаРедактирования = ПолучитьФорму("Обработка.ирПлатформа.Форма.Граница", , , РасширенноеЗначение);
		ИначеЕсли ТипРасширенногоЗначения = Тип("Массив") Тогда
			ФормаРедактирования = ПолучитьФорму("Обработка.ирПлатформа.Форма.Массив", , , РасширенноеЗначение);
		ИначеЕсли ТипРасширенногоЗначения = Тип("УникальныйИдентификатор") Тогда
			ФормаРедактирования = ПолучитьФорму("Обработка.ирПлатформа.Форма.УникальныйИдентификатор", , , РасширенноеЗначение);
		ИначеЕсли ТипРасширенногоЗначения = Тип("СписокЗначений") Тогда
			ФормаРедактирования = ПолучитьФорму("Обработка.ирПлатформа.Форма.СписокЗначений", , , РасширенноеЗначение);
		ИначеЕсли ТипРасширенногоЗначения = Тип("Строка") Тогда
			ФормаРедактирования = ПолучитьФорму("Обработка.ирПлатформа.Форма.Текст", , , Новый УникальныйИдентификатор());
		ИначеЕсли ТипРасширенногоЗначения = Тип("Тип") Тогда
			ФормаРедактирования = ПолучитьФорму("Обработка.ирПлатформа.Форма.ВыборРедактируемыхТипов", , , Новый УникальныйИдентификатор());
			ФормаРедактирования.МножественныйВыбор = Ложь;
		ИначеЕсли ТипРасширенногоЗначения = Тип("ОписаниеТипов") Тогда
			ФормаРедактирования = ПолучитьФорму("Обработка.ирПлатформа.Форма.ВыборРедактируемыхТипов", , , РасширенноеЗначение);
			ФормаРедактирования.МножественныйВыбор = Истина;
		КонецЕсли;
		Если ЗначениеЗаполнено(ЗаголовокФормы) Тогда
			ФормаРедактирования.Заголовок = ЗаголовокФормы;
		КонецЕсли; 
		Если ФормаРедактирования.Открыта() Тогда
			ФормаРедактирования.Активизировать();
			Возврат Результат;
		КонецЕсли; 
		ФормаРедактирования.ТолькоПросмотр = Не РедактированиеРазрешено;
		Если РедактированиеРазрешено Тогда
			ФормаРедактирования.НачальноеЗначениеВыбора = ЛксПолучитьКопиюОбъекта(РасширенноеЗначение); // Опасно
		Иначе
			ФормаРедактирования.НачальноеЗначениеВыбора = РасширенноеЗначение;
		КонецЕсли;
		Если РедактированиеРазрешено Тогда
			РезультатВыбора = ФормаРедактирования.ОткрытьМодально();
			Если РезультатВыбора <> Неопределено Тогда
				РасширенноеЗначение = РезультатВыбора;
				Результат = Истина;
			КонецЕсли; 
		Иначе
			ФормаРедактирования.Открыть();
		КонецЕсли; 
	ИначеЕсли Ложь
		Или ТипРасширенногоЗначения = Тип("Число")
		Или ТипРасширенногоЗначения = Тип("Строка")
		Или ТипРасширенногоЗначения = Тип("Дата")
		Или ТипРасширенногоЗначения = Тип("Булево")
		Или ТипРасширенногоЗначения = Тип("Неопределено")
		Или ТипРасширенногоЗначения = Тип("Null")
		Или ТипРасширенногоЗначения = Тип("ПолеКомпоновкиДанных")
		Или ТипРасширенногоЗначения = Тип("СтандартнаяДатаНачала")
		Или ТипРасширенногоЗначения = Тип("СтандартныйПериод")
		Или ТипРасширенногоЗначения = Тип("ВидДвиженияНакопления")
		Или ТипРасширенногоЗначения = Тип("ВидДвиженияБухгалтерии")
		Или ТипРасширенногоЗначения = Тип("ВидСчета")
		Или (Истина
			И ХмлТип <> Неопределено
			И Найти(ХмлТип.ИмяТипа, "Ref.") > 0)
			
	Тогда
		Если ХмлТип <> Неопределено Тогда
			Если Найти(ХмлТип.ИмяТипа, "Ref.") > 0 Тогда 
				Если Истина
					И ЗначениеЗаполнено(РасширенноеЗначение) 
					И Найти(ХмлТип.ИмяТипа, "BusinessProcessRoutePointRef.") = 0
					И Найти(ХмлТип.ИмяТипа, "EnumRef.") = 0
					И РасширенноеЗначение.ПолучитьОбъект() = Неопределено 
				Тогда
					//ирНеглобальный.ОткрытьСсылкуЯчейкиВРедактореОбъектаБДЛкс(ТабличноеПоле);
					Обработки.ирРедакторОбъектаБД.Создать().РедактироватьОбъектСсылки(РасширенноеЗначение);
					СтандартнаяОбработка = Ложь;
				КонецЕсли; 
			КонецЕсли; 
		КонецЕсли; 
		Если Ложь
			Или Не СтандартнаяОбработка
			Или Не РедактированиеРазрешено
		Тогда
			Если ХмлТип <> Неопределено Тогда
				Если Найти(ХмлТип.ИмяТипа, "Ref.") > 0 Тогда 
					Если Истина
						И ЗначениеЗаполнено(РасширенноеЗначение) 
						И (Ложь
							Или Найти(ХмлТип.ИмяТипа, "BusinessProcessRoutePointRef.") = 1
							Или Найти(ХмлТип.ИмяТипа, "EnumRef.") = 1
							Или РасширенноеЗначение.ПолучитьОбъект() <> Неопределено)
					Тогда
						ОткрытьЗначение(РасширенноеЗначение);
					КонецЕсли; 
					СтандартнаяОбработка = Ложь;
				КонецЕсли; 
			КонецЕсли; 
			Если СтандартнаяОбработка Тогда
				ОткрытьЗначение(РасширенноеЗначение);
				СтандартнаяОбработка = Ложь;
			КонецЕсли;
		КонецЕсли; 
	Иначе
		//Если Истина
		//	И ТипЗначения1 <> Неопределено
		//	И ТипЗначения1.ПривестиЗначение(РасширенноеЗначение) <> РасширенноеЗначение 
		//Тогда
			Исследовать(РасширенноеЗначение);
			СтандартнаяОбработка = Ложь;
		//КонецЕсли; 
	КонецЕсли;
	Возврат Результат;
	
КонецФункции

// Результат - Булево - Истина если значение было изменено
Функция ЯчейкаТабличногоПоляРасширенногоЗначения_ВыборЛкс(ТабличноеПоле, СтандартнаяОбработка = Ложь, РасширенноеЗначение = Null,
	РедактированиеРазрешено = Ложь) Экспорт 

	Колонка = ТабличноеПоле.ТекущаяКолонка;
	ВыбраннаяСтрока = ТабличноеПоле.ТекущаяСтрока;
	Если РасширенноеЗначение = Null Тогда
		РасширенноеЗначение = ТабличноеПоле.ТекущаяСтрока[Колонка.Данные];
	КонецЕсли; 
	ОформлениеСтроки = ТабличноеПоле.ОформлениеСтроки(ВыбраннаяСтрока);
	Ячейка = ОформлениеСтроки.Ячейки[Колонка.Имя];
	Если Колонка.ЭлементУправления <> Неопределено Тогда
		ТипЗначения1 = Колонка.ЭлементУправления.ТипЗначения;
	КонецЕсли; 
	РедактированиеРазрешено = Истина
		И РедактированиеРазрешено
		И Не ТабличноеПоле.ТолькоПросмотр
		И Не Колонка.ТолькоПросмотр
		И Колонка.ЭлементУправления <> Неопределено
		И Не Колонка.ЭлементУправления.ТолькоПросмотр
		И Не Ячейка.ТолькоПросмотр;
	Результат = ОткрытьФормуПроизвольногоЗначенияЛкс(РасширенноеЗначение, РедактированиеРазрешено, СтандартнаяОбработка);
	Если Результат Тогда
		ВыбраннаяСтрока[Колонка.Данные] = РасширенноеЗначение;
	КонецЕсли; 
	Возврат Результат;

КонецФункции // ОткрытьЗначениеЯчейки()

// Результат - Булево - Истина если значение было изменено
Функция ПолеВводаРасширенногоЗначения_НачалоВыбораЛкс(ТабличноеПоле, СтандартнаяОбработка, РасширенноеЗначение = Null, ИспользоватьОграничениеТипа = Ложь) Экспорт
	
	Колонка = ТабличноеПоле.ТекущаяКолонка;
	Если РасширенноеЗначение = Null Тогда
		РасширенноеЗначение = ТабличноеПоле.ТекущаяСтрока[Колонка.Данные];
	КонецЕсли; 
	ЗначениеИзменено = Ложь;
	Если РасширенноеЗначение = Неопределено Тогда
		СтандартнаяОбработка = Ложь;
		ОграничениеТипа = Неопределено;
		Если ИспользоватьОграничениеТипа Тогда
			ОграничениеТипа = Колонка.ЭлементУправления.ОграничениеТипа;
			Если ОграничениеТипа.Типы().Количество() = 0 Тогда
				ОграничениеТипа = Колонка.ЭлементУправления.ТипЗначения;
			КонецЕсли; 
		КонецЕсли; 
		НовыйТип = ирНеглобальный.ВыбратьРедактируемыйТипЛкс(ОграничениеТипа);
		Если НовыйТип <> Неопределено Тогда
			МассивТипов = ЛксБыстрыйМассив(НовыйТип);
			НовоеОписаниеТипов = Новый ОписаниеТипов(МассивТипов);
			НовоеЗначение = НовоеОписаниеТипов.ПривестиЗначение(Неопределено);
			РасширенноеЗначение = НовоеЗначение;
			ТабличноеПоле.ТекущаяСтрока[Колонка.Данные] = РасширенноеЗначение;
			ЗначениеИзменено = Истина;
		КонецЕсли;
	Иначе
		ЗначениеИзменено = ЯчейкаТабличногоПоляРасширенногоЗначения_ВыборЛкс(ТабличноеПоле, СтандартнаяОбработка, РасширенноеЗначение, Истина);
		//Если ЗначениеИзменено Тогда
		Если Не СтандартнаяОбработка Тогда
			ТабличноеПоле.ТекущаяСтрока[Колонка.Данные] = РасширенноеЗначение;//
		КонецЕсли; 
	КонецЕсли;
	Возврат ЗначениеИзменено;
	
КонецФункции

Функция ПолучитьФормуЛкс(ИмяФормы, Параметры = Неопределено, Владелец = Неопределено, Уникальность = Неопределено, Окно = Неопределено) Экспорт
	
	Результат = ПолучитьФорму(ИмяФормы, Параметры, Владелец, Уникальность, Окно);
	Возврат Результат;
	
КонецФункции

// ИменаКолонокСПиктограммамиТипов - Массив, Строка
Процедура ТабличноеПолеПриВыводеСтрокиЛкс(Элемент, ОформлениеСтроки, ДанныеСтроки, ЛиОтбражатьПустые = Ложь, Знач ИменаКолонокСПиктограммамиТипов = "") Экспорт 

	ирПлатформа = ирКэш.Получить();
	Если ТипЗнч(ИменаКолонокСПиктограммамиТипов) = Тип("Строка") Тогда
		ИменаКолонокСПиктограммамиТипов = ЛксПолучитьМассивИзСтрокиСРазделителем(ИменаКолонокСПиктограммамиТипов, ",", Истина); 
	КонецЕсли; 
	Для Каждого Колонка Из Элемент.Колонки Цикл
		Ячейка = ОформлениеСтроки.Ячейки[Колонка.Имя];
		ЗначениеЯчейки = Ячейка.Значение;
		Если Формат(ЗначениеЯчейки, Колонка.Формат) = Ячейка.Текст Тогда // Здесь могут быть обращения к БД
			ПредставлениеЗначения = "";
			Если ТипЗнч(ЗначениеЯчейки) <> Тип("Строка") Тогда
				ПредставлениеЗначения = ЛксПолучитьРасширенноеПредставлениеЗначения(ЗначениеЯчейки, Колонка);
			КонецЕсли; 
			Если ЛиОтбражатьПустые Тогда
				Если Не ЗначениеЗаполнено(ЗначениеЯчейки) Тогда
					ПредставлениеЗначения = ирПлатформа.мПолучитьПредставлениеПустогоЗначения(ЗначениеЯчейки);
					Ячейка.ЦветФона = WebЦвета.Роса;
				КонецЕсли;
			КонецЕсли; 
			Если ПредставлениеЗначения <> "" Тогда
				Ячейка.УстановитьТекст(ПредставлениеЗначения);
			КонецЕсли; 
		КонецЕсли; 
		
		Если ИменаКолонокСПиктограммамиТипов.Найти(Колонка.Имя) <> Неопределено Тогда
			Если ТипЗнч(ЗначениеЯчейки) <> Тип("ПолеКомпоновкиДанных") Тогда
				ТипЗначения = ТипЗнч(ЗначениеЯчейки);
				Если Истина
					И ТипЗначения = Тип("Булево")
					И Ячейка.ОтображатьФлажок
				Тогда
					Продолжить;
				КонецЕсли;
				КартинкаТипа = ПолучитьПиктограммуТипаЛкс(ТипЗначения);
				Если КартинкаТипа <> Неопределено Тогда
					Ячейка.УстановитьКартинку(КартинкаТипа);
				КонецЕсли;
			КонецЕсли;
		КонецЕсли; 
	КонецЦикла;  

КонецПроцедуры // ТабличноеПолеСВложеннымиКоллекциямиПриВыводеСтроки()

Процедура ПрименитьИзмененияИЗакрытьФормуЛкс(ЭтаФорма, ЗначениеВыбора = Неопределено) Экспорт

	ЭтаФорма.Модифицированность = Ложь;
	Если Ложь
		Или ЭтаФорма.ВладелецФормы <> Неопределено 
		Или Не ЭтаФорма.Открыта()
	Тогда
		ЭтаФорма.ОповеститьОВыборе(ЗначениеВыбора);
	КонецЕсли; 
	Если ЭтаФорма.Открыта() Тогда
		ЭтаФорма.Закрыть(ЗначениеВыбора);
	КонецЕсли; 
	//Если ЭтаФорма.Открыта() Тогда
	//	ЭтаФорма.Закрыть(ЗначениеВыбора);
	//Иначе//Если ЭтаФорма.МодальныйРежим Тогда
	//	ЭтаФорма.ОповеститьОВыборе(ЗначениеВыбора);
	//КонецЕсли; 

КонецПроцедуры // ПрименитьИзмененияИЗакрытьФорму()

Функция НайтиВозможныеСтрокиОписанияСловаВСинтаксПомощникеЛкс(Знач Слово, ЯзыкПрограммы = 0, ПоискСУчетомТипаСлова = Истина) Экспорт

	ирКэш.Получить().ИнициализацияОписанияМетодовИСвойств();
	МассивВозможныхТиповСлова = Новый Массив;
	МассивВозможныхТиповСлова.Добавить("Конструктор");
	Слово = НРег(Слово);
	Если Ложь
		Или Не ПоискСУчетомТипаСлова
		Или Прав(Слово, 1) = "(" 
	Тогда
		Если Прав(Слово, 1) = "(" Тогда
			Слово = ЛксПолучитьСтрокуБезКонца(Слово, 1);
		КонецЕсли; 
		МассивВозможныхТиповСлова.Добавить("Метод");
	КонецЕсли; 
	Если Ложь
		Или Не ПоискСУчетомТипаСлова
		Или Прав(Слово, 1) <> "(" 
	Тогда
		МассивВозможныхТиповСлова.Добавить("Свойство");
		МассивВозможныхТиповСлова.Добавить("Конструкция");
		МассивВозможныхТиповСлова.Добавить("Событие");
		МассивВозможныхТиповСлова.Добавить("Таблица");
	КонецЕсли;
	ТаблицаСтруктурВозможныхТиповКонтекста = ирКэш.Получить().ПолучитьНовуюТаблицуСтруктурТипа();
	Для Каждого ВозможныйТипСлова Из МассивВозможныхТиповСлова Цикл
		Если ВозможныйТипСлова = "Конструктор" Тогда
			КлючПоиска = Новый Структура("ТипКонтекста, ТипСлова, ЯзыкПрограммы, ТипЯзыка", Слово, ВозможныйТипСлова, ЯзыкПрограммы, "");
		Иначе
			КлючПоиска = Новый Структура("НСлово, ТипСлова, ЯзыкПрограммы, ТипЯзыка", Слово, ВозможныйТипСлова, ЯзыкПрограммы, "");
		КонецЕсли;
		НайденныеСтроки = ирКэш.Получить().ТаблицаКонтекстов.НайтиСтроки(КлючПоиска);
		Для Каждого НайденнаяСтрока Из НайденныеСтроки Цикл
			ЗаполнитьЗначенияСвойств(ТаблицаСтруктурВозможныхТиповКонтекста.Добавить(), Новый Структура("СтрокаОписания", НайденнаяСтрока));
		КонецЦикла;
		НайденныеСтроки = ирКэш.Получить().ТаблицаШаблоновКонтекстов.НайтиСтроки(КлючПоиска);
		Для Каждого НайденнаяСтрока Из НайденныеСтроки Цикл
			ЗаполнитьЗначенияСвойств(ТаблицаСтруктурВозможныхТиповКонтекста.Добавить(), Новый Структура("СтрокаОписания", НайденнаяСтрока));
		КонецЦикла;
	КонецЦикла;
	КлючПоиска = Новый Структура("НСлово, ЯзыкПрограммы", Слово, ЯзыкПрограммы);
	НайденныеСтроки = ирКэш.Получить().ТаблицаОбщихТипов.НайтиСтроки(КлючПоиска);
	Для Каждого НайденнаяСтрока Из НайденныеСтроки Цикл
		ЗаполнитьЗначенияСвойств(ТаблицаСтруктурВозможныхТиповКонтекста.Добавить(), Новый Структура("СтрокаОписания", НайденнаяСтрока));
	КонецЦикла;
	Возврат ТаблицаСтруктурВозможныхТиповКонтекста;

КонецФункции // НайтиВозможныеСтрокиОписанияСлова()

// Открывает форму синтакс-помощника и загружает в нее нужную страницу, подсвечивая заданную строку.
//
// Параметры:
//  ВнутреннийПутьКОписанию – Строка – внутренний путь к странице синтакс-помощника;
//  СтрокаДляПодсветки – Строка – которую нужно подсветить в тексте страницы.
//
// Возвращаемое значение:
//  Форма.
//
Функция ОткрытьСтраницуСинтаксПомощникаЛкс(ВнутреннийПутьКОписанию, СтрокаДляПодсветки = "", ВладелецФормы = Неопределено, КлючУникальности = Неопределено) Экспорт

	Если ВнутреннийПутьКОписанию = "" Тогда
		Возврат Неопределено; 
	КонецЕсли; 
	ФормаСправка = ПолучитьФорму("Обработка.ирСинтаксПомощник.Форма", , , КлючУникальности);
	ФормаСправка.ВладелецФормы = ВладелецФормы;
	ФормаСправка.ОткрытьАдрес(ВнутреннийПутьКОписанию, СтрокаДляПодсветки);
	ФормаСправка.ВладелецФормы = Неопределено;
	Возврат ФормаСправка;

КонецФункции // ОткрытьСтраницуСинтаксПомощникаЛкс()

// Обходит строки табличного поля и имитирует редактирование и выбор пользователем заданного значения.
//
// Параметры:
//  ТабличноеПоле - ТабличноеПоле;
//  ЗначениеОбработки - Произвольные - значение, которое будем записывать в ячейки;
//  *ФормаИнициатор - Форма, *Неопределено - форма, от имени которой будет записывать;
//  *ТипИсточника – Строка, *Неопределено – "ТаблицаЗначений", "ТабличнаяЧасть";
//  *Колонка      – КолонкаТабличногоПоля, *Неопределено – колонка в которой обходим ячейки, по умолчанию текущая;
//  *ТолькоВыделенныеСтроки - Булево, *Истина - обходить только выделенные строки.
//
Процедура УстановитьЗначениеВКолонкеТабличногоПоляТЧИлиТЗЛкс(ТабличноеПоле, ЗначениеОбработки,
	ФормаИнициатор = Неопределено, Знач ТипИсточника = Неопределено, Знач Колонка = Неопределено,
	Знач ТолькоВыделенныеСтроки = Истина, Знач ИнтерактивноеУстановка = Истина) Экспорт

	Если Колонка = Неопределено Тогда
		Колонка = ТабличноеПоле.ТекущаяКолонка;
	Иначе
		ТабличноеПоле.ТекущаяКолонка = Колонка;
	КонецЕсли;
	ЗначениеТабличногоПоля = ТабличноеПоле.Значение;
	Если ТипИсточника = "" Тогда
		ТипЗначенияТабличногоПоля = ТипЗнч(ЗначениеТабличногоПоля);
		Если ТипЗначенияТабличногоПоля = Тип("ТаблицаЗначений") Тогда 
			ТипИсточника = "ТаблицаЗначений";
		ИначеЕсли ТипЗначенияТабличногоПоля = Тип("ДеревоЗначений") Тогда 
			ТипИсточника = "ДеревоЗначений";
		Иначе
			СтруктураТипа = ирКэш.Получить().ПолучитьСтруктуруТипаИзКонкретногоТипа(ТипЗначенияТабличногоПоля);
			Если Найти(СтруктураТипа.ИмяОбщегоТипа, "<Имя табличной части>") > 0 Тогда
				ТипИсточника = "ТабличнаяЧасть";
			ИначеЕсли Найти(СтруктураТипа.ИмяОбщегоТипа, "НаборЗаписей.") > 0 Тогда
				ТипИсточника = "НаборЗаписей";
			КонецЕсли;
		КонецЕсли;
	КонецЕсли;
	ЕстьОтборСтрок = Ложь
		Или ТипИсточника = "ТабличнаяЧасть" 
		Или ТипИсточника = "НаборЗаписей";
	Если ТолькоВыделенныеСтроки Тогда
		Если Истина
			И ТабличноеПоле.ВыделенныеСтроки.Количество() = 1
			И ТипИсточника <> "ДеревоЗначений"
		Тогда
			ТекстОтбора = "";
			Если ЕстьОтборСтрок Тогда
				ТекстОтбора = " удовлетворяющие отбору";
			КонецЕсли;
			Ответ = Вопрос("Выделена только одна строка. Хотите обработать все" + ТекстОтбора + " строки?",
				РежимДиалогаВопрос.ДаНет);
			Если Ответ = КодВозвратаДиалога.Да Тогда
				ТолькоВыделенныеСтроки = Ложь;
			КонецЕсли;
		КонецЕсли;
	КонецЕсли;
	КлючиСтрокДляОбработки = Новый Массив;
	Если ТолькоВыделенныеСтроки Тогда
		Для Каждого ВыделеннаяСтрока Из ТабличноеПоле.ВыделенныеСтроки Цикл
			КлючиСтрокДляОбработки.Добавить(ВыделеннаяСтрока);
		КонецЦикла;
	Иначе
		Если ЕстьОтборСтрок Тогда
			Построитель = Новый ПостроительЗапроса;
			Построитель.ИсточникДанных = Новый ОписаниеИсточникаДанных(ЗначениеТабличногоПоля);
			Построитель.ВыбранныеПоля.Очистить();
			Построитель.ВыбранныеПоля.Добавить("НомерСтроки");
			ЛксСкопироватьОтбор(Построитель.Отбор, ТабличноеПоле.ОтборСтрок, Истина);
			ТаблицаРезультата = Построитель.Результат.Выгрузить();
			Для Каждого СтрокаРезультата Из ТаблицаРезультата Цикл
				КлючиСтрокДляОбработки.Добавить(СтрокаРезультата.НомерСтроки - 1); 
			КонецЦикла;
		ИначеЕсли ТипИсточника = "ТаблицаЗначений" Тогда 
			Для Каждого СтрокаТаблицы Из ТабличноеПоле.Значение Цикл
				КлючиСтрокДляОбработки.Добавить(СтрокаТаблицы);
			КонецЦикла;
		КонецЕсли;
	КонецЕсли;
	
	Индикатор = ЛксПолучитьИндикаторПроцесса(КлючиСтрокДляОбработки.Количество(), "Групповая установка значения");
	// Нужно встать на редактируемую колонку, чтобы сработал режим редактирования
	Для Каждого КлючСтроки Из КлючиСтрокДляОбработки Цикл
		ЛксОбработатьИндикатор(Индикатор);
		Если ТипЗнч(КлючСтроки) = Тип("Число") Тогда
			ТекущаяСтрока = ТабличноеПоле.Значение[КлючСтроки];
		Иначе
			ТекущаяСтрока = КлючСтроки;
		КонецЕсли;
		Если ТипЗнч(ЗначениеОбработки) = Тип("Структура") Тогда
			ЗаполнитьЗначенияСвойств(ЗначениеОбработки.Параметры, ТекущаяСтрока); 
			НовоеЗначение = ирНеглобальный.ВычислитьВыражение(ЗначениеОбработки.Формула, ЗначениеОбработки.Параметры);
		Иначе
			НовоеЗначение = ЗначениеОбработки;
		КонецЕсли; 
		Если ИнтерактивноеУстановка Тогда
			ТабличноеПоле.ТекущаяСтрока = ТекущаяСтрока;
			//ТабличноеПоле.ИзменитьСтроку();
			ЛксИнтерактивноЗаписатьВКолонкуТабличногоПоля(ТабличноеПоле, Колонка, НовоеЗначение, ФормаИнициатор);
			ТабличноеПоле.ЗакончитьРедактированиеСтроки(Ложь);
		Иначе
			ТекущаяСтрока[Колонка.Имя] = НовоеЗначение;
		КонецЕсли; 
	КонецЦикла; 
	
КонецПроцедуры // ИнтерактивноУстановитьЗначениеВКолонкеТабличногоПоляТЧИлиТЗ()

Процедура ОформитьФонТекущейСтрокиЛкс(Элемент, ОформлениеСтроки, ДанныеСтроки) Экспорт
	
	Если Элемент.ТекущаяСтрока = ДанныеСтроки Тогда
		ОформлениеСтроки.ЦветФона = WebЦвета.СветлоНебесноГолубой;
	КонецЕсли; 

КонецПроцедуры

Функция ПроверитьЗапуститьОтладчик(Знач ВремяОжиданияЗапуска = 5) Экспорт
	
	ИдентификаторПроцессаОтладчика = Неопределено;
	Платформа = ирКэш.Получить();
	ПортОтладки = Платформа.ПолучитьПортДляПодключенияОтладчика(ИдентификаторПроцессаОтладчика);
	Если ИдентификаторПроцессаОтладчика = Неопределено Тогда
		//Если Не УФ(сПроверитьДоступностьКонфигуратора) Тогда
		//	Сообщить("Конфигуратор уже открыт, но отладка не подключена. Выполните подключение отладчика вручную");
		//	Перейти ~Конец;
		//КонецЕсли;
		// Антибаг 8.2.15 http://partners.v8.1c.ru/forum/thread.jsp?id=1003164#1003164
		Если Платформа.ВерсияПлатформы = 802015 Тогда 
			Предупреждение("Из-за ошибки платформы 8.2.15 запуск и подключение отладчика необходимо выполнять вручную", 20);
			Возврат Неопределено;
		КонецЕсли; 
		Если ПортОтладки = Неопределено Тогда
			Предупреждение("Включите разрешение отладки в главном меню ""Сервис/Параметры/Системные"" и повторите операцию снова");
			Возврат Неопределено;
		КонецЕсли;
		ПараметрыЗапуска = "CONFIG /DEBUG /DEBUGTARGET""tcp://127.0.0.1:" + ПортОтладки + """";
		ЗапуститьСистему(ПараметрыЗапуска);
		Платформа.Sleep(ВремяОжиданияЗапуска);
		
		Если ИдентификаторПроцессаОтладчика = Неопределено Тогда
			ИдентификаторПроцессаОтладчика = 0;
		КонецЕсли;
	
		Пока Истина Цикл
			Платформа.ПолучитьПортДляПодключенияОтладчика(ИдентификаторПроцессаОтладчика);
			Если ИдентификаторПроцессаОтладчика = Неопределено Тогда
				Ответ = Вопрос("Отладчик еще не подключился. Повторить снова?", РежимДиалогаВопрос.ОКОтмена);
				Если Ответ = КодВозвратаДиалога.ОК Тогда
					Продолжить;
				КонецЕсли;
			КонецЕсли;
			Прервать;
		КонецЦикла;
	Иначе
		Платформа.АктивизироватьОкноПроцесса1С8(Число(ИдентификаторПроцессаОтладчика));
	КонецЕсли;
	Если ИдентификаторПроцессаОтладчика <> Неопределено Тогда
		Результат = Число(ИдентификаторПроцессаОтладчика);
	КонецЕсли;
	Возврат Результат;
	
КонецФункции

Процедура ОткрытьСсылкуЯчейкиВРедактореОбъектаБДЛкс(ТабличноеПоле, ИмяКолонки = "") Экспорт
	
	Если ТабличноеПоле.ТекущаяСтрока = Неопределено Тогда
		Возврат;
	КонецЕсли;
	Если Не ЗначениеЗаполнено(ИмяКолонки) Тогда
		Если ТабличноеПоле.ТекущаяКолонка = Неопределено Тогда
			Возврат;
		КонецЕсли; 
		ИмяКолонки = ТабличноеПоле.ТекущаяКолонка.Данные;
	КонецЕсли; 
	ЗначениеЯчейки = ТабличноеПоле.ТекущаяСтрока[ИмяКолонки];
	XMLТип = XMLТипЗнч(ЗначениеЯчейки);
	Если XMLТип = Неопределено Тогда
		Возврат;
	КонецЕсли; 
	Если Найти(XMLТип.ИмяТипа, "Ref.") = 0 Тогда
		Возврат;
	КонецЕсли; 
	Обработки.ирРедакторОбъектаБД.Создать().РедактироватьОбъектСсылки(ЗначениеЯчейки);
	
КонецПроцедуры

// ВариантПросмотра - Строка - "Компактный", "ЯзыкЗапросов", "ВстроенныйЯзык", ...
Функция ПолучитьФормуТекстаЛкс(Текст, Знач Заголовок = "", ВариантПросмотра = "Компактный", ТолькоПросмотр = Ложь, КлючУникальности = Неопределено) Экспорт

	Если КлючУникальности = Неопределено Тогда
		КлючУникальности = Новый УникальныйИдентификатор();
	КонецЕсли; 
	ФормаПросмотра = ирКэш.Получить().ПолучитьФорму("Текст", , КлючУникальности);
	ФормаПросмотра.НачальноеЗначениеВыбора = Текст;
	ФормаПросмотра.РекомендуемыйВариант = ВариантПросмотра;
	ФормаПросмотра.ТолькоПросмотр = ТолькоПросмотр;
	Если Не ЗначениеЗаполнено(Заголовок) Тогда
		//Заголовок = ФормаПросмотра.Заголовок;
		Заголовок = ""; // Чтобы при повторном открытии не оставался старый текст
	КонецЕсли; 
	Если ТолькоПросмотр Тогда
		Заголовок = Заголовок + " - " + СтрДлина(Текст) + " символов";
	КонецЕсли; 
	ФормаПросмотра.Заголовок = Заголовок;
	Возврат ФормаПросмотра;

КонецФункции

Функция ОткрытьТекстЛкс(Текст, Знач Заголовок = "", ВариантПросмотра = "Компактный", ТолькоПросмотр = Ложь, КлючУникальности = Неопределено) Экспорт

	ФормаПросмотра = ПолучитьФормуТекстаЛкс(Текст, Заголовок, ВариантПросмотра, ТолькоПросмотр, КлючУникальности);
	ФормаПросмотра.Открыть();
	Возврат ФормаПросмотра;

КонецФункции

Процедура ПолеВводаТекста_НачалоВыбораЛкс(Элемент, СтандартнаяОбработка) Экспорт

	Если ТипЗнч(Элемент.Значение) = Тип("Строка") Тогда
		СтандартнаяОбработка = Ложь;
		ФормаРедактора = ирКэш.Получить().ПолучитьФорму("Текст", Элемент, Новый УникальныйИдентификатор);
		ФормаРедактора.РежимВыбора = Истина;
		ФормаРедактора.НачальноеЗначениеВыбора = Элемент.Значение;
		ФормаРедактора.Открыть();
	КонецЕсли;

КонецПроцедуры

Функция ПолучитьПутьКДаннымТекущейКолонкиТабличногоПоляЛкс(Знач ТабличноеПоле) Экспорт
	
	Если Истина
		И ТабличноеПоле.ТекущаяКолонка <> Неопределено
		И ТабличноеПоле.ТекущиеДанные <> Неопределено
	Тогда
		ДанныеКолонки = ТабличноеПоле.ТекущаяКолонка.Данные;
		Если Не ЗначениеЗаполнено(ДанныеКолонки) Тогда
			ДанныеКолонки = ТабличноеПоле.ТекущаяКолонка.ДанныеФлажка;
			Если Не ЗначениеЗаполнено(ДанныеКолонки) Тогда
				Если Ложь
					Или ТипЗнч(ТабличноеПоле.Значение) = Тип("ТаблицаЗначений")
					Или ТипЗнч(ТабличноеПоле.Значение) = Тип("ДеревоЗначений")
				Тогда
					ДанныеКолонки = ТабличноеПоле.ТекущаяКолонка.ДанныеКартинки;
				КонецЕсли;
			КонецЕсли;
		КонецЕсли;
	КонецЕсли;
	Возврат ДанныеКолонки;
	
КонецФункции

Процедура ТабличноеПоле_ОтборБезЗначенияВТекущейКолонке_КнопкаЛкс(Знач ТабличноеПоле) Экспорт
	
	ДанныеКолонки = ПолучитьПутьКДаннымТекущейКолонкиТабличногоПоляЛкс(ТабличноеПоле);
	Если Не ЗначениеЗаполнено(ДанныеКолонки) Тогда
		Возврат;
	КонецЕсли;
	Попытка
		Отбор = ТабличноеПоле.Значение.Отбор;
	Исключение
		Отбор = ТабличноеПоле.ОтборСтрок;
	КонецПопытки;
	//:Отбор = Новый ("Отбор");
	ЭлементОтбора = Отбор[ДанныеКолонки];
	ЗначениеЯчейки = ТабличноеПоле.ТекущиеДанные[ДанныеКолонки];
	Если ЭлементОтбора.Использование Тогда
		Если ЭлементОтбора.ВидСравнения = ВидСравнения.НеРавно Тогда
			Если Ложь
				Или ТипЗнч(ЗначениеЯчейки) <> Тип("Булево")
				Или ЭлементОтбора.ТипЗначения.Типы().Количество() > 1
			Тогда
				СписокЗначений = Новый СписокЗначений;
				СписокЗначений.Добавить(ЭлементОтбора.Значение);
				СписокЗначений.Добавить(ЗначениеЯчейки);
				ЭлементОтбора.ВидСравнения = ВидСравнения.НеВСписке;
				ЭлементОтбора.Значение = СписокЗначений;
			КонецЕсли;
		ИначеЕсли ЭлементОтбора.ВидСравнения = ВидСравнения.НеВСписке Тогда
			СписокЗначений = ЭлементОтбора.Значение;
			СписокЗначений.Добавить(ЗначениеЯчейки);
			// Для обновления отбора
			ЭлементОтбора.Использование = Ложь; 
			ЭлементОтбора.Использование = Истина;
		ИначеЕсли ЭлементОтбора.ВидСравнения = ВидСравнения.ВСписке Тогда
			СписокЗначений = ЭлементОтбора.Значение;
			СписокЗначений.Удалить(СписокЗначений.НайтиПоЗначению(ЗначениеЯчейки));
			// Для обновления отбора
			ЭлементОтбора.Использование = Ложь; 
			ЭлементОтбора.Использование = Истина;
		Иначе
			ЭлементОтбора.Использование = Ложь;
		КонецЕсли;
	КонецЕсли;
	Если Не ЭлементОтбора.Использование Тогда
		ЭлементОтбора.Использование = Истина;
		Если Истина
			И ЭлементОтбора.ТипЗначения.СодержитТип(Тип("Строка"))
			И ЭлементОтбора.ТипЗначения.КвалификаторыСтроки.Длина = 0
		Тогда
			Если Не ЗначениеЗаполнено(ЗначениеЯчейки) Тогда
				// Особенность платформы
				ЭлементОтбора.ВидСравнения = ВидСравнения.Содержит;
			Иначе
				ЭлементОтбора.ВидСравнения = ВидСравнения.НеСодержит;
			КонецЕсли;
		Иначе
			ЭлементОтбора.ВидСравнения = ВидСравнения.НеРавно;
		КонецЕсли;
		ЭлементОтбора.Значение = ЗначениеЯчейки;
	КонецЕсли;
	
КонецПроцедуры

Функция ЗагрузитьЗначениеИзФайлаЛкс(Расширение = "", ОписаниеФормата = "", Сжатие = Истина) Экспорт
	
	ВыборФайла = Новый ДиалогВыбораФайла(РежимДиалогаВыбораФайла.Открытие);
	ВыборФайла.Фильтр = ирНеглобальный.ПолучитьСтрокуФильтраДляВыбораФайлаЛкс(Расширение, ОписаниеФормата);
	ВыборФайла.Расширение = Расширение;
	Если Не ВыборФайла.Выбрать() Тогда
		Возврат Неопределено;
	КонецЕсли;
	ПолноеИмяФайла = ВыборФайла.ПолноеИмяФайла;
	Если Сжатие Тогда
		ВременныйКаталог = ПолучитьИмяВременногоФайла();
		СоздатьКаталог(ВременныйКаталог);
		ЗипЧтение = Новый ЧтениеZipФайла(ПолноеИмяФайла);
		ЗипЧтение.ИзвлечьВсе(ВременныйКаталог);
		ПолноеИмяФайла = ВременныйКаталог + "\" + ЗипЧтение.Элементы[0].Имя;
	КонецЕсли; 
	
	ЧтениеХМЛ = Новый ЧтениеXML;
	ЧтениеХМЛ.ОткрытьФайл(ПолноеИмяФайла);
	Попытка
		//Результат = ЗначениеИзФайла(ВыборФайла.ПолноеИмяФайла);
		Результат = СериализаторXDTO.ПрочитатьXML(ЧтениеХМЛ);
	Исключение
		Сообщить(ОписаниеОшибки());
		Результат = Неопределено;
	КонецПопытки; 
	ЧтениеХМЛ.Закрыть();
	Если Сжатие Тогда
		УдалитьФайлы(ВременныйКаталог, "*");
	КонецЕсли; 
	Возврат Результат;
	
КонецФункции

Функция СохранитьЗначениеВФайлЛкс(Значение, Расширение = "", ОписаниеФормата = "", Сжатие = Истина, УровеньСжатия = Неопределено) Экспорт
	
	ВыборФайла = Новый ДиалогВыбораФайла(РежимДиалогаВыбораФайла.Сохранение);
	ВыборФайла.Фильтр = ирНеглобальный.ПолучитьСтрокуФильтраДляВыбораФайлаЛкс(Расширение, ОписаниеФормата);
	ВыборФайла.Расширение = Расширение;
	Если Не ВыборФайла.Выбрать() Тогда
		Возврат Неопределено;
	КонецЕсли;
	ЗаписьХМЛ = Новый ЗаписьXML;
	ЗаписьХМЛ.ОткрытьФайл(ВыборФайла.ПолноеИмяФайла);
	Попытка
		//ЗначениеВФайл(ВыборФайла.ПолноеИмяФайла, Значение);
		СериализаторXDTO.ЗаписатьXML(ЗаписьХМЛ, Значение);
		Результат = Истина;
	Исключение
		Сообщить(ОписаниеОшибки());
		Результат = Ложь;
	КонецПопытки; 
	ЗаписьХМЛ.Закрыть();
	
	Если Сжатие Тогда
		ВременныйКаталог = ПолучитьИмяВременногоФайла();
		СоздатьКаталог(ВременныйКаталог);
		Файл = Новый Файл(ВыборФайла.ПолноеИмяФайла);
		ИмяВременногоФайла = ВременныйКаталог + "\" + Файл.Имя;
		ПереместитьФайл(Файл.ПолноеИмя, ИмяВременногоФайла);
		ЗаписьЗип = Новый ЗаписьZipФайла(ВыборФайла.ПолноеИмяФайла,,,, УровеньСжатия);
		ЗаписьЗип.Добавить(ИмяВременногоФайла);
		ЗаписьЗип.Записать();
		УдалитьФайлы(ВременныйКаталог, "*");
	КонецЕсли; 
	Возврат Результат;
	
КонецФункции

Функция ВыбратьРедактируемыйТипЛкс(ОграничениеТипа = Неопределено, ТолькоПросмотр = Ложь, НачальноеЗначениеВыбора = Неопределено) Экспорт

	Если ОграничениеТипа = Неопределено Тогда
		ОграничениеТипа = Новый ОписаниеТипов;
	КонецЕсли; 
	ФормаРедактора = ирКэш.Получить().ПолучитьФорму("ВыборРедактируемыхТипов");
	ФормаРедактора.ОграничениеТипа = ОграничениеТипа;
	ФормаРедактора.НачальноеЗначениеВыбора = НачальноеЗначениеВыбора;
	ФормаРедактора.МножественныйВыбор = Ложь;
	ФормаРедактора.ТолькоПросмотр = ТолькоПросмотр;
	РезультатВыбора = ФормаРедактора.ОткрытьМодально();
	Возврат РезультатВыбора;

КонецФункции // РедактироватьДопустимыеТипы()

Функция РедактироватьОписаниеТиповЛкс(ОграничениеТипаИлиПолеВвода, ТолькоПросмотр = Ложь) Экспорт

	Если ТипЗнч(ОграничениеТипаИлиПолеВвода) = Тип("ОписаниеТипов") Тогда
		ВладелецФормы = Неопределено;
		ОграничениеТипа = ОграничениеТипаИлиПолеВвода;
	Иначе
		ВладелецФормы = ОграничениеТипаИлиПолеВвода;
		ОграничениеТипа = ОграничениеТипаИлиПолеВвода.Значение;
	КонецЕсли; 
	ФормаРедактора = ирКэш.Получить().ПолучитьФорму("ВыборРедактируемыхТипов", ВладелецФормы);
	//ФормаРедактора.ОграничениеТипа = ОграничениеТипа;
	ФормаРедактора.НачальноеЗначениеВыбора = ОграничениеТипа;
	ФормаРедактора.МножественныйВыбор = Истина;
	ФормаРедактора.ТолькоПросмотр = ТолькоПросмотр;
	РезультатВыбора = ФормаРедактора.ОткрытьМодально();
	Возврат РезультатВыбора;

КонецФункции // РедактироватьДопустимыеТипы()

Функция ОткрытьПодборСВыборомТипаЛкс(ВладелецФормы, ОписаниеТипов = Неопределено, НачальноеЗначениеВыбора = Неопределено) Экспорт

	Если ТипЗнч(ОписаниеТипов) = Тип("Строка") Тогда
		ДоступныеОбъекты = ЛксПолучитьМассивИзСтрокиСРазделителем(ОписаниеТипов, ",", Истина);
	ИначеЕсли ОписаниеТипов <> Неопределено Тогда
		ДоступныеОбъекты = Новый Массив();
		Для Каждого Тип Из ОписаниеТипов.Типы() Цикл
			ОбъектМетаданных = Метаданные.НайтиПоТипу(Тип);
			Если ОбъектМетаданных <> Неопределено Тогда
				ДоступныеОбъекты.Добавить(ОбъектМетаданных.ПолноеИмя());
			КонецЕсли; 
		КонецЦикла;
	КонецЕсли;
	Если Ложь
		Или ДоступныеОбъекты = Неопределено
		Или ДоступныеОбъекты.Количество() = 0 
		Или ДоступныеОбъекты.Количество() > 1 
	Тогда
		Форма = ирКэш.Получить().ПолучитьФорму("ВыборОбъектаМетаданных", ВладелецФормы, ВладелецФормы);
		Форма.НачальноеЗначениеВыбора = Новый Структура("ДоступныеОбъекты, ОтображатьСсылочныеОбъекты", ДоступныеОбъекты, Истина);
		Результат = Форма.ОткрытьМодально();
		Если Результат = Неопределено Тогда
			Возврат Неопределено;
		КонецЕсли;
		ПолноеИмяМД = Результат.ПолноеИмяОбъекта;
	Иначе
		ПолноеИмяМД = ДоступныеОбъекты[0];
	КонецЕсли; 
	МассивФрагментов = ЛксПолучитьМассивИзСтрокиСРазделителем(ПолноеИмяМД);
	Если МассивФрагментов.Количество() > 2 Тогда
		Сообщить("Подбор строк таблицы " + ПолноеИмяМД + " не предусмотрен");
		Возврат Неопределено;
	КонецЕсли; 
	ПараметрыФормы = Новый Структура("МножественныйВыбор, РежимВыбора, ТекущаяСтрока", Истина, Истина, НачальноеЗначениеВыбора);
	Попытка
		ФормаВыбора = ПолучитьФорму(ПолноеИмяМД + ".ФормаВыбора", ПараметрыФормы, ВладелецФормы); 
	Исключение
		ФормаВыбора = ПолучитьФорму(ПолноеИмяМД + ".ФормаСписка", ПараметрыФормы, ВладелецФормы); 
	КонецПопытки; 
	ФормаВыбора.ЗакрыватьПриВыборе = Ложь;
	Если ТипЗнч(ФормаВыбора) = Тип("Форма") Тогда
		ФормаВыбора.МножественныйВыбор = Истина;
		ФормаВыбора.РежимВыбора = Истина;
		ФормаВыбора.НачальноеЗначениеВыбора = НачальноеЗначениеВыбора;
	КонецЕсли; 
	ФормаВыбора.Открыть();
	Возврат ФормаВыбора;

КонецФункции

Функция ПолучитьФормуВыбораОбъектаМетаданныхЛкс(ВладелецФормы, КлючУникальности, НачальноеЗначениеВыбора, МножественныйВыбор = Ложь, 
	ОтображатьСсылочныеОбъекты = Истина, ОтображатьВыборочныеТаблицы = Истина, ОтображатьРегистры = Ложь, ОтображатьПоследовательности = Истина,
	ОтображатьКонстанты = Ложь, ОтображатьТабличныеЧасти = Ложь, ОтображатьТаблицыИзменений = Ложь) Экспорт 
	
	Форма = ирКэш.Получить().ПолучитьФорму("ВыборОбъектаМетаданных", ВладелецФормы, КлючУникальности);
	лСтруктураПараметров = Новый Структура;
	лСтруктураПараметров.Вставить("НачальноеЗначениеВыбора", НачальноеЗначениеВыбора);
	лСтруктураПараметров.Вставить("ОтображатьКонстанты", ОтображатьКонстанты);
	лСтруктураПараметров.Вставить("ОтображатьВыборочныеТаблицы", ОтображатьВыборочныеТаблицы);
	лСтруктураПараметров.Вставить("ОтображатьТаблицыИзменений", ОтображатьТаблицыИзменений);
	лСтруктураПараметров.Вставить("ОтображатьТабличныеЧасти", ОтображатьТабличныеЧасти);
	лСтруктураПараметров.Вставить("ОтображатьРегистры", ОтображатьРегистры);
	лСтруктураПараметров.Вставить("ОтображатьПоследовательности", ОтображатьПоследовательности);
	лСтруктураПараметров.Вставить("ОтображатьСсылочныеОбъекты", ОтображатьСсылочныеОбъекты);
	лСтруктураПараметров.Вставить("МножественныйВыбор", МножественныйВыбор);
	Форма.НачальноеЗначениеВыбора = лСтруктураПараметров;
	Возврат Форма;
	
КонецФункции

// Результат - Неопределено, "*", Число
Функция ПолучитьКоличествоЭлементовКоллекцииЛкс(Значение) Экспорт

	Если Не ЭтоКоллекцияЛкс(Значение) Тогда
		КоличествоЭлементов = Неопределено;
	Иначе
		КоличествоЭлементов = "*";
		Если ТипЗнч(Значение) = Тип("COMSafeArray") Тогда
			КоличествоЭлементов = Значение.GetLength();
		ИначеЕсли ТипЗнч(Значение) = Тип("COMОбъект") Тогда
			Попытка
				КоличествоЭлементов = Значение.Count;
			Исключение
			КонецПопытки; 
		КонецЕсли; 
		Если КоличествоЭлементов = "*" Тогда
			Попытка
				КоличествоЭлементов = Значение.Количество();
			Исключение
			КонецПопытки;
		КонецЕсли;
	КонецЕсли;

	Возврат КоличествоЭлементов;

КонецФункции

Функция ЭтоКоллекцияЛкс(Значение) Экспорт
	
	// Антибаг платформы 8.2.15 http://partners.v8.1c.ru/forum/thread.jsp?id=1017316#1017316
	Если Значение = ПараметрыСеанса Тогда
		Возврат Истина;
	КонецЕсли;
	
	Попытка
		Для Каждого _Элемент Из Значение Цикл
			Прервать;
		КонецЦикла; 
		ЭтоКоллекция = Истина;
	Исключение
		ЭтоКоллекция = Ложь;
	КонецПопытки;
	Возврат ЭтоКоллекция;
	
КонецФункции


// ИсторияФайлов - СписокЗначений
// Кнопки - КнопкиКоманднойПанели
Процедура ОбновитьПодменюИсторииФайловЛкс(ИсторияФайлов, Кнопки, ИмяДействия = "ОткрытьФайлИзИстории") Экспорт
	
	Кнопки.Очистить();
	ДлинаПредставления = 100;
	ДействиеКнопки = Новый Действие(ИмяДействия);
	Для Каждого СтрокаФайла Из ИсторияФайлов Цикл
		Файл = Новый Файл(СтрокаФайла.Значение);
		ДлинаПути = ДлинаПредставления - СтрДлина(Файл.Имя);
		Представление = Лев(Файл.Имя, ДлинаПредставления);
		Если ДлинаПути > 0 Тогда
			Если ДлинаПути < СтрДлина(Файл.Путь) + 3 Тогда
				Представление = Лев(Файл.Путь, ДлинаПути) + "...\" + Представление;
			Иначе
				Представление = Файл.Путь + Представление;
			КонецЕсли; 
		КонецЕсли; 
		КнопкаФайла = Кнопки.Добавить("_" + Формат(ИсторияФайлов.Индекс(СтрокаФайла), "ЧГ=;ЧН="), ТипКнопкиКоманднойПанели.Действие, Представление, ДействиеКнопки);
	КонецЦикла;
	
КонецПроцедуры

Процедура ДобавитьВИсториюЭлементЛкс(СписокИстории, ЗначениеЭлемента, РазмерИстории = 20) Экспорт
	
	ЭлементИстории = СписокИстории.НайтиПоЗначению(ЗначениеЭлемента);
	Если ЭлементИстории <> Неопределено Тогда
		СписокИстории.Удалить(ЭлементИстории);
	КонецЕсли; 
	СписокИстории.Вставить(0, ЗначениеЭлемента);
	Пока СписокИстории.Количество() > РазмерИстории Цикл
		СписокИстории.Удалить(РазмерИстории);
	КонецЦикла;
	
КонецПроцедуры

Процедура ПоместитьТекстВБуферОбменаОСЛкс(Текст) Экспорт
	
	// http://partners.v8.1c.ru/forum/thread.jsp?id=1075241#1075241
	Документ = ирКэш.Получить().СлужебноеПолеHtmlДокумента.Документ; // Так падает после нескольких вызовов
	//Документ = Новый COMОбъект("HTMLFILE");
	Окно = Документ.parentWindow;
	Окно.ClipboardData.SetData("Text", Текст); 
	
Конецпроцедуры

Функция ПолучитьТекстИзБуфераОбменаОСЛкс() Экспорт
	
	// http://partners.v8.1c.ru/forum/thread.jsp?id=1075241#1075241
	Документ = ирКэш.Получить().СлужебноеПолеHtmlДокумента.Документ; // Так падает после нескольких вызовов
	//Документ = Новый COMОбъект("HTMLFILE");
	Окно = Документ.parentWindow;
	Результат = Окно.ClipboardData.GetData("Text"); 
	Возврат Результат;
	
КонецФункции

Функция ОткрытьФормуСпискаСОтбором(ПолноеИмяМД, Отбор) Экспорт
	
	ПараметрыФормы = Новый Структура("Отбор", Отбор);
	ФормаСписка = ПолучитьФорму(ПолноеИмяМД + ".ФормаСписка", ПараметрыФормы);
	Если ТипЗнч(ФормаСписка) = Тип("Форма") Тогда
		Для Каждого КлючИЗначение Из Отбор Цикл
			ЭлементОтбора = ФормаСписка.Отбор[КлючИЗначение.Ключ];
			ЭлементОтбора.Использование = Истина;
			ЭлементОтбора.Значение = КлючИЗначение.Значение;
		КонецЦикла; 
	КонецЕсли;
	ФормаСписка.Открыть();
	Возврат ФормаСписка;

КонецФункции

Процедура ПолеВводаСИсториейВыбора_ПриИзмененииЛкс(ПолеВвода, КлючИстории, ЗапоминатьПоследние = 20, НеЗапоминатьПустыеТипизированные = Истина) Экспорт
	
	Если Ложь
		Или (Истина
			И Не НеЗапоминатьПустыеТипизированные 
			И ПолеВвода.Значение <> ПолеВвода.ТипЗначения.ПривестиЗначение(Неопределено))
		Или ЗначениеЗаполнено(ПолеВвода.Значение)
	Тогда
		КлючНастройки = КлючИстории + "." + ПолеВвода.Имя + ".ПоследниеЗначения";
		ПоследниеЗначения = ВосстановитьЗначение(КлючНастройки);
		Если ТипЗнч(ПоследниеЗначения) <> Тип("Массив") Тогда
			ПоследниеЗначения = Новый Массив;
		КонецЕсли;
		Индекс = ПоследниеЗначения.Найти(ПолеВвода.Значение);
		Если Индекс <> Неопределено Тогда
			ПоследниеЗначения.Удалить(Индекс);
		КонецЕсли;
		ПоследниеЗначения.Вставить(0, ПолеВвода.Значение);
		Для Счетчик = ЗапоминатьПоследние По ПоследниеЗначения.ВГраница() Цикл
			ПоследниеЗначения.Удалить(ЗапоминатьПоследние);
		КонецЦикла;
		СохранитьЗначение(КлючНастройки, ПоследниеЗначения);
	КонецЕсли;
	
КонецПроцедуры

Процедура ПолеВводаСИсториейВыбора_НачалоВыбораИзСпискаЛкс(ПолеВвода, КлючИстории) Экспорт
	
	// Запоминать последние
	КлючНастройки = КлючИстории + "." + ПолеВвода.Имя + ".ПоследниеЗначения";
	ПоследниеЗначения = ВосстановитьЗначение(КлючНастройки);
	Если ТипЗнч(ПоследниеЗначения) = Тип("Массив") Тогда
		ПолеВвода.СписокВыбора.Очистить();
		Для Каждого Значение Из ПоследниеЗначения Цикл
			НовыйЭлемент = ПолеВвода.СписокВыбора.Добавить(Значение);
		КонецЦикла;
	КонецЕсли;
	
КонецПроцедуры

Процедура ПолеФайловогоКаталога_НачалоВыбораЛкс(Элемент, СтандартнаяОбработка) Экспорт 
	
	СтандартнаяОбработка = Ложь;
	ВыборФайла = Новый ДиалогВыбораФайла(РежимДиалогаВыбораФайла.ВыборКаталога);
	ВыборФайла.Каталог = Элемент.Значение;
	Если Не ВыборФайла.Выбрать() Тогда
		Возврат;
	КонецЕсли;
	ЛксИнтерактивноЗаписатьВЭлементУправления(Элемент, ВыборФайла.Каталог);

КонецПроцедуры

Функция ОткрытьСсылкуВСпискеЛкс(Ссылка) Экспорт
	
	ПолноеИмяМД = Ссылка.Метаданные().ПолноеИмя();
	СтруктураПараметры = Новый Структура;
	СтруктураПараметры.Вставить("ТекущаяСтрока", Ссылка);
	ФормаСписка = ПолучитьФорму(ПолноеИмяМД + ".ФормаСписка", СтруктураПараметры, , Новый УникальныйИдентификатор);
	ФормаСписка.Открыть();
	Возврат ФормаСписка;

КонецФункции

// ИменаКолонок - Строка - имена колонок через запятую
Процедура ТабличноеПоле_ОтобразитьФлажкиЛкс(ОформлениеСтроки, Знач ИменаКолонок) Экспорт

	Если ТипЗнч(ИменаКолонок) = Тип("Строка") Тогда
		ИменаКолонок = ЛксПолучитьМассивИзСтрокиСРазделителем(ИменаКолонок, ",", Истина); 
	КонецЕсли; 
	Для Каждого ИмяКолонки Из ИменаКолонок Цикл
		Ячейка = ОформлениеСтроки.Ячейки[ИмяКолонки];
		//Если Ячейка.ТолькоПросмотр Тогда
		//	Продолжить;
		//КонецЕсли;
		Если ТипЗнч(Ячейка.Значение) = Тип("Булево") Тогда
			Ячейка.УстановитьФлажок(Ячейка.Значение);
			Ячейка.УстановитьТекст("");
		КонецЕсли; 
	КонецЦикла;

КонецПроцедуры

Процедура ТабличноеПоле__ПриИзмененииФлажкаИис(Элемент, Знач Колонка) Экспорт
	
	Если ТипЗнч(Колонка.ЭлементУправления) = Тип("ПолеВвода") Тогда
		Если Истина
			И Колонка.Данные = ""
			И Колонка.ДанныеФлажка = ""
		Тогда
			ОформлениеСтроки = Элемент.ОформлениеСтроки(Элемент.ТекущаяСтрока);
			Колонка.ЭлементУправления.Значение = Не ОформлениеСтроки.Ячейки[Колонка.Имя].Значение;
			//ЛксИнтерактивноЗаписатьВКолонкуТабличногоПоля(Элемент, Колонка, Не ОформлениеСтроки.Ячейки[Колонка.Имя].Значение);
			//глВызватьСобытиеПоОбъектуСистемы(ЭтаФорма.мСвойстваФормы, оПолеВвода, сПриИзменении, ЭтаФорма, Колонка.ЭлементУправления);
		Иначе
			//МетаданныеТипа = глПолучитьМетаданныеТипа(ТипЗнч(Элемент.Значение), "ТипСписка", Истина);
			//РедактированиеВДиалоге = Ложь;
			//Если Истина 
			//	И МетаданныеТипа <> Неопределено
			//	И МетаданныеТипа.КлассМетаданных.Предок = оСсылочный
			//Тогда
			//	Попытка
			//		ВыбранныйСпособРедактирования = Элемент.СпособРедактирования;
			//	Исключение
			//	КонецПопытки;
			//	РедактированиеВДиалоге = ВыбранныйСпособРедактирования <> СпособРедактированияСписка.ВСписке;
			//КонецЕсли;
			//РазрешитьИзменение = Истина;
			//Если РедактированиеВДиалоге Тогда
			//Иначе
				//Элемент.ЗакончитьРедактированиеСтроки(Ложь);
				Элемент.ИзменитьСтроку();
				ЗначениеЯчейки = Колонка.ЭлементУправления.Значение;
				Если ТипЗнч(ЗначениеЯчейки) = Тип("Булево") Тогда
					ЛксИнтерактивноЗаписатьВКолонкуТабличногоПоля(Элемент, Колонка, Не ЗначениеЯчейки, , , Ложь);
					//Элемент.ТекущаяКолонка = Колонка;
				КонецЕсли;
				Элемент.ЗакончитьРедактированиеСтроки(Ложь);
			//КонецЕсли;
		КонецЕсли;
	КонецЕсли;
	
КонецПроцедуры

Функция ПолучитьПиктограммуТипаЛкс(Тип) Экспорт 
	
	ИмяОбщегоТипа = Неопределено;
	КлючПоиска = Новый Структура("ИД", ПолучитьИдентификаторТипаЛкс(Тип));
	НайденныеСтроки = ирКэш.Получить().ТаблицаОбщихТипов.НайтиСтроки(КлючПоиска);
	Если НайденныеСтроки.Количество() > 0 Тогда
		ИмяОбщегоТипа = НайденныеСтроки[0].Слово;
	Иначе
		//СтруктураТипа = ирКэш.Получить().ПолучитьСтруктуруТипаИзКонкретногоТипа(Тип);
		//ИмяОбщегоТипа = СтруктураТипа.ИмяОбщегоТипа;
		ОбъектМД = Метаданные.НайтиПоТипу(Тип);
		Если ОбъектМД <> Неопределено Тогда
			ТекущееИмяТипа = ОбъектМД.ПолноеИмя();
			ИмяОбщегоТипа = ЛксПолучитьПервыйФрагмент(ТекущееИмяТипа);
		КонецЕсли; 
	КонецЕсли;
	Картинка = Неопределено;
	Если ИмяОбщегоТипа <> Неопределено Тогда
		ИмяКартинки = "ир" + ЛксПолучитьПервыйФрагмент(ИмяОбщегоТипа);
		Попытка
			Пустышка = БиблиотекаКартинок[ИмяКартинки];
		Исключение
			ИмяКартинки = ИмяОбщегоТипа;
			Попытка
				Пустышка = БиблиотекаКартинок[ИмяКартинки];
			Исключение
				ИмяКартинки = Неопределено;
			КонецПопытки; 
		КонецПопытки; 
		Если ИмяКартинки <> Неопределено Тогда
			Картинка = БиблиотекаКартинок[ИмяКартинки];
		КонецЕсли; 
	КонецЕсли;
	Возврат Картинка;
		
КонецФункции

// ИменаКолонок - Строка - имена колонок через запятую
Процедура ТабличноеПоле_ОтобразитьПиктограммыТиповЛкс(ОформлениеСтроки, ИменаКолонок) Экспорт
	
	Если ТипЗнч(ИменаКолонок) = Тип("Строка") Тогда
		ИменаКолонок = ЛксПолучитьМассивИзСтрокиСРазделителем(ИменаКолонок, ",", Истина); 
	КонецЕсли; 
	Для Каждого ИмяКолонки Из ИменаКолонок Цикл
		Ячейка = ОформлениеСтроки.Ячейки.Найти(ИмяКолонки);
		//:Ячейка=Новый("ОформлениеЯчейки")
		Если Ячейка <> Неопределено Тогда
			ДанныеКартинки = Ячейка.Значение;
			Если ТипЗнч(ДанныеКартинки) = Тип("ПолеКомпоновкиДанных") Тогда
				Продолжить;
			КонецЕсли;
			СсылкаКартинка = Неопределено;
			ТипЗначения = ТипЗнч(ДанныеКартинки);
			Если Истина
				И ТипЗначения = Тип("Булево")
				И Ячейка.ОтображатьФлажок
			Тогда
				Продолжить;
			КонецЕсли;
			КартинкаТипа = ПолучитьПиктограммуТипаЛкс(ТипЗначения);
			Если КартинкаТипа <> Неопределено Тогда
				Ячейка.УстановитьКартинку(КартинкаТипа);
			КонецЕсли;
		КонецЕсли;
	КонецЦикла;

КонецПроцедуры

Функция ТабличноеПоле_СколькоСтрокЛкс(ТабличноеПоле) Экспорт
	
	ЗначениеЭУ = ТабличноеПоле.Значение;
	//ТипЗначенияТабличногоПоля = ТипЗнч(ИсточникДействий.Значение);
	//ИмяОбщегоТипа = ПолучитьИмяОбщегоТипаИзКонкретногоТипа, ТипЗначенияТабличногоПоля);
	Попытка
		Количество = ЗначениеЭУ.Количество();
		Попытка
			Отбор = ТабличноеПоле.ОтборСтрок;
		Исключение
		КонецПопытки;
	Исключение
		Попытка
			//Коллекция компоновки
			Количество = ЗначениеЭУ.Элементы.Количество();
			//Суффикс = "*";
		Исключение
			Попытка
				//Или ИмяОбщегоТипа = "ДеревоЗначений" 
				Количество = ЗначениеЭУ.Строки.Количество();
				Суффикс = "*";
			Исключение
				// ДинамическийСписок
				ОбъектМД = Метаданные.НайтиПоТипу(ТабличноеПоле.ТипЗначения.Типы()[0]);
				Если ОбъектМД = Неопределено Тогда
					Возврат Неопределено;
				КонецЕсли;
				КорневойТип = ЛксПолучитьКорневойТипКонфигурации(ОбъектМД);
				ТекстЗапроса = " ИЗ " + ОбъектМД.ПолноеИмя();
				Если КорневойТип = "РегистрБухгалтерии" Тогда
					ТекстЗапроса = ТекстЗапроса + ".ДвиженияССубконто";
				КонецЕсли;
				ПостроительПростой = Новый ПостроительЗапроса("ВЫБРАТЬ * " + ТекстЗапроса);
				ПостроительПростой.ЗаполнитьНастройки();
				ТекстОтбор = "";
				Для Каждого ДоступноеПоле Из ПостроительПростой.ДоступныеПоля Цикл
					Если Не ДоступноеПоле.Отбор Тогда
						Продолжить;
					КонецЕсли;
					Если ТекстОтбор <> "" Тогда
						ТекстОтбор = ТекстОтбор + ", ";
					КонецЕсли;
					ТекстОтбор = ТекстОтбор + "Т." + ДоступноеПоле.ПутьКДанным;
				КонецЦикла;
				ТекстЗапроса = "ВЫБРАТЬ РАЗРЕШЕННЫЕ КОЛИЧЕСТВО(*) " + ТекстЗапроса + " КАК Т {ГДЕ " + ТекстОтбор + "}";
				ПостроительЗапроса = Новый ПостроительЗапроса(ТекстЗапроса);
				ПостроительЗапроса.ЗаполнитьНастройки();
				
				ЛксСкопироватьОтбор(ПостроительЗапроса.Отбор, ТабличноеПоле.Значение.Отбор, Истина, Истина);
				Отбор = ТабличноеПоле.Значение.Отбор;
				Количество = ПостроительЗапроса.Результат.Выгрузить()[0][0];
			КонецПопытки;
		КонецПопытки;
	КонецПопытки;
	
	Текст = "Количество строк ";
	Если Отбор <> Неопределено Тогда
		Текст = Текст + "с отбором """ + Отбор + """ ";
	КонецЕсли;
	Сообщить(Текст + "- " + Формат(Количество, "ЧН=") + "(" + Формат(Количество, "ЧН=; ЧГ=") + ")" + Суффикс);
	Результат = Количество;
	Возврат Результат;
	
КонецФункции

// Получает картинку для корневого типа конфигурации.
//
// Параметры:
//  пКорневойТип – Строка – корневой тип конфигурации.
//
// Возвращаемое значение:
//               – Картинка – корневого типа конфигурации.
//
Функция ПолучитьКартинкуКорневогоТипаЛкс(пКорневойТип) Экспорт

	Попытка
		Возврат БиблиотекаКартинок["ир" + пКорневойТип];
	Исключение
		Попытка
			Возврат БиблиотекаКартинок[пКорневойТип];
		Исключение
		КонецПопытки; 
	КонецПопытки; 
	Возврат Новый Картинка();

КонецФункции // ПолучитьКартинкуКорневогоТипа()

Функция ОткрытьТекущуюСтрокуТабличногоПоляТаблицыБДВРедактореОбъектаБДЛкс(ТабличноеПоле, ПолноеИмяМД = Неопределено, ДоступныеПоляВыбора = Неопределено) Экспорт
	
	Если ПолноеИмяМД = Неопределено Тогда
		ПолноеИмяМД = Метаданные.НайтиПоТипу(ТипЗнч(ТабличноеПоле.Значение)).ПолноеИмя();
	КонецЕсли; 
	ОбъектМД = Метаданные.НайтиПоПолномуИмени(ПолноеИмяМД);
	ПолноеИмяТаблицы = ирНеглобальный.ПолучитьИмяТаблицыИзМетаданныхЛкс(ПолноеИмяМД);
	ТипТаблицы = ирНеглобальный.ПолучитьТипТаблицыБДЛкс(ПолноеИмяМД);
	СтруктураКлюча = ирНеглобальный.ПолучитьСтруктуруКлючаТаблицыБДЛкс(ПолноеИмяМД);
	КорневойТип = ЛксПолучитьПервыйФрагмент(ПолноеИмяМД);
	ТекущаяСтрока = ТабличноеПоле.ТекущаяСтрока;
	Если ТекущаяСтрока = Неопределено Тогда
		Возврат Неопределено;
	КонецЕсли;
	ТекущаяКолонка = ТабличноеПоле.ТекущаяКолонка;
	Если Истина
		И ТекущаяКолонка <> Неопределено 
		И (Ложь
			Или ДоступныеПоляВыбора = Неопределено
			Или ДоступныеПоляВыбора.НайтиПоле(Новый ПолеКомпоновкиДанных(ТекущаяКолонка.Данные)) <> Неопределено)
	Тогда
	    ИмяКолонки = ТекущаяКолонка.Данные;
	Иначе
		ИмяКолонки = "";
	КонецЕсли; 
	Если СтруктураКлюча.Свойство("НомерСтроки") Тогда
		СтруктураКлючаСтроки = Новый Структура("НомерСтроки");
	ИначеЕсли СтруктураКлюча.Свойство("Период") Тогда
		СтруктураКлючаСтроки = Новый Структура("Период");
	Иначе
		СтруктураКлючаСтроки = Неопределено;
	КонецЕсли;
	Если СтруктураКлючаСтроки <> Неопределено Тогда
		ЗаполнитьЗначенияСвойств(СтруктураКлючаСтроки, ТекущаяСтрока);
	КонецЕсли; 
	Если ЛксЛиКорневойТипСсылки(ТипТаблицы) Тогда
		Ссылка = ТекущаяСтрока.Ссылка;
	ИначеЕсли ЛксЛиТипВложеннойТаблицыБД(ТипТаблицы) Тогда 
		Ссылка = ТекущаяСтрока.Ссылка;
	ИначеЕсли Истина
		И (Ложь
			Или ЛксЛиКорневойТипРегистраБД(ТипТаблицы) 
			Или ЛксЛиКорневойТипПоследовательности(ТипТаблицы)) 
		И (Ложь
			Или ТипТаблицы <> "РегистрСведений"
			Или ОбъектМД.РежимЗаписи <> Метаданные.СвойстваОбъектов.РежимЗаписиРегистра.Независимый)
	Тогда 
		Ссылка = ТекущаяСтрока.Регистратор;
	Иначе
		Возврат Неопределено;
	КонецЕсли; 
	ФормаРедактора = ирНеглобальный.ПолучитьФормуЛкс("Обработка.ирРедакторОбъектаБД.Форма", , , Ссылка);
	ФормаРедактора.Открыть();
	//ФормаРедактора.ПоказатьЯчейкуДанныхОбъекта(ПолноеИмяТаблицы, ИмяКолонки, СтруктураКлючаСтроки);
	ФормаРедактора.ПоказатьЯчейкуДанныхОбъекта(ПолноеИмяМД, ИмяКолонки, СтруктураКлючаСтроки);
	Возврат ФормаРедактора;
	
КонецФункции

Функция КонтрольРазмераВыборкиПользователемЛкс(ЗапросИлиПостроитель, МаксимальноеЧислоСтрок = 500000) Экспорт

	КоличествоСтрокРезультата = ирКэш.Получить().ПолучитьГрубоКоличествоСтрокВРезультатеЗапроса(ЗапросИлиПостроитель);
	Если Истина
		И ТипЗнч(КоличествоСтрокРезультата) = Тип("Число")
		И КоличествоСтрокРезультата > МаксимальноеЧислоСтрок 
	Тогда
		Кнопки = Новый СписокЗначений;
		Кнопки.Добавить("Все", "Все");
		Кнопки.Добавить("Часть", "Первые " + Формат(МаксимальноеЧислоСтрок, "ЧГ="));
		Ответ = Вопрос("Загружаемая таблица содержит " + КоличествоСтрокРезультата + " строк. Сколько строк загружать?", Кнопки, , "Часть");
		//Если Ответ <> КодВозвратаДиалога.ОК Тогда
		//	Возврат;
		//КонецЕсли;
		Если Ответ = "Все" Тогда
			МаксимальноеЧислоСтрок = 0;
		КонецЕсли;
	Иначе
		МаксимальноеЧислоСтрок = 0;
	КонецЕсли;
	Возврат МаксимальноеЧислоСтрок;

КонецФункции

Функция ВычислитьКоличествоСтрокТаблицВДеревеМетаданныхЛкс(ДеревоМетаданных, ИмяКлючевойКолонки = "ПолноеИмяОбъекта", ИмяКолонкиКоличества = "КоличествоСтрок",
	ЛиТаблицыИзменений = Ложь, СтруктураОтбора = Неопределено, ТолькоРазрешенные = Истина) Экспорт
	
	#Если _ Тогда
	    ДеревоМетаданных = Новый ДеревоЗначений
	#КонецЕсли
	МассивКлючей = Новый Массив;
	Для Каждого СтрокаДерева1 Из ДеревоМетаданных.Строки Цикл
		Для Каждого СтрокаДерева2 Из СтрокаДерева1.Строки Цикл
			Если ЛксПолучитьПервыйФрагмент(СтрокаДерева2[ИмяКлючевойКолонки]) = "ВнешнийИсточникДанных"	Тогда
				Продолжить;
			КонецЕсли; 
			МассивКлючей.Добавить(СтрокаДерева2[ИмяКлючевойКолонки]);
			Для Каждого СтрокаДерева3 Из СтрокаДерева2.Строки Цикл
				МассивКлючей.Добавить(СтрокаДерева3[ИмяКлючевойКолонки]);
			КонецЦикла;
		КонецЦикла;
	КонецЦикла;
	ТекстПакета = "";
	ТекстЗапроса = "";
	СчетчикТаблиц = 0;
	Для Каждого КлючМД Из МассивКлючей Цикл
		ИмяТаблицы = ирНеглобальный.ПолучитьИмяТаблицыИзМетаданныхЛкс(КлючМД, ЛиТаблицыИзменений, ТолькоРазрешенные);
		Если ИмяТаблицы = Неопределено Тогда
			Продолжить;
		КонецЕсли; 
		Если ТекстЗапроса <> "" Тогда
			ТекстЗапроса = ТекстЗапроса + "
			|ОБЪЕДИНИТЬ ВСЕ";
		КонецЕсли; 
		ТекстЗапроса = ТекстЗапроса + "
		|ВЫБРАТЬ
		|	""" + КлючМД + """ КАК " + ИмяКлючевойКолонки + ",
		|    Количество(*) КАК " + ИмяКолонкиКоличества + ",";
		Если ЛиТаблицыИзменений Тогда
			ТекстЗапроса = ТекстЗапроса + "
			|    СУММА(ВЫБОР КОГДА Т.НомерСообщения ЕСТЬ NULL ТОГДА 1 ИНАЧЕ 0 КОНЕЦ) КАК КоличествоНевыгруженных,
			|    СУММА(ВЫБОР КОГДА Т.НомерСообщения ЕСТЬ NULL ТОГДА 0 ИНАЧЕ 1 КОНЕЦ) КАК КоличествоВыгруженных,";
		КонецЕсли; 
		ТекстЗапроса = ТекстЗапроса + "
		|    1
		|ИЗ " + ИмяТаблицы + " КАК Т
		|ГДЕ 1 = 1";
		Если СтруктураОтбора <> Неопределено Тогда
			Для Каждого КлючИЗначение Из СтруктураОтбора Цикл
				ТекстЗапроса = ТекстЗапроса + "
				|	И Т." + КлючИЗначение.Ключ + " = &" + КлючИЗначение.Ключ;
			КонецЦикла;
		КонецЕсли; 
		СчетчикТаблиц = СчетчикТаблиц + 1;
		Если СчетчикТаблиц = 255 Тогда
			Если ТекстПакета <> "" Тогда
				ТекстПакета = ТекстПакета + "
				|;";
			КонецЕсли; 
			ТекстПакета = ТекстПакета + ТекстЗапроса;
			ТекстЗапроса = "";
		КонецЕсли; 
	КонецЦикла;
	Если ТекстПакета <> "" Тогда
		ТекстПакета = ТекстПакета + "
		|;";
	КонецЕсли; 
	ТекстПакета = ТекстПакета + ТекстЗапроса;
	Если ЗначениеЗаполнено(ТекстПакета) Тогда
		Запрос = Новый Запрос;
		Если СтруктураОтбора <> Неопределено Тогда
			ЛксСкопироватьУниверсальнуюКоллекцию(СтруктураОтбора, Запрос.Параметры);
		КонецЕсли; 
		Запрос.Текст = ТекстПакета;
		РезультатПакета = Запрос.ВыполнитьПакет();
	Иначе
		РезультатПакета = Новый ТаблицаЗначений;
		// Возможно здесь еще и колонки добавить придется
	КонецЕсли; 
	Возврат РезультатПакета;

КонецФункции

Процедура ЗаполнитьКоличествоСтрокТаблицВДеревеМетаданныхЛкс(ДеревоМетаданных, РезультатПакета, ИмяКлючевойКолонки = "ПолноеИмяОбъекта", ИмяКолонкиКоличества = "КоличествоСтрок") Экспорт
	
	#Если _ Тогда
	    ДеревоМетаданных = Новый ДеревоЗначений
	#КонецЕсли
	Для Каждого РезультатЗапроса Из РезультатПакета Цикл
		ТаблицаРезультата = РезультатЗапроса.Выгрузить();
		Для Каждого СтрокаРезультата Из ТаблицаРезультата Цикл
			СтрокаДерева = ДеревоМетаданных.Строки.Найти(СтрокаРезультата[ИмяКлючевойКолонки], ИмяКлючевойКолонки, Истина);
			Если СтрокаДерева <> Неопределено Тогда
				СтароеКоличество = СтрокаДерева[ИмяКолонкиКоличества];
				Если ТипЗнч(СтароеКоличество) <> Тип("Число") Тогда
					СтароеКоличество = 0;
				КонецЕсли; 
				ЗаполнитьЗначенияСвойств(СтрокаДерева, СтрокаРезультата); 
				Если СтрокаДерева.Уровень() > 1 Тогда
					Продолжить;
				КонецЕсли; 
				Родитель = СтрокаДерева.Родитель;
				Пока Родитель <> Неопределено Цикл
					КоличествоРодителя = Родитель[ИмяКолонкиКоличества];
					Если ТипЗнч(КоличествоРодителя) <> Тип("Число") Тогда
						КоличествоРодителя = 0;
					КонецЕсли; 
					Родитель[ИмяКолонкиКоличества] = КоличествоРодителя - СтароеКоличество + СтрокаДерева[ИмяКолонкиКоличества];
					Родитель = Родитель.Родитель;
				КонецЦикла;
			КонецЕсли; 
		КонецЦикла;
	КонецЦикла; 

КонецПроцедуры

Процедура ОбновитьКоличествоСтрокТаблицВДеревеМетаданныхЛкс(ДеревоМетаданных, ИмяКлючевойКолонки = "ПолноеИмяОбъекта", ИмяКолонкиКоличества = "КоличествоСтрок",
	ЛиТаблицыИзменений = Ложь, СтруктураОтбора = Неопределено) Экспорт
	
	#Если _ Тогда
	    ДеревоМетаданных = Новый ДеревоЗначений
	#КонецЕсли
	РезультатПакета = ВычислитьКоличествоСтрокТаблицВДеревеМетаданныхЛкс(ДеревоМетаданных, ИмяКлючевойКолонки, ИмяКолонкиКоличества, ЛиТаблицыИзменений, СтруктураОтбора);
	ЗаполнитьКоличествоСтрокТаблицВДеревеМетаданныхЛкс(ДеревоМетаданных, РезультатПакета, ИмяКлючевойКолонки, ИмяКолонкиКоличества);

КонецПроцедуры

Процедура УстановитьЗначениеКолонкиДереваЛкс(ДеревоЗначений, ИмяКолонки = "Пометка", НовоеЗначение = Истина) Экспорт
	
	ВсеСтроки = ирНеглобальный.ПолучитьВсеСтрокиДереваЗначенийЛкс(ДеревоЗначений);
	Для Каждого СтрокаДерева Из ВсеСтроки Цикл
		СтрокаДерева.Пометка = НовоеЗначение;
	КонецЦикла; 

КонецПроцедуры

Функция ПолучитьМетаданныеНаборовЗаписейПоРегистраторуЛкс(мдОбъекта) Экспорт

	ОбъектыМД = Новый Массив();
	Для Каждого МетаРегистр из мдОбъекта.Движения Цикл
		ОбъектыМД.Добавить(МетаРегистр);
	КонецЦикла;
	Для Каждого МетаПоследовательность Из Метаданные.Последовательности Цикл
		Если МетаПоследовательность.Документы.Содержит(мдОбъекта) Тогда
			ОбъектыМД.Добавить(МетаПоследовательность);
		КонецЕсли; 
	КонецЦикла;
	Возврат ОбъектыМД;

КонецФункции

// НовыйРежим - Булево - Имя/Синоним
Процедура ТабличноеПоле_ОбновитьКолонкиИмяСинонимЛкс(ТабличноеПоле, НовыйРежим, ИмяКолонкиИмя = "Имя", ИмяКолонкиСиноним = "Представление") Экспорт

	КолонкиТП = ТабличноеПоле.Колонки;
	КолонкаИмя = КолонкиТП[ИмяКолонкиИмя];
	КолонкаСиноним = КолонкиТП[ИмяКолонкиСиноним];
	КолонкаИмя.Видимость = НовыйРежим;
	КолонкаСиноним.Видимость = Не НовыйРежим;
	Если ТипЗнч(ТабличноеПоле.Значение) = Тип("ДеревоЗначений") Тогда
		КолонкаИмя.ОтображатьИерархию = НовыйРежим;
		КолонкаСиноним.ОтображатьИерархию = Не НовыйРежим;
	КонецЕсли;
	ИндексКолонкиИмя = КолонкиТП.Индекс(КолонкаИмя);
	ИндексКолонкиСиноним = КолонкиТП.Индекс(КолонкаСиноним);
	Если НовыйРежим = (ИндексКолонкиИмя > ИндексКолонкиСиноним) Тогда
		КолонкиТП.Сдвинуть(КолонкаИмя, ИндексКолонкиСиноним - ИндексКолонкиИмя);
	КонецЕсли; 
	Если НовыйРежим Тогда
		ТабличноеПоле.ТекущаяКолонка = ТабличноеПоле.Колонки.Имя;
	Иначе
		ТабличноеПоле.ТекущаяКолонка = ТабличноеПоле.Колонки.Представление;
	КонецЕсли;

КонецПроцедуры

Процедура ТабличноеПоле_ОформитьЯчейкиИмяСинонимЛкс(ТабличноеПоле, ОформлениеСтроки,
	ИмяКолонкиИмя = "Имя", ИмяКолонкиСиноним = "Представление", ИмяКолонкиИндексКартинки = "ИндексКартинки", ДанныеФлажка = "") Экспорт

	ДанныеСтроки = ОформлениеСтроки.ДанныеСтроки;
	Если ТабличноеПоле.Колонки[ИмяКолонкиИмя].Видимость Тогда
		ВедущаяКолонка = ТабличноеПоле.Колонки[ИмяКолонкиИмя];
		ВедущийИндекс = ТабличноеПоле.Колонки.Индекс(ВедущаяКолонка);
	КонецЕсли; 
	Если ТабличноеПоле.Колонки[ИмяКолонкиСиноним].Видимость Тогда
		Если Ложь
			Или ВедущаяКолонка = Неопределено 
			Или ТабличноеПоле.Колонки.Индекс(ТабличноеПоле.Колонки[ИмяКолонкиСиноним]) < ВедущийИндекс
		Тогда
			ВедущаяКолонка = ТабличноеПоле.Колонки[ИмяКолонкиСиноним];
		КонецЕсли; 
	КонецЕсли;
	Если ВедущаяКолонка <> Неопределено Тогда
		Ячейка = ОформлениеСтроки.Ячейки[ВедущаяКолонка.Имя];
		ИндексКартинки = ДанныеСтроки[ИмяКолонкиИндексКартинки];
		Если ИндексКартинки >= 0 Тогда
			Ячейка.ОтображатьКартинку = Истина;
			Ячейка.ИндексКартинки = ИндексКартинки;
		КонецЕсли; 
		Если ДанныеФлажка <> "" Тогда
			Ячейка.ОтображатьФлажок = Истина;
			Ячейка.Флажок = ДанныеСтроки[ДанныеФлажка];
		КонецЕсли;
		КоличествоДочерних = ДанныеСтроки.Строки.Количество();
		Если КоличествоДочерних > 0 Тогда
			Ячейка.УстановитьТекст(Ячейка.Текст + " (" + КоличествоДочерних + ")");
		КонецЕсли; 
	КонецЕсли; 

КонецПроцедуры

Функция ОпределитьВедущуюСтроковуюКолонкуТабличногоПоляЛкс(ТабличноеПолеДерева) Экспорт
	
	Если Истина
		И ТабличноеПолеДерева.ТекущаяКолонка <> Неопределено
		И ЗначениеЗаполнено(ТабличноеПолеДерева.ТекущаяКолонка.Данные)
		И ТабличноеПолеДерева.Значение.Колонки[ТабличноеПолеДерева.ТекущаяКолонка.Данные].ТипЗначения.СодержитТип(Тип("Строка"))
	Тогда
		ТекущаяКолонкаТП = ТабличноеПолеДерева.ТекущаяКолонка;
	Иначе
		Для Каждого КолонкаТП Из ТабличноеПолеДерева.Колонки Цикл
			Если Не КолонкаТП.Видимость Тогда
				Продолжить;
			КонецЕсли; 
			КолонкаДерева = ТабличноеПолеДерева.Значение.Колонки[КолонкаТП.Данные];
			Если КолонкаДерева.ТипЗначения.СодержитТип(Тип("Строка")) Тогда
				ТекущаяКолонкаТП = КолонкаТП;
				Прервать;
			КонецЕсли; 
		КонецЦикла;
	КонецЕсли; 
	Возврат ТекущаяКолонкаТП; 
	
КонецФункции

Функция НайтиСтрокуТабличногоПоляДереваЗначенийСоСложнымФильтромЛкс(ТабличноеПолеДерева, ПолеВводаФильтра, Подстроки = "") Экспорт
	
	ТекущаяКолонкаТП = ОпределитьВедущуюСтроковуюКолонкуТабличногоПоляЛкс(ТабличноеПолеДерева);
	Если ТекущаяКолонкаТП = Неопределено Тогда
		Возврат Неопределено;
	КонецЕсли; 
	ИмяТекущейКолонки = ТекущаяКолонкаТП.Данные;
	Если Не ЗначениеЗаполнено(ИмяТекущейКолонки) Тогда
		Возврат Неопределено;
	КонецЕсли; 
	ВсеСтроки = ирНеглобальный.ПолучитьВсеСтрокиДереваЗначенийЛкс(ТабличноеПолеДерева.Значение);
	ТекущаяСтрока = ТабличноеПолеДерева.ТекущаяСтрока;
	Если Подстроки = "" Тогда
		Подстроки = ПолеВводаФильтра.Значение;
	КонецЕсли; 
	Фрагменты = ЛксПолучитьМассивИзСтрокиСРазделителем(НРег(Подстроки), " ", Истина);
	ИндексСтроки = 0;
	Если ТекущаяСтрока <> Неопределено Тогда
		Если ирНеглобальный.ЛиСтрокаСодержитВсеПодстрокиЛкс(ТекущаяСтрока[ИмяТекущейКолонки], Фрагменты) Тогда
			ИндексСтроки = ВсеСтроки.Найти(ТекущаяСтрока) + 1;
		КонецЕсли; 
	КонецЕсли; 
	Успех = Ложь;
	Для ИндексСтроки = ИндексСтроки По ВсеСтроки.Количество() - 1 Цикл
		ТекущаяСтрока = ВсеСтроки[ИндексСтроки];
		Если ирНеглобальный.ЛиСтрокаСодержитВсеПодстрокиЛкс(ТекущаяСтрока[ИмяТекущейКолонки], Фрагменты) Тогда
			ТабличноеПолеДерева.ТекущаяСтрока = ТекущаяСтрока;
			ТабличноеПолеДерева.ТекущаяКолонка = ТекущаяКолонкаТП;
			Успех = Истина;
			Прервать;
		КонецЕсли; 
	КонецЦикла;
	Если Успех Тогда
		ПолеВводаФильтра.ЦветФонаПоля = Новый Цвет();
	Иначе
		ТекущаяСтрока = Неопределено;
		ПолеВводаФильтра.ЦветФонаПоля = ЦветаСтиля.ирЦветФонаОшибки;
	КонецЕсли;
	Возврат ТекущаяСтрока;
	
КонецФункции

Процедура ТабличноеПолеДеревоЗначений_РазвернутьВсеСтрокиЛкс(ТабличноеПоле, ЧислоПервыхИгнорируемыхСтрок = 0) Экспорт
	
	Счетчик = 0;
	Для Каждого Строка Из ТабличноеПоле.Значение.Строки Цикл
		Счетчик = Счетчик + 1;
		Если Счетчик > ЧислоПервыхИгнорируемыхСтрок Тогда
			ТабличноеПоле.Развернуть(Строка, Истина);
		КонецЕсли; 
	КонецЦикла;
	
КонецПроцедуры

Процедура ТабличноеПолеДеревоЗначений_АвтоРазвернутьВсеСтрокиЛкс(ТабличноеПоле, МаксимальноеЧислоСтрок = 30, ТекущаяСтрокаУстановлена = Ложь) Экспорт
	
	ВсеСтроки = ПолучитьВсеСтрокиДереваЗначенийЛкс(ТабличноеПоле.Значение);
	ЧислоДинамическихСтрок = ВсеСтроки.Количество();
	Если ЧислоДинамическихСтрок > 0 Тогда
		Если ЧислоДинамическихСтрок <= МаксимальноеЧислоСтрок Тогда
			ТабличноеПолеДеревоЗначений_РазвернутьВсеСтрокиЛкс(ТабличноеПоле);
			Если Не ТекущаяСтрокаУстановлена Тогда
				ТабличноеПоле.ТекущаяСтрока = ТабличноеПоле.Значение.Строки[0].Строки[0];
			КонецЕсли; 
		Иначе
			Если Не ТекущаяСтрокаУстановлена Тогда
				ТабличноеПоле.ТекущаяСтрока = ТабличноеПоле.Значение.Строки[0];
			КонецЕсли; 
		КонецЕсли; 
	КонецЕсли; 
	
КонецПроцедуры

Функция ДобавитьСсылкуВИзбранноеЛкс(Ссылка, ДобавлятьВИзбранноеРаботыПользователя = Истина, ДобавлятьВИзрабнноеИнтерфейснойПанели = Истина) Экспорт
	
	Если ДобавлятьВИзбранноеРаботыПользователя Тогда
		Избранное = ХранилищеСистемныхНастроек.Загрузить("Общее/ИзбранноеРаботыПользователя");
		Если Избранное = Неопределено Тогда
			Избранное = Новый ИзбранноеРаботыПользователя;
		КонецЕсли; 
		ЭлементИзбранного = Новый ЭлементИзбранногоРаботыПользователя;
		ЭлементИзбранного.НавигационнаяСсылка = ПолучитьНавигационнуюСсылку(Ссылка);
		Избранное.Добавить(ЭлементИзбранного);
		ХранилищеСистемныхНастроек.Сохранить("Общее/ИзбранноеРаботыПользователя", "", Избранное);
	КонецЕсли; 
	Если ДобавлятьВИзрабнноеИнтерфейснойПанели Тогда
		ФормаИнтерфейснойПанели = Обработки.ирИнтерфейснаяПанель.ПолучитьФорму();
		СтруктураЭлемента = Новый Структура();
		СтруктураЭлемента.Вставить("Вид", Ссылка.Метаданные().ПолноеИмя());
		СтруктураЭлемента.Вставить("Представление", "" + Ссылка);
		СтруктураЭлемента.Вставить("Имя", "" + Ссылка.УникальныйИдентификатор());
		ФормаИнтерфейснойПанели.ДобавитьСтрокуВСтатическуюВетку(СтруктураЭлемента, "Избранное");
		Если ФормаИнтерфейснойПанели.Открыта() Тогда
			ФормаИнтерфейснойПанели.ЗаполнитьСтатическиеВеткиДереваИнтерфейса(ФормаИнтерфейснойПанели);
		Иначе
			ФормаИнтерфейснойПанели.СохранитьНастройки(ФормаИнтерфейснойПанели);
		КонецЕсли; 
	КонецЕсли;
	
КонецФункции

// 
Функция ТрансформироватьОтборВОтборКомпоновкиЛкс(Знач ОтборКомпоновкиДанных, Знач ЭлементыОтбора, Знач СоответствиеИмен = Неопределено,
	Знач ПроверятьДоступностьПолей = Истина, Знач ДоступныеПоляОтбора = Неопределено, ПропускатьВыключенные = Ложь) Экспорт
	
	Если СоответствиеИмен = Неопределено Тогда
		СоответствиеИмен = Новый ТаблицаЗначений();
		СоответствиеИмен.Колонки.Добавить("Источник");
		//СоответствиеИмен.Колонки.Добавить("Приемник");
	КонецЕсли;
	Если ДоступныеПоляОтбора = Неопределено Тогда
		ДоступныеПоляОтбора = ОтборКомпоновкиДанных.ДоступныеПоляОтбора;
	КонецЕсли;
	ИндексГраницы = ЭлементыОтбора.Количество() - 1;
	ИзмененныеЭлементыОтбора = Новый Массив;
	Платформа = ирКэш.Получить();
	Для Каждого ЭлементОтбора Из ЭлементыОтбора Цикл
		Если Истина 
			И ПропускатьВыключенные
			И Не ЭлементОтбора.Использование
		Тогда
			Продолжить;
		КонецЕсли; 
		Если ТипЗнч(ЭлементОтбора) = Тип("ГруппаЭлементовОтбораКомпоновкиДанных") Тогда
			ПриемникОтбора = ОтборКомпоновкиДанных.Элементы.Добавить(Тип("ГруппаЭлементовОтбораКомпоновкиДанных"));
			ЗаполнитьЗначенияСвойств(ПриемникОтбора, ЭлементОтбора);
			ТрансформироватьОтборВОтборКомпоновкиЛкс(ПриемникОтбора, ЭлементОтбора.Элементы, СоответствиеИмен, , ДоступныеПоляОтбора);
			Продолжить;
		КонецЕсли;
		Если ТипЗнч(ЭлементОтбора) = Тип("ЭлементОтбораКомпоновкиДанных") Тогда
			Если ТипЗнч(ЭлементОтбора.ЛевоеЗначение) <> Тип("ПолеКомпоновкиДанных")	Тогда
				Продолжить;
			КонецЕсли;
			//ПутьКДаннымЛевый = Неопределено;
			//Если ТипЗнч(ЭлементОтбора.ЛевоеЗначение) = Тип("ПолеКомпоновкиДанных") Тогда
				ПутьКДаннымЛевый = "" + ЭлементОтбора.ЛевоеЗначение;
			//Иначе
			//	ЛевоеЗначение = ЭлементОтбора.ЛевоеЗначение;
			//КонецЕсли;
			ПутьКДаннымПравый = Неопределено;
			Если ТипЗнч(ЭлементОтбора.ПравоеЗначение) = Тип("ПолеКомпоновкиДанных") Тогда
				ПутьКДаннымПравый = "" + ЭлементОтбора.ПравоеЗначение;
			Иначе
				ПравоеЗначение = ЭлементОтбора.ПравоеЗначение;
			КонецЕсли;
			лВидСравнения = ЭлементОтбора.ВидСравнения;
		Иначе
			СтрокаВидаСравнения = Платформа.СоответствиеВидовСравнения.Найти(ЭлементОтбора.ВидСравнения, "Построитель");
			Если СтрокаВидаСравнения = Неопределено Тогда
				// %%%% Здесь можно добавить интеллекта
				Продолжить;
			КонецЕсли;
			ПутьКДаннымЛевый = ЭлементОтбора.ПутьКДанным;
			ПутьКДаннымПравый = Неопределено;
			лВидСравнения = СтрокаВидаСравнения.Компоновка;
			ПравоеЗначение = ЭлементОтбора.Значение;
		КонецЕсли;
	
		//Если ПутьКДаннымЛевый <> Неопределено Тогда
			МассивФрагментов = ЛксПолучитьМассивИзСтрокиСРазделителем(ПутьКДаннымЛевый);
			СтрокаИсточника = СоответствиеИмен.Найти(НРег(МассивФрагментов[0]), "Источник");
			Если СтрокаИсточника <> Неопределено Тогда
				МассивФрагментов[0] = СтрокаИсточника.Приемник;
			КонецЕсли;
			ПутьКДанным = ЛксПолучитьСтрокуСРазделителемИзМассива(МассивФрагментов, ".");
			ПолеКомпоновки = Новый ПолеКомпоновкиДанных(ПутьКДанным);
			ПолеОтбора = Неопределено;
			Для Каждого лЭлементОтбора Из ОтборКомпоновкиДанных.Элементы Цикл
				Если Истина
					И ТипЗнч(лЭлементОтбора) = Тип("ЭлементОтбораКомпоновкиДанных")
					И лЭлементОтбора.ЛевоеЗначение = ПолеКомпоновки 
					И ИзмененныеЭлементыОтбора.Найти(лЭлементОтбора) = Неопределено
				Тогда
					ПолеОтбора = лЭлементОтбора;
					ИзмененныеЭлементыОтбора.Добавить(ПолеОтбора);
					Прервать;
				КонецЕсли;
			КонецЦикла;
			Если ПолеОтбора = Неопределено Тогда
				ДоступноеПоле = ДоступныеПоляОтбора.НайтиПоле(ПолеКомпоновки);
				Если Истина
					И ПроверятьДоступностьПолей
					И ДоступноеПоле = Неопределено
				Тогда
					Продолжить;
				КонецЕсли;
				ПолеОтбора = ОтборКомпоновкиДанных.Элементы.Добавить(Тип("ЭлементОтбораКомпоновкиДанных"));
				ПолеОтбора.ЛевоеЗначение = ПолеКомпоновки;
			КонецЕсли;
		//Иначе
		//	ПолеОтбора.ПравоеЗначение = ЛевоеЗначение;
		//КонецЕсли;
		Если ПутьКДаннымПравый <> Неопределено Тогда
			МассивФрагментов = ЛксПолучитьМассивИзСтрокиСРазделителем(ПутьКДаннымПравый);
			СтрокаИсточника = СоответствиеИмен.Найти(НРег(МассивФрагментов[0]), "Источник");
			Если СтрокаИсточника <> Неопределено Тогда
				МассивФрагментов[0] = СтрокаИсточника.Приемник;
			КонецЕсли;
			ПутьКДанным = ЛксПолучитьСтрокуСРазделителемИзМассива(МассивФрагментов, ".");
			ПолеКомпоновки = Новый ПолеКомпоновкиДанных(ПутьКДанным);
			ПолеОтбора.ПравоеЗначение = ПолеКомпоновки;
		Иначе
			ПолеОтбора.ПравоеЗначение = ПравоеЗначение;
		КонецЕсли;
		ПолеОтбора.ВидСравнения   = лВидСравнения;
		ПолеОтбора.Использование  = ЭлементОтбора.Использование;
	КонецЦикла;
	
КонецФункции

Процедура ОткрытьОбъектыИзВыделенныхЯчеекВПодбореИОбработкеОбъектов(ТабличноеПоле) Экспорт 

	Если ирКэш.Получить().Это2iS Тогда
		ДУ("УФ(П1, П2)", "ОткрытьКоллекциюВКонсолиОбработкиДанных", ТабличноеПоле.Значение);
	Иначе
		ВыделенныеСтроки = ТабличноеПоле.ВыделенныеСтроки;
		Если ВыделенныеСтроки.Количество() = 0 Тогда
			Возврат ;
		КонецЕсли; 
		ИмяКолонки = ТабличноеПоле.ТекущаяКолонка.Данные;
		МассивСсылок = Новый Массив;
		Для Каждого Строка Из ВыделенныеСтроки Цикл
			ЗначениеСтроки = Строка[ИмяКолонки];
			ТипЗначения = ТипЗнч(ЗначениеСтроки);
			Если Метаданные.НайтиПоТипу(ТипЗначения) = Неопределено Тогда
				Продолжить;
			КонецЕсли; 
			МассивСсылок.Добавить(ЗначениеСтроки);
		КонецЦикла;
		ОткрытьМассивОбъектовВПодбореИОбработкеОбъектовЛкс(МассивСсылок);
	КонецЕсли; 

КонецПроцедуры // ОткрытьОбъектыИзВыделенныхЯчеекВПодбореИОбработкеОбъектов()

Функция ОткрытьПодборИОбработкуОбъектовИзТабличногоПоляДинамическогоСпискаЛкс(ТабличноеПоле) Экспорт 

	ОбъектМД = Метаданные.НайтиПоТипу(ТипЗнч(ТабличноеПоле.Значение));
	Если ОбъектМД <> Неопределено Тогда
		Ответ = Вопрос("Обработать только выделенные строки (Да) иначе будет использован текущий отбор (Нет)?", РежимДиалогаВопрос.ДаНет);
	Иначе
		Ответ = КодВозвратаДиалога.Да;
	КонецЕсли; 
	Если Ответ = КодВозвратаДиалога.Да Тогда
		ПараметрКоманды = Новый Массив();
		Для Каждого Строка Из ТабличноеПоле.ВыделенныеСтроки Цикл
			ПараметрКоманды.Добавить(Строка);
		КонецЦикла; 
		Форма = ирНеглобальный.ОткрытьМассивОбъектовВПодбореИОбработкеОбъектовЛкс(ПараметрКоманды);
	Иначе
		Форма = Обработки.ирПодборИОбработкаОбъектов.ПолучитьФорму(,, ОбъектМД.ПолноеИмя());
		Форма.Открыть();
		Форма.УстановитьОбластьПоиска();
		Форма.СтрокаПоиска = "";
		//ЛксСкопироватьОтбор(Форма.ПостроительОтчета.Отбор, ИсточникДействий.Значение.Отбор, Истина, Истина);
		Форма.Компоновщик.Настройки.Отбор.Элементы.Очистить();
		ирНеглобальный.ТрансформироватьОтборВОтборКомпоновкиЛкс(Форма.Компоновщик.Настройки.Отбор, ТабличноеПоле.Значение.Отбор,,,, Истина);
	КонецЕсли;
	Возврат Форма;

КонецФункции

Функция ОткрытьМассивОбъектовВПодбореИОбработкеОбъектовЛкс(МассивСсылок) Экспорт 

	Если МассивСсылок.Количество() = 0 Тогда
		Возврат Неопределено;
	КонецЕсли; 
	Форма = Обработки.ирПодборИОбработкаОбъектов.ПолучитьФорму();
	Форма.Открыть();
	Форма.ЗагрузитьОбъектыДляОбработки(МассивСсылок);
	Возврат Форма;

КонецФункции // ОткрытьМассивОбъектовВПодбореИОбработкеОбъектовЛкс()

Функция ПолучитьСтруктуруВосстановленияКонсолиЛкс(ИмяИлиОбъектКонсоли) Экспорт 

	Если ТипЗнч(ИмяИлиОбъектКонсоли) = Тип("Строка") Тогда
		ИмяКонсоли = ИмяИлиОбъектКонсоли;
	Иначе
		ИмяКонсоли = ИмяИлиОбъектКонсоли.Метаданные().Имя;
	КонецЕсли; 
	Структура = Новый Структура();
	Структура.Вставить("БлокировкаВосстановления", Неопределено);
	ПрефиксИмениФайлаВосстановления = ИмяКонсоли + "_" + ИмяПользователя() + "_";
	Структура.Вставить("ПрефиксИмениФайлаВосстановления", ПрефиксИмениФайлаВосстановления);
	ИмяФайлаВосстановления = ирКэш.Получить().КаталогФайловогоКэша + "\" + ПрефиксИмениФайлаВосстановления 
		+ Формат(НомерСеансаИнформационнойБазы(), "ЧЦ=8; ЧВН=; ЧГ=") + ".tmp";
	Структура.Вставить("ФайлВосстановления", Новый Файл(ИмяФайлаВосстановления));
	Возврат Структура;

КонецФункции

Функция СохранитьФайлВКонсолиСВосстановлениемЛкс(ДиалогВыбораФайла, Знач ИмяСохраняемогоФайла, ИмяОткрытогоФайла = "", ДанныеДляФайла,
	СтруктураВосстановления, ЗапрашиватьИмяФайла = Ложь) Экспорт

	#Если _ Тогда
	    ДиалогВыбораФайла = Новый ДиалогВыбораФайла();
	#КонецЕсли
	ФайлВосстановления = СтруктураВосстановления.ФайлВосстановления;
	ПрефиксИмениФайлаВосстановления = СтруктураВосстановления.ПрефиксИмениФайлаВосстановления;
	БлокировкаВосстановления = СтруктураВосстановления.БлокировкаВосстановления;
	СохранитьФайл = Истина;
	Если НРег(ИмяСохраняемогоФайла) <> НРег(ФайлВосстановления.ПолноеИмя) Тогда
		ФайлВыбран = Истина;
		лФайл = Новый Файл(ИмяОткрытогоФайла);
		ДиалогВыбораФайла.ПолноеИмяФайла = ИмяСохраняемогоФайла;
		Если Ложь
			Или ПустаяСтрока(ИмяСохраняемогоФайла) 
			Или ЗапрашиватьИмяФайла 
			Или Найти(Нрег(лФайл.Имя), НРег(ПрефиксИмениФайлаВосстановления)) = 1
		Тогда
			Пока Истина Цикл
				Если ДиалогВыбораФайла.Выбрать() Тогда
					лФайл = Новый Файл(ДиалогВыбораФайла.ПолноеИмяФайла);
					Если Найти(Нрег(лФайл.Имя), НРег(ПрефиксИмениФайлаВосстановления)) = 1 Тогда
						КодОтвета = Вопрос("Это имя файла зарезервировано. Хотите выбрать другое?", РежимДиалогаВопрос.ОКОтмена);
						Если КодОтвета = КодВозвратаДиалога.ОК Тогда
							Продолжить;
						Иначе
							ФайлВыбран = Ложь;
							Прервать;
						КонецЕсли; 
					КонецЕсли;
					ИмяСохраняемогоФайла = ДиалогВыбораФайла.ПолноеИмяФайла;
					ФайлВыбран = Истина;
					Прервать;
				Иначе
					ФайлВыбран = Ложь;
					СохранитьФайл = Ложь;
					Прервать;
				КонецЕсли;
			КонецЦикла; 
		КонецЕсли;
	Иначе
		ФайлВыбран = Ложь;
	КонецЕсли; 
	Если СохранитьФайл Тогда
		Если Истина
			И НРег(ИмяСохраняемогоФайла) = НРег(ФайлВосстановления.ПолноеИмя)
			И БлокировкаВосстановления <> Неопределено 
		Тогда
			БлокировкаВосстановления = Неопределено;
		КонецЕсли; 
		ЗначениеВФайл(ИмяСохраняемогоФайла, ДанныеДляФайла);
		Если НРег(ИмяСохраняемогоФайла) = НРег(ФайлВосстановления.ПолноеИмя) Тогда
			БлокировкаВосстановления = Новый ЗаписьТекста(ИмяСохраняемогоФайла,,,Истина);
		КонецЕсли; 
	КонецЕсли; 
	Возврат ФайлВыбран;

КонецФункции

Функция ПроверитьВыбратьФайлВосстановленияКонсолиЛкс(СтруктураВосстановления) Экспорт

	ПрефиксИмениФайлаВосстановления = СтруктураВосстановления.ПрефиксИмениФайлаВосстановления;
	СписокВосстановления = Новый СписокЗначений;
	ФайлыВосстановления = НайтиФайлы(ирКэш.Получить().КаталогФайловогоКэша, ПрефиксИмениФайлаВосстановления + "*.tmp");
	Для Каждого ФайлВосстановления Из ФайлыВосстановления Цикл
		#Если _ Тогда
		    ФайлВосстановления = Новый Файл();
		#КонецЕсли
		Попытка
			ФайлВосстановления.УстановитьВремяИзменения(ФайлВосстановления.ПолучитьВремяИзменения());
			//Пустышка = Новый ЗаписьТекста(ФайлВосстановления.ПолноеИмя, , , Истина);
		Исключение
			// Файла заблокирован и значит сессия продолжается.
			Продолжить;
		КонецПопытки; 
		СписокВосстановления.Добавить(ФайлВосстановления.ПолноеИмя, "" + ФайлВосстановления.ПолучитьВремяИзменения() + " - " 
			+ ФайлВосстановления.ИмяБезРасширения);
	КонецЦикла;
	ИмяФайлаВосстановления = "";
	Если СписокВосстановления.Количество() > 0 Тогда
		СписокВосстановления.СортироватьПоПредставлению(НаправлениеСортировки.Убыв);
		СписокВосстановления.Добавить("<Удалить все файлы восстановления>");
		ВыбранныйЭлемент = СписокВосстановления.ВыбратьЭлемент("Вы можете открыть файл восстановления прерванной сессии");
		Если ВыбранныйЭлемент <> Неопределено Тогда
			Если ВыбранныйЭлемент.Значение = "<Удалить все файлы восстановления>" Тогда
				Для Каждого ЭлементСписка Из СписокВосстановления Цикл
					Если ВыбранныйЭлемент = ЭлементСписка Тогда
						Продолжить;
					КонецЕсли; 
					УдалитьФайлы(ЭлементСписка.Значение);
				КонецЦикла;
			Иначе
				ИмяФайлаВосстановления = ВыбранныйЭлемент.Значение;
			КонецЕсли; 
		КонецЕсли;
	КонецЕсли;
	Возврат ИмяФайлаВосстановления;

КонецФункции

Процедура УдалитьФайлВосстановленияКонсолиСБлокировкойЛкс(СтруктураВосстановления) Экспорт
	
	СтруктураВосстановления.БлокировкаВосстановления = Неопределено;
	Попытка
		УдалитьФайлы(СтруктураВосстановления.ФайлВосстановления.ПолноеИмя);
	Исключение
	КонецПопытки; 

КонецПроцедуры

Функция ПолучитьРежимЗаписиНаСервереПоУмолчаниюЛкс() Экспорт

	Результат = Истина
		И ирКэш.ЛиНемобильныйРежимЛкс()
		И Метаданные.ОсновнойРежимЗапуска = РежимЗапускаКлиентскогоПриложения.УправляемоеПриложение;
	Возврат Результат;
	
КонецФункции

// ТабличноеПоле определяется как источник действий командной панели.
// Параметру ВыборкаРезультата внутри присваивается значение!
Процедура ЗагрузитьДинамическуюВыборкуВТабличноеПолеПервуюПорциюЛкс(ЭтаФорма, РезультатЗапроса, ВыборкаРезультата, КоманднаяПанель,
	ИмяОбработчикаОбновления = "ОбновитьРазмерДинамическойТаблицы", БезопасныйПорогКоличестваСтрок = 100000) Экспорт

	#Если _ Тогда
		лЗапрос = Новый Запрос;
	    РезультатЗапроса = лЗапрос.Выполнить();
	#КонецЕсли
	ВыборкаРезультата = РезультатЗапроса.Выбрать();
	ТабличноеПоле = КоманднаяПанель.ИсточникДействий;
	Если Ложь
		Или БезопасныйПорогКоличестваСтрок = 0
		Или ВыборкаРезультата.Количество() < БезопасныйПорогКоличестваСтрок 
	Тогда
		КоманднаяПанель.Кнопки.ЗагрузитьПолностью.Доступность = Ложь;
		ТабличноеПоле.Значение = РезультатЗапроса.Выгрузить(ОбходРезультатаЗапроса.Прямой);
		Попытка
			Выполнить("ЭтаФорма." + ИмяОбработчикаОбновления + "()");
		Исключение
			ВызватьИсключение ОписаниеОшибки();
		КонецПопытки;
	Иначе
		ТабличноеПоле.Значение = Новый ТаблицаЗначений;
		Для Каждого Колонка Из РезультатЗапроса.Колонки Цикл
			ТипЗначения = Колонка.ТипЗначения;
			Если ТипЗначения.СодержитТип(Тип("РезультатЗапроса")) Тогда
				ТипЗначения = Новый ОписаниеТипов("ТаблицаЗначений");
			КонецЕсли; 
			ТабличноеПоле.Значение.Колонки.Добавить(Колонка.Имя, ТипЗначения, Колонка.Имя, Колонка.Ширина);
		КонецЦикла;
		ЭтаФорма.ПодключитьОбработчикОжидания(ИмяОбработчикаОбновления, 0.1, Истина);
		ирНеглобальный.СчитатьПорциюДинамическойВыборкиВТаблицуЛкс(ВыборкаРезультата, ТабличноеПоле.Значение);
	КонецЕсли; 

КонецПроцедуры

// ТабличноеПоле определяется как источник действий командной панели.
Процедура ЗагрузитьДинамическуюВыборкуВТабличноеПолеПолностьюЛкс(ЭтаФорма, мВыборкаРезультата, КоманднаяПанель,
	ИмяОбработчикаОбновления = "ОбновитьРазмерДинамическойТаблицы") Экспорт

	ЭтаФорма.ПодключитьОбработчикОжидания(ИмяОбработчикаОбновления, 0.1, Истина);
	ТабличноеПоле = КоманднаяПанель.ИсточникДействий;
	ирНеглобальный.СчитатьПорциюДинамическойВыборкиВТаблицуЛкс(мВыборкаРезультата, ТабличноеПоле.Значение, 0);

КонецПроцедуры

// Параметру КоличествоРезультата внутри присваивается значение!
Процедура ПослеЗагрузкиДинамическойВыборкиВТабличноеПолеЛкс(ЭтаФорма, мВыборкаРезультата, КоманднаяПанель, ПолеСтрокиКоличестваРезультата) Экспорт
	
	ТабличноеПоле = КоманднаяПанель.ИсточникДействий;
	Если ТипЗнч(мВыборкаРезультата) = Тип("COMОбъект") Тогда
		КоличествоРезультата = 0;
		Попытка
			КоличествоРезультата = мВыборкаРезультата.Count;
		Исключение
			Если мВыборкаРезультата.State <> 0 Тогда
				КоличествоРезультата = мВыборкаРезультата.RecordCount;
			КонецЕсли; 
		КонецПопытки; 
	ИначеЕсли ТипЗнч(мВыборкаРезультата) = Тип("ВыборкаИзРезультатаЗапроса") Тогда
		КоличествоРезультата = мВыборкаРезультата.Количество();
	Иначе
		КоличествоРезультата = ТабличноеПоле.Значение.Количество();
	КонецЕсли; 
	ОбновитьЧислоЗагруженныхЭлементовВыборкиЛкс(ТабличноеПоле, КоманднаяПанель, ПолеСтрокиКоличестваРезультата, ТабличноеПоле.Значение.Количество(),
		КоличествоРезультата);

КонецПроцедуры

Процедура ОбновитьЧислоЗагруженныхЭлементовВыборкиЛкс(ТабличноеПоле, КоманднаяПанель, ПолеСтрокиКоличестваРезультата, КоличествоЗагружено, КоличествоРезультата) Экспорт
	
	ВсеСчитано = КоличествоЗагружено = КоличествоРезультата;
	Если ВсеСчитано Тогда
		СтрокаКоличествоРезультата = "" + КоличествоЗагружено;
		ПолеСтрокиКоличестваРезультата.ЦветФона = Новый Цвет();
	Иначе
		СтрокаКоличествоРезультата = "" + КоличествоЗагружено + "/" + КоличествоРезультата;
		ПолеСтрокиКоличестваРезультата.ЦветФона = ЦветаСтиля.ирЦветФонаВычисляемогоЗначения;
	КонецЕсли;
	ПолеСтрокиКоличестваРезультата.Значение = СтрокаКоличествоРезультата;
	КоманднаяПанель.Кнопки.ЗагрузитьПолностью.Доступность = Не ВсеСчитано;

КонецПроцедуры

Функция СоздатьСсылочныйОбъектПоМетаданнымЛкс(ОбъектМД, ЭтоГруппаДляНового = Ложь, ИдентификаторСсылки = Неопределено) Экспорт

	Если ИдентификаторСсылки = Неопределено Тогда
		ИдентификаторСсылки = Новый УникальныйИдентификатор();
	КонецЕсли; 
	Объект = Новый (СтрЗаменить(ОбъектМД.ПолноеИмя(), ".", "Объект."));
	// Антибаг платформы 8.2.14 http://partners.v8.1c.ru/forum/thread.jsp?id=967697#967697
	//Объект = СериализаторXDTO.ЗаписатьXDTO(Объект);
	//Объект.Ref = ИдентификаторСсылки;
	//Объект.IsFolder = ЭтоГруппаДляНового;
	//Объект = СериализаторXDTO.ПрочитатьXDTO(Объект);
	//
	// Этот метод опасный, т.к. может привести к нежелательным изменениям в объекте!
	ЗаписьХмл = Новый ЗаписьXML;
	ЗаписьХмл.УстановитьСтроку();
	ЗаписатьXML(ЗаписьХмл, Объект);
	СтрокаХмл = ЗаписьХмл.Закрыть();
	ИмяЭлементаСсылки = "Ref";
	СтрокаХмл = СтрЗаменить(СтрокаХмл, "<" + ИмяЭлементаСсылки + ">" + XMLСтрока(Объект.Ссылка) + "</" + ИмяЭлементаСсылки + ">",
		"<" + ИмяЭлементаСсылки + ">" + XMLСтрока(ИдентификаторСсылки) + "</" + ИмяЭлементаСсылки + ">");
	ИмяЭлементаЭтоГруппа = "IsFolder";
	Если Найти(СтрокаХмл, "<" + ИмяЭлементаЭтоГруппа + ">") > 0 Тогда
		СтрокаХмл = СтрЗаменить(СтрокаХмл, "<" + ИмяЭлементаЭтоГруппа + ">" + XMLСтрока(Объект.IsFolder) + "</" + ИмяЭлементаЭтоГруппа + ">",
			"<" + ИмяЭлементаЭтоГруппа + ">" + XMLСтрока(ЭтоГруппаДляНового) + "</" + ИмяЭлементаЭтоГруппа + ">");
	КонецЕсли; 
	ЧтениеХмл = Новый ЧтениеXML;
	ЧтениеХмл.УстановитьСтроку(СтрокаХмл);
	Объект = ПрочитатьXML(ЧтениеХмл);

	Возврат Объект;

КонецФункции

// Формирует макет компоновки и извлекает из него запрос
// Параметры:
//   Схема - СхемаКомпоновкиДанных
//   НастройкаКомпоновкиДанных - НастройкиКомпоновкиДанных
//   ДобавлятьУпорядочивание - Булево
//   ПрефиксИменПараметров - Строка, *"" - используется для переименования параметров, полезно при смешивании нескольких запросов из компоновки в один
//   выхСхемаКолонок - Структура, *Неопределено - если не равно Неопределено, то возвращается структура, 
//                                         где ключи - имена колонок, а значения - полные имена полей
//
// Результат - Запрос
//
Функция ПолучитьЗапросИзКомпоновкиЛкс(Знач Схема, Знач НастройкаКомпоновкиДанных, Знач ДобавлятьУпорядочивание = Ложь, ПрефиксИменПараметров = "",
	ДобавитьВыбранноеПоле = "", выхСхемаКолонок = Неопределено) Экспорт
	
	#Если _ Тогда
	    НастройкаКомпоновкиДанных = Новый НастройкиКомпоновкиДанных
	#КонецЕсли
	Если НастройкаКомпоновкиДанных.Структура.Количество() = 0 Тогда
		НайтиДобавитьЭлементСтруктурыГруппировкаКомпоновкиЛкс(НастройкаКомпоновкиДанных.Структура);
	КонецЕсли; 
	Если ЗначениеЗаполнено(ДобавитьВыбранноеПоле) Тогда
		ирНеглобальный.НайтиДобавитьЭлементНастроекКомпоновкиПоПолюЛкс(НастройкаКомпоновкиДанных.Выбор, ДобавитьВыбранноеПоле);
	КонецЕсли; 
	СтрокаПорядка = ЛксПолучитьСтрокуПорядкаКомпоновки(НастройкаКомпоновкиДанных.Порядок);
	НастройкаКомпоновкиДанных.Порядок.Элементы.Очистить();
	КомпоновщикМакета = Новый КомпоновщикМакетаКомпоновкиДанных;
	МакетКомпоновки = КомпоновщикМакета.Выполнить(Схема, НастройкаКомпоновкиДанных, ,, Тип("ГенераторМакетаКомпоновкиДанныхДляКоллекцииЗначений"));
	Запрос = Новый Запрос;
	Если МакетКомпоновки.НаборыДанных.Количество() > 2 Тогда
		Сообщить("В макете компоновки обнаружено более одного запроса");
	КонецЕсли;
	ТекстЗапроса = МакетКомпоновки.НаборыДанных[0].Запрос; 
	Если ДобавлятьУпорядочивание Тогда
		Если ЗначениеЗаполнено(СтрокаПорядка) Тогда
			ТекстЗапроса = ТекстЗапроса + "
			|//Секция_Упорядочить. Этот комментарий используется в коде
			|УПОРЯДОЧИТЬ ПО
			|	" + СтрокаПорядка;
		КонецЕсли;
		//Если Автоупорядочивание Тогда
			ТекстЗапроса = ТекстЗапроса + "
			|//Секция_Упорядочить. Этот комментарий используется в коде
			|АВТОУПОРЯДОЧИВАНИЕ";
		//КонецЕсли; 
	КонецЕсли;
	Если ПрефиксИменПараметров <> "" Тогда
		ТекстЗапроса = СтрЗаменить(ТекстЗапроса, "&", "&" + ПрефиксИменПараметров);
	КонецЕсли; 
	Запрос.Текст = ТекстЗапроса;
	Для Каждого ЗначениеПараметра Из МакетКомпоновки.ЗначенияПараметров Цикл
		Запрос.Параметры.Вставить(ПрефиксИменПараметров + ЗначениеПараметра.Имя, ЗначениеПараметра.Значение);
	КонецЦикла;
	Если выхСхемаКолонок <> Неопределено Тогда
		//выхСхемаКолонок = ПолучитьСхемуКолонокМакетаКомпоновкиДанныхЛкс(МакетКомпоновки);
		//
		Для Каждого ПолеНабора Из МакетКомпоновки.НаборыДанных[0].Поля Цикл
			выхСхемаКолонок.Вставить(ПолеНабора.Имя, ПолеНабора.ПутьКДанным);
		КонецЦикла;
	КонецЕсли;
	Возврат Запрос;
	
КонецФункции

Функция ПолучитьТекстОтбораЗапросаКомпоновкиЛкс(ЗапросСОтбором, ПсевдонимТаблицы = "Т") Экспорт

	ТекстОтбораДублей = ЛксПолучитьПоследнийФрагмент(ЗапросСОтбором.Текст, "КАК " + ПсевдонимТаблицы + "
	|ГДЕ", Ложь);
	Если Не ЗначениеЗаполнено(ТекстОтбораДублей) Тогда
		ТекстОтбораДублей = " ИСТИНА ";
	КонецЕсли; 
	Возврат ТекстОтбораДублей;

КонецФункции

// Осуществляет вывод результата компоновки в коллекцию значений. По умолчанию в качестве коллекции используется новая таблица значений.
// Параметры:
//   СхемаКомпоновки - СхемаКомпоновкиДанных
//   НастройкаКомпоновки - НастройкиКомпоновкиДанных
//   КоллекцияЗначений - ДеревоЗначений, Массив, СписокЗначений, ТаблицаЗначений - Если не указана, создается ТаблицаЗначений
//   ВнешниеНаборыДанных - Структура
//   ТолькоСоздатьКолонки - Булево
//   СхемаКолонок - Структура - Если Неопределено, то не возвращается
//   МаксимальноеЧислоСтрокРезультата - Число(15,2) - Для предотвращения получения слишком большого результата. Если порог превышен, то результат = Неопределено.
//   ОтключитьОбщиеИтоги - Булево
//   РежимОтладки - Булево
//
Функция СкомпоноватьВКоллекциюЗначенийПоСхемеЛкс(Знач СхемаКомпоновки, Знач НастройкаКомпоновки, КоллекцияЗначений = Неопределено, Знач ВнешниеНаборыДанных,
	Знач ТолькоСоздатьКолонки = Ложь, СхемаКолонок = Неопределено, Знач МаксимальноеЧислоСтрокРезультата = 0, Знач ОтключитьОбщиеИтоги = Истина, Знач РежимОтладки = Ложь) Экспорт
	
	Если НастройкаКомпоновки.Структура.Количество() = 0 Тогда
		//ЭлементСтруктуры = НастройкаКомпоновки.Структура.Добавить(Тип("ГруппировкаКомпоновкиДанных"));
		//ЭлементСтруктуры.Выбор.Элементы.Добавить(Тип("АвтоВыбранноеПолеКомпоновкиДанных"));
		НайтиДобавитьЭлементСтруктурыГруппировкаКомпоновкиЛкс(НастройкаКомпоновки.Структура);
	КонецЕсли;
	Если ОтключитьОбщиеИтоги Тогда
		НастройкаКомпоновки.ПараметрыВывода.УстановитьЗначениеПараметра(Новый ПараметрКомпоновкиДанных("ВертикальноеРасположениеОбщихИтогов"),
			РасположениеИтоговКомпоновкиДанных.Нет);
	КонецЕсли;
	Если Ложь
		Или КоллекцияЗначений = Неопределено 
		Или ТипЗнч(КоллекцияЗначений) = Тип("СписокЗначений")
		Или ТипЗнч(КоллекцияЗначений) = Тип("Массив")
	Тогда
		КоллекцияРезультата = Новый ТаблицаЗначений;
	Иначе
		КоллекцияРезультата = КоллекцияЗначений;
	КонецЕсли;
	Если РежимОтладки Тогда
		Отладить(СхемаКомпоновки, Ложь, НастройкаКомпоновки, ВнешниеНаборыДанных);
		//Возврат Неопределено;
	КонецЕсли;
	КомпоновщикМакета = Новый КомпоновщикМакетаКомпоновкиДанных;
	Попытка
		МакетКомпоновки = КомпоновщикМакета.Выполнить(СхемаКомпоновки, НастройкаКомпоновки, , ,
			Тип("ГенераторМакетаКомпоновкиДанныхДляКоллекцииЗначений"));
	Исключение
		//ИнформацияОбОшибке = ИнформацияОбОшибке();
		//Если глКэш.ЭтоВидимоеПриложение Тогда
		//	ПоказатьИнформациюОбОшибке(ИнформацияОбОшибке);
		//Иначе
		//	ВызватьИсключение ПодробноеПредставлениеОшибки(ИнформацияОбОшибке);
		//КонецЕсли;
		ВызватьИсключение;
		Возврат Неопределено;
	КонецПопытки;
	//Исследовать(МакетКомпоновки, Ложь);
	//Отладить(МакетКомпоновки, Ложь);
	//Возврат Неопределено;
	
	Если МаксимальноеЧислоСтрокРезультата > 0 Тогда
		// Здесь тратится дополнительное ощутимое время на предварительный запрос.
		ирПлатформа = ирКэш.Получить();
		ГрубоеКоличествоСтрокРезультата = ирПлатформа.ПолучитьГрубоКоличествоСтрокВРезультатеКомпоновки(МакетКомпоновки);
		Если ГрубоеКоличествоСтрокРезультата > МаксимальноеЧислоСтрокРезультата Тогда
			Сообщить("Настройки компоновки приводят к слишком большой выборке данных. Попробуйте задать более сильные ограничения.");
			Возврат Неопределено;
		КонецЕсли;
	КонецЕсли;
	
	//Антибаг платформы 1.14. Удаляем дубли ячеек по именам колонок в макете.
	//Исследовать(МакетКомпоновки, Ложь);
	ОписанияМакетовОбластей = МакетКомпоновки.Макеты;
	Если ОписанияМакетовОбластей.Количество() > 0 Тогда
		ЯчейкиЗаголовка = ОписанияМакетовОбластей[0].Макет.Ячейки;
		КоличествоЯчеек = ЯчейкиЗаголовка.Количество(); 
		СтруктураКолонок = Новый Структура;
		ИндексЯчейки = 0;
		Пока ИндексЯчейки < КоличествоЯчеек Цикл
			ЯчейкаКолонки = ЯчейкиЗаголовка[ИндексЯчейки];
			ИмяКолонки = ЯчейкаКолонки.Имя;
			//ИмяКолонки = ирПлатформа.ПолучитьИдентификаторИзПредставления(ЯчейкаКолонки.Имя); // От этого варианта отказались из-за мобильности
			ИмяКолонки = СтрЗаменить(ИмяКолонки, ".", "_");
			ИмяКолонки = СтрЗаменить(ИмяКолонки, "]", "");
			ИмяКолонки = СтрЗаменить(ИмяКолонки, "[", "");
			ИмяКолонки = СтрЗаменить(ИмяКолонки, " ", "_");
			ЯчейкаКолонки.Имя = ИмяКолонки;
			Если СтруктураКолонок.Свойство(ИмяКолонки) Тогда
				Для ИндексМакета = 1 По ОписанияМакетовОбластей.Количество() - 1 Цикл
					МакетСтроки = ОписанияМакетовОбластей[ИндексМакета];
					МакетСтроки.Макет.Ячейки.Удалить(ИндексЯчейки);
				КонецЦикла;
				ЯчейкиЗаголовка.Удалить(ИндексЯчейки);
				КоличествоЯчеек = КоличествоЯчеек - 1;
			Иначе
				ИндексЯчейки = ИндексЯчейки + 1;
				СтруктураКолонок.Вставить(ИмяКолонки);
			КонецЕсли;
		КонецЦикла;
	КонецЕсли;
	
	Если СхемаКолонок <> Неопределено Тогда
		// Схема колонок строится негарантировано, т.к. платформа не предоставляет нужных данных
		СхемаКолонок.Очистить();
		Если ЯчейкиЗаголовка <> Неопределено Тогда
			КоличествоЯчеекЗаголовка = ЯчейкиЗаголовка.Количество();
			Для Индекс = 0 По КоличествоЯчеекЗаголовка - 1 Цикл
				Для Каждого ОписаниеМакетаОбласти Из ОписанияМакетовОбластей Цикл
					// Здесь подсказка криво работает из-за кривого синтакс-помощника 8.2.13.205
					// http://partners.v8.1c.ru/forum/thread.jsp?id=898023#898023
					ЯчейкаМакетаОбласти = ОписаниеМакетаОбласти.Макет.Ячейки[Индекс];
					Если ТипЗнч(ЯчейкаМакетаОбласти) <> Тип("ЯчейкаМакетаКоллекцииЗначенийОбластиКомпоновкиДанных") Тогда
						Продолжить;
					КонецЕсли;
					ПараметрЯчейки = ЯчейкаМакетаОбласти.Значение;
					Если ПараметрЯчейки = Неопределено Тогда
						Продолжить;
					КонецЕсли;
					Выражение = ОписаниеМакетаОбласти.Параметры["" + ПараметрЯчейки].Выражение;
					ПозицияТочки = Найти(Выражение, ".");
					Если Ложь
						Или ПозицияТочки = 0
						Или Найти(Выражение, " ") > 0
						Или Найти(Выражение, "(") > 0
					Тогда
						//ИмяПоля = "";
						Продолжить;
					Иначе
						ИмяПоля = Сред(Выражение, ПозицияТочки + 1);
					КонецЕсли;
					СхемаКолонок.Вставить(ЯчейкиЗаголовка[Индекс].Имя, ИмяПоля);
					Прервать;
				КонецЦикла;
			КонецЦикла;	
		КонецЕсли;
	КонецЕсли;
	
	Если ТолькоСоздатьКолонки Тогда
		КоллекцияЗначений.Колонки.Очистить();
		ЯчейкиЗаголовка = МакетКомпоновки.Макеты[0].Макет.Ячейки;
		Для Каждого Ячейка Из ЯчейкиЗаголовка Цикл
			//КолонкаКоллекции = КоллекцияЗначений.Колонки.Найти(Ячейка.Имя);
			//Если КолонкаКоллекции = Неопределено Тогда
				КоллекцияЗначений.Колонки.Добавить(Ячейка.Имя, Ячейка.ТипЗначения, Ячейка.Заголовок,);
			//КонецЕсли;
		КонецЦикла; 
	Иначе
		ПроцессорКомпоновки = Новый ПроцессорКомпоновкиДанных;
		ПроцессорКомпоновки.Инициализировать(МакетКомпоновки, ВнешниеНаборыДанных, , Истина);
		ПроцессорВывода = Новый ПроцессорВыводаРезультатаКомпоновкиДанныхВКоллекциюЗначений;
		ПроцессорВывода.УстановитьОбъект(КоллекцияРезультата);
		ПроцессорВывода.Вывести(ПроцессорКомпоновки);
	КонецЕсли;
	//Исследовать(КоллекцияРезультата);
	Если ТипЗнч(КоллекцияЗначений) = Тип("СписокЗначений") Тогда
		Есть0 = КоллекцияРезультата.Колонки.Количество() > 0;
		Есть1 = КоллекцияРезультата.Колонки.Количество() > 1;
		Для Каждого СтрокаРезультата Из КоллекцияРезультата Цикл
			НовыйЭлемент = КоллекцияЗначений.Добавить();
			Если Есть0 Тогда
				НовыйЭлемент.Значение = СтрокаРезультата[0];
			КонецЕсли;
			Если Есть1 Тогда
				НовыйЭлемент.Представление = СтрокаРезультата[1];
			КонецЕсли;
		КонецЦикла;
	ИначеЕсли ТипЗнч(КоллекцияЗначений) = Тип("Массив") Тогда
		Если КоллекцияРезультата.Колонки.Количество() > 0 Тогда
			Для Каждого СтрокаРезультата Из КоллекцияРезультата Цикл
				КоллекцияЗначений.Добавить(СтрокаРезультата[0]);
			КонецЦикла;
		КонецЕсли;
	Иначе
		КоллекцияЗначений = КоллекцияРезультата;
	КонецЕсли;
	Результат = КоллекцияЗначений;
	Возврат Результат;
	
КонецФункции

Функция НайтиПоказатьСтрокуВПолеТекстовогоДокументаЛкс(Форма, ПолеТекстовогоДокумента, СтрокаПоиска) Экспорт
	
	Позиция = Найти(Нрег(ПолеТекстовогоДокумента.ПолучитьТекст()), Нрег(СтрокаПоиска));
	Если Позиция > 0 Тогда
		ПолеТекстовогоДокумента.УстановитьГраницыВыделения(Позиция, Позиция + СтрДлина(СтрокаПоиска));
		Форма.ТекущийЭлемент = ПолеТекстовогоДокумента;
		Результат = Истина;
	Иначе
		Если СтрДлина(ПолеТекстовогоДокумента.ВыделенныйТекст) > 0 Тогда
			ПолеТекстовогоДокумента.УстановитьГраницыВыделения(1, 1);
		КонецЕсли; 
		Результат = Ложь;
	КонецЕсли;
	Возврат Результат;

КонецФункции

// Параметры:
//   Элемент - ПолеТабличногоДокумента
//
Функция ПолеТабличногоДокумента_ПолучитьПредставлениеСуммыВыделенныхЯчеекЛкс(Знач Элемент) Экспорт
	
	Сумма = 0;
	СчетчикЯчеекСуммы = 0;
	СчетчикЯчеекОбщий = 0;
	ВыделенныеОбласти = Элемент.ВыделенныеОбласти;
	ЕстьИгнорированныеОбласти = Ложь;
	НачальноеКоличество = ВыделенныеОбласти.Количество();
	Для СчетчикВыделенныеОбласти = 1 По НачальноеКоличество Цикл
		Область = ВыделенныеОбласти[НачальноеКоличество - СчетчикВыделенныеОбласти];
		Если ТипЗнч(Область) = Тип("РисунокТабличногоДокумента") Тогда
			Продолжить;
		КонецЕсли;
		ПлощадьОбласти = (Область.Право - Область.Лево + 1) * (Область.Низ - Область.Верх + 1);
		СчетчикЯчеекОбщий = СчетчикЯчеекОбщий + ПлощадьОбласти;
		Если ПлощадьОбласти < 10000 Тогда
			Для НомерКолонки = Область.Лево по Область.Право Цикл
				Для НомерСтроки = Область.Верх по Область.Низ Цикл
					ОбластьЯчейки = Элемент.Область(НомерСтроки, НомерКолонки);
					Если ОбластьЯчейки.Лево <> НомерКолонки Или ОбластьЯчейки.Верх <> НомерСтроки Тогда
						// Данная ячейка принадлежит объединенным ячейкам и не является начальной ячейкой
						Продолжить;
					КонецЕсли;
					Попытка
						Число = Число(ОбластьЯчейки.Текст);
					Исключение 
						Продолжить;
					КонецПопытки; 
					Сумма = Сумма + Число;
					СчетчикЯчеекСуммы = СчетчикЯчеекСуммы + 1;
				КонецЦикла;
			КонецЦикла;
		Иначе
			ЕстьИгнорированныеОбласти = Истина;
		КонецЕсли;
	КонецЦикла;
	СчетчикЯчеекСуммы = "" + СчетчикЯчеекСуммы;
	Сумма = "" + Сумма;
	Если ЕстьИгнорированныеОбласти Тогда
		СчетчикЯчеекСуммы = СчетчикЯчеекСуммы + "+?";
		Сумма = Сумма + "+?";
	КонецЕсли;
	Текст = "" + СчетчикЯчеекСуммы + " из " + СчетчикЯчеекОбщий + " яч. = " + Сумма + "";
	Возврат Текст;
	
КонецФункции

// Таблица - ТаблицаЗначений, ТабличнаяЧасть, РезультатЗапроса
Функция ВывестиТаблицуВТабличныйДокументЛкс(Таблица, Знач ТабличныйДокумент = Неопределено, ДанныеРасшифровки = Неопределено, ИтогиЧисловыхПолей = Истина,
	АвтофиксацияШапки = Истина) Экспорт

	ВнешниеНаборыДанных = Новый Структура("Основной", Таблица);
	СхемаКомпоновки = ЛксСоздатьСхемуПоТаблицамЗначений(ВнешниеНаборыДанных, , , ИтогиЧисловыхПолей);
	НастройкаКомпоновки = Новый НастройкиКомпоновкиДанных;
	Для Каждого Колонка Из Таблица.Колонки Цикл
		ирНеглобальный.НайтиДобавитьЭлементНастроекКомпоновкиПоПолюЛкс(НастройкаКомпоновки.Выбор, Колонка.Имя);
	КонецЦикла;
	ТабличныйДокумент = СкомпоноватьВТабличныйДокументЛкс(СхемаКомпоновки, НастройкаКомпоновки, ТабличныйДокумент, ВнешниеНаборыДанных,
		ДанныеРасшифровки, АвтофиксацияШапки);
	Возврат ТабличныйДокумент;

КонецФункции

Функция СкомпоноватьВТабличныйДокументЛкс(СхемаКомпоновки, НастройкаКомпоновки, Знач ТабличныйДокумент = Неопределено, ВнешниеНаборыДанных = Неопределено,
	ДанныеРасшифровки = Неопределено, АвтофиксацияШапки = Истина) Экспорт

	#Если _ Тогда
	    НастройкаКомпоновки = Новый НастройкиКомпоновкиДанных;
	#КонецЕсли
	Если НастройкаКомпоновки.Структура.Количество() = 0 Тогда
		ирНеглобальный.НайтиДобавитьЭлементСтруктурыГруппировкаКомпоновкиЛкс(НастройкаКомпоновки.Структура);
	КонецЕсли; 
	КомпоновщикМакета = Новый КомпоновщикМакетаКомпоновкиДанных;
	Если ДанныеРасшифровки = Неопределено Тогда
		ДанныеРасшифровки = Новый ДанныеРасшифровкиКомпоновкиДанных;
	КонецЕсли; 
	МакетКомпоновки = КомпоновщикМакета.Выполнить(СхемаКомпоновки, НастройкаКомпоновки, ДанныеРасшифровки);
	ПроцессорКомпоновки = Новый ПроцессорКомпоновкиДанных;
	ПроцессорКомпоновки.Инициализировать(МакетКомпоновки, ВнешниеНаборыДанных, ДанныеРасшифровки);
	Если ТабличныйДокумент = Неопределено Тогда
		ТабличныйДокумент = Новый ТабличныйДокумент;
	КонецЕсли;
	ЛксВывестиРезультатКомпоновкиСАвтофиксациейСтрок(ТабличныйДокумент, ПроцессорКомпоновки, ДанныеРасшифровки.Элементы,,, АвтофиксацияШапки);
	Возврат ТабличныйДокумент;

КонецФункции

// мВнешниеНаборыДанных - Структура, Неопределено - не очищается
Функция ДополнитьСтруктуруВнешихНаборовДанныхПустышкамиЛкс(лСхемаКомпоновкиДанных, мВнешниеНаборыДанных = Неопределено) Экспорт

	Если мВнешниеНаборыДанных = Неопределено Тогда
		мВнешниеНаборыДанных = Новый Структура();
	КонецЕсли; 
	// Создадим пустышки внешних наборов данных, если они не переданы
	ОбъектТаблица = 0;
	Для Каждого НаборДанных Из лСхемаКомпоновкиДанных.НаборыДанных Цикл
		Если ТипЗнч(НаборДанных) = Тип("НаборДанныхОбъектСхемыКомпоновкиДанных") Тогда
			Если НаборДанных.ИмяОбъекта = "" Тогда
				Продолжить;
			КонецЕсли; 
			Если Не мВнешниеНаборыДанных.Свойство(НаборДанных.ИмяОбъекта, ОбъектТаблица) Тогда 
				ОбъектТаблица = Новый ТаблицаЗначений;
			КонецЕсли;
			Попытка
				КолонкиОбъектаТаблицы = ОбъектТаблица.Колонки;
			Исключение
				// Тогда это табличная часть, но возможно и тут будет исключение
				КолонкиОбъектаТаблицы = ОбъектТаблица.ВыгрузитьКолонки().Колонки;
			КонецПопытки;
			Если КолонкиОбъектаТаблицы.Количество() > 0 Тогда
				Продолжить;
			КонецЕсли; 
			Для Каждого Поле Из НаборДанных.Поля Цикл
				Если ТипЗнч(Поле) = Тип("ПолеНабораДанныхСхемыКомпоновкиДанных") Тогда
					Если КолонкиОбъектаТаблицы.Найти(Поле.Поле) = Неопределено Тогда
						КолонкиОбъектаТаблицы.Добавить(Поле.Поле, Поле.ТипЗначения);
					КонецЕсли;
				КонецЕсли;
			КонецЦикла;
			мВнешниеНаборыДанных.Вставить(НаборДанных.ИмяОбъекта, ОбъектТаблица);
		КонецЕсли; 
	КонецЦикла;

	Возврат мВнешниеНаборыДанных;

КонецФункции

Функция ВыбратьТипСсылкиВПолеВводаЛкс(Элемент, СтандартнаяОбработка) Экспорт

	Форма = ирКэш.Получить().ПолучитьФорму("ВыборОбъектаМетаданных", Элемент, Элемент);
	лСтруктураПараметров = Новый Структура;
	лСтруктураПараметров.Вставить("ОтображатьСсылочныеОбъекты", Истина);
	Форма.НачальноеЗначениеВыбора = лСтруктураПараметров;
	ЗначениеВыбора = Форма.ОткрытьМодально();
	Если ТипЗнч(ЗначениеВыбора) = Тип("Структура") Тогда
		лПолноеИмяОбъекта = Неопределено;
		Если ЗначениеВыбора.Свойство("ПолноеИмяОбъекта", лПолноеИмяОбъекта) Тогда
			ИмяТипаСсылки = ирНеглобальный.ПолучитьИмяТипаИзМетаданныхЛкс(лПолноеИмяОбъекта);
			ОписаниеТипов = Новый ОписаниеТипов(ИмяТипаСсылки);
			НовоеЗначение = ОписаниеТипов.ПривестиЗначение(Неопределено);
			ЛксИнтерактивноЗаписатьВЭлементУправления(Элемент, НовоеЗначение);
		КонецЕсли;
	КонецЕсли;
	СтандартнаяОбработка = Ложь;
	Возврат Неопределено;

КонецФункции

Функция ЛиПустаяПодгруппаRegExpЛкс(Подгруппа) Экспорт
	
	Результат = Ложь
		Или Подгруппа = Неопределено
		Или Подгруппа = "";
	Возврат Результат;
	
КонецФункции

// Для "Ссылка.Организация" вернет "Организация", для "Основание.Контрагент" вернет "ОснованиеКонтрагент"
// Параметры:
//   ИмяПоля - Строка
Функция ПолучитьИмяКолонкиРезультатаПоИмениПоляЛкс(Знач ИмяПоля) Экспорт

	Начало = "Ссылка.";
	ДлинаНачала = СтрДлина(Начало);
	Если СтрокиРавныЛкс(Лев(ИмяПоля, ДлинаНачала), Начало) Тогда
		ИмяПоля = Сред(ИмяПоля, ДлинаНачала + 1);
	КонецЕсли; 
	ИмяПоля = СтрЗаменить(ИмяПоля, ".", "");
	Возврат ИмяПоля;
	
КонецФункции

Процедура ДобавитьМногострочнуюСтрокуВТекстЛкс(СобираемыйТекст, Выражение, Смещение, СНовойСтроки = Ложь) Экспорт
	
	Если СНовойСтроки Тогда
		СобираемыйТекст = СобираемыйТекст + Символы.ПС + Смещение;
	КонецЕсли; 
	СобираемыйТекст = СобираемыйТекст + СтрПолучитьСтроку(Выражение, 1);
	Для Счетчик = 2 По СтрЧислоСтрок(Выражение) Цикл
		СобираемыйТекст = СобираемыйТекст + Символы.ПС + Смещение + СтрПолучитьСтроку(Выражение, Счетчик);
	КонецЦикла;
	
КонецПроцедуры

Функция ПолучитьАвтоУникальноеИмяВКоллекцииСтрокЛкс(ТаблицаЗначений, БазовоеИмяИлиСтрока, ИмяКлючевойКолонки = "Имя", ИмяДолжноБытьИдентификатором = Истина,
	ЗаменаПустойСтроки = "_", ДопустимаяДлинаИдентификатора = 50) Экспорт
	
	ТекущийИндекс = 0;
	Если Ложь
		Или ТипЗнч(БазовоеИмяИлиСтрока) = Тип("СтрокаТаблицыЗначений") 
		Или ТипЗнч(БазовоеИмяИлиСтрока) = Тип("СтрокаДереваЗначений") 
	Тогда
		ИсключаемаяСтрока = БазовоеИмяИлиСтрока;
		БазовоеИмя = БазовоеИмяИлиСтрока[ИмяКлючевойКолонки];
		//ТекущийИндекс = 1;
	Иначе
		БазовоеИмя = БазовоеИмяИлиСтрока;
	КонецЕсли; 
	Если ИмяДолжноБытьИдентификатором Тогда
		БазовоеИмя = ирКэш.Получить().ПолучитьИдентификаторИзПредставления(БазовоеИмя, ЗаменаПустойСтроки);
		БазовоеИмя = Лев(БазовоеИмя, ДопустимаяДлинаИдентификатора);
	Иначе
		Если ПустаяСтрока(БазовоеИмя) Тогда
			БазовоеИмя = ЗаменаПустойСтроки;
		КонецЕсли; 
	КонецЕсли; 
	Пока Истина Цикл
		ТекущийПсевдоним = БазовоеИмя + Формат(ТекущийИндекс, "ЧГ=");
		СтрокиОдноименных = ТаблицаЗначений.НайтиСтроки(Новый Структура(ИмяКлючевойКолонки, ТекущийПсевдоним));
		Если Ложь
			Или СтрокиОдноименных.Количество() = 0
			Или (Истина
				И СтрокиОдноименных.Количество() = 1
				И ИсключаемаяСтрока <> Неопределено
				И ирНеглобальный.СтрокиРавныЛкс(ТекущийПсевдоним, ИсключаемаяСтрока[ИмяКлючевойКолонки])
				)
		Тогда
			Прервать;
		КонецЕсли;
		ТекущийИндекс = ТекущийИндекс + 1;
	КонецЦикла;
	Возврат ТекущийПсевдоним;
	
КонецФункции

Функция ПолучитьИндексКартинкиТипаЛкс(ОписаниеТипов) Экспорт

	Если ОписаниеТипов = Неопределено Тогда
		Возврат 14;
	КонецЕсли; 
	Типы = ОписаниеТипов.Типы();
	Если Типы.Количество() = 1 Тогда
		КорневойТип = ЛксПолучитьКорневойТипКонфигурации(Типы[0]);
		Если Типы[0] = Тип("Число") Тогда 
			ИндексКартинки = 0;
		ИначеЕсли Типы[0] = Тип("Строка") Тогда 
			ИндексКартинки = 1;
		ИначеЕсли Типы[0] = Тип("Дата") Тогда 
			ИндексКартинки = 2;
		ИначеЕсли Типы[0] = Тип("Булево") Тогда 
			ИндексКартинки = 3;
		ИначеЕсли КорневойТип = "Справочник" Тогда 
			ИндексКартинки = 7;
		ИначеЕсли КорневойТип = "Документ" Тогда 
			ИндексКартинки = 8;
		ИначеЕсли КорневойТип = "Перечисление" Тогда 
			ИндексКартинки = 9;
		ИначеЕсли КорневойТип = "ПланВидовХарактеристик" Тогда 
			ИндексКартинки = 10;
		ИначеЕсли КорневойТип = "ПланСчетов" Тогда 
			ИндексКартинки = 11;
		ИначеЕсли КорневойТип = "ПланВидовРасчета" Тогда 
			ИндексКартинки = 12;
		ИначеЕсли КорневойТип = "БизнесПроцесс" Тогда 
			ИндексКартинки = 13;
		ИначеЕсли КорневойТип = "ТочкаМаршрута" Тогда 
			ИндексКартинки = 14;
		ИначеЕсли КорневойТип = "Задача" Тогда 
			ИндексКартинки = 15;
		Иначе
			ИндексКартинки = 16;
		КонецЕсли;
	Иначе
		ИндексКартинки = 16;
	КонецЕсли;

	Возврат ИндексКартинки;

КонецФункции

// Получает строку для установки порядка компоновки.
//
// Параметры:
//  ПорядокКомпоновки – ПорядокКомпоновкиДанных.
//
// Возвращаемое значение:
//  Строка - для установки порядка.
//
Функция ПолучитьВыражениеПорядкаКомпоновкиНаЯзыкеЛкс(ПорядокКомпоновки, ИсключаемоеПоле = "", СимволЗаменыТочки = Неопределено, ДиалектSQL = "1C") Экспорт

	Строка = "";
	Если СтрокиРавныЛкс(ДиалектSQL, "1С") Тогда
		СтрокаВозр = "Возр";
		СтрокаУбыв = "Убыв";
	Иначе
		СтрокаВозр = "Asc";
		СтрокаУбыв = "Desc";
	КонецЕсли; 
	Для Каждого ЭлементПорядка Из ПорядокКомпоновки.Элементы Цикл
		Если Ложь
			Или Не ЭлементПорядка.Использование
			Или ТипЗнч(ЭлементПорядка) = Тип("АвтоЭлементПорядкаКомпоновкиДанных")
			Или ИсключаемоеПоле = "" + ЭлементПорядка.Поле
		Тогда
			Продолжить;
		КонецЕсли;
		ИмяПоля = "" + ЭлементПорядка.Поле;
		Если СимволЗаменыТочки <> Неопределено Тогда
			ИмяПоля = СтрЗаменить(ИмяПоля, ".", СимволЗаменыТочки);
		КонецЕсли; 
		Строка = Строка + ", " + ИмяПоля + " ";
		Если ЭлементПорядка.ТипУпорядочивания = НаправлениеСортировкиКомпоновкиДанных.Возр Тогда
			Строка = Строка + СтрокаВозр;
		Иначе
			Строка = Строка + СтрокаУбыв;
		КонецЕсли;
	КонецЦикла;
	Возврат Сред(Строка, 3);

КонецФункции // ЛксПолучитьСтрокуПорядкаКомпоновки()

Функция ПолучитьПреставлениеСочетанияКлавишЛкс(СочетаниеКлавиш) Экспорт
	
	Представление = "";
	Если СочетаниеКлавиш.Alt Тогда
		Представление = Представление + "Alt+";
	ИначеЕсли СочетаниеКлавиш.Ctrl Тогда
		Представление = Представление + "Ctrl+";
	ИначеЕсли СочетаниеКлавиш.Shift Тогда
		Представление = Представление + "Shift+";
	КонецЕсли; 
	Представление = Представление + СочетаниеКлавиш.Клавиша;
	Возврат Представление;
	
КонецФункции


////////////////////////////////
// ФОРМЫ

Функция ПолучитьДопСвойстваФормыЛкс(ЭтаФорма)
	
	СвойстваФормы = ЭтаФорма.Панель.Страницы[0].Значение;
	Если СвойстваФормы = Неопределено Тогда
		СвойстваФормы = Новый Структура();
		ЭтаФорма.Панель.Страницы[0].Значение = СвойстваФормы;
	КонецЕсли;
	Возврат СвойстваФормы;
	
КонецФункции

Процедура ВстроитьКнопкиСтруктурыКоманднойПанелиЛкс(ЭтаФорма) Экспорт
	
	мСвойстваФормы = ПолучитьДопСвойстваФормыЛкс(ЭтаФорма);
	КнопкиВсехДействийКомандныхПанелей = Новый Соответствие;
	ИмяКнопки = "СтруктураКоманднойПанели";
	Для Каждого ЭлементФормы Из ЭтаФорма.ЭлементыФормы Цикл
		КоманднаяПанель = Неопределено;
		Если ТипЗнч(ЭлементФормы) = Тип("КоманднаяПанель") Тогда
			КоманднаяПанель = ЭлементФормы;
		Иначе
			Попытка
				//КоманднаяПанель = ЭлементФормы.КонтекстноеМеню; // В контекстных меню функция будет маловостребована, т.к. они имеют обычно более простую структуру и там сразу виден текст всех кнопок
			Исключение
			КонецПопытки; 
		КонецЕсли; 
		Если Истина
			И КоманднаяПанель <> Неопределено 
			И КоманднаяПанель.Кнопки.Найти(ИмяКнопки) = Неопределено
		Тогда
			КоличествоКнопок = 0;
			Для Каждого Кнопка Из КоманднаяПанель.Кнопки Цикл
				Если Кнопка.ТипКнопки <> ТипКнопкиКоманднойПанели.Разделитель Тогда
					КоличествоКнопок = КоличествоКнопок + 1;
				КонецЕсли; 
			КонецЦикла;
			Если КоличествоКнопок > 2 Тогда
				КнопкаСтруктураКоманднойПанели = КоманднаяПанель.Кнопки.Вставить(0);
				КнопкаСтруктураКоманднойПанели.Имя = ИмяКнопки;
				КнопкаСтруктураКоманднойПанели.ТипКнопки = ТипКнопкиКоманднойПанели.Действие;
				КнопкаСтруктураКоманднойПанели.Картинка = БиблиотекаКартинок.ирКоманднаяПанель;
				КнопкаСтруктураКоманднойПанели.Отображение = ОтображениеКнопкиКоманднойПанели.Авто;
				КнопкаСтруктураКоманднойПанели.Текст = "Структура командной панели";
				КнопкаСтруктураКоманднойПанели.Подсказка = "Открыть структуру командной панели";
				КнопкаСтруктураКоманднойПанели.Действие = Новый Действие("СтруктураКоманднойПанелиНажатие");
				КнопкиВсехДействийКомандныхПанелей.Вставить(КнопкаСтруктураКоманднойПанели, КоманднаяПанель);
			КонецЕсли; 
		КонецЕсли; 
	КонецЦикла;
	мСвойстваФормы.Вставить("КнопкиВсехДействийКомандныхПанелей", КнопкиВсехДействийКомандныхПанелей);
	
КонецПроцедуры

Процедура ОткрытьСтруктуруКоманднойПанелиЛкс(ЭтаФорма, Знач Кнопка = Неопределено) Экспорт
	
	мСвойстваФормы = ПолучитьДопСвойстваФормыЛкс(ЭтаФорма);
	КоманднаяПанель = мСвойстваФормы.КнопкиВсехДействийКомандныхПанелей[Кнопка];
	Если Кнопка <> Неопределено Тогда
		Если КоманднаяПанель.Кнопки.Индекс(Кнопка) = -1 Тогда
			// Для контекстных меню
			КоманднаяПанель = КоманднаяПанель.Кнопки[0];
		КонецЕсли; 
	КонецЕсли; 
	ФормаСтруктуры = ирНеглобальный.ПолучитьФормуЛкс("Обработка.ирПлатформа.Форма.СтруктураКоманднойПанели");
	ФормаСтруктуры.КоманднаяПанель = КоманднаяПанель;
	ФормаСтруктуры.ОткрытьМодально();
	
КонецПроцедуры

#КонецЕсли

Процедура ОбновитьКопиюСвойстваВНижнемРегистреЛкс(Объект, ИмяСвойства = "Имя") Экспорт
	
	Объект["Н" + ИмяСвойства] = НРег(Объект[ИмяСвойства]);

КонецПроцедуры

Функция ПолучитьСхемуКолонокМакетаКомпоновкиДанныхЛкс(МакетКомпоновки) Экспорт
	
	#Если _ Тогда
	    МакетКомпоновки = Новый МакетКомпоновкиДанных;
	#КонецЕсли
	СхемаКолонок = Новый Структура;
	
	// Схема колонок строится негарантировано, т.к. платформа не предоставляет нужных данных
	ОписанияМакетовОбластей = МакетКомпоновки.Макеты;
	Если ОписанияМакетовОбластей.Количество() > 0 Тогда
		ЯчейкиЗаголовка = ОписанияМакетовОбластей[0].Макет.Ячейки;
		Если ЯчейкиЗаголовка <> Неопределено Тогда
			КоличествоЯчеекЗаголовка = ЯчейкиЗаголовка.Количество();
			Для Индекс = 0 По КоличествоЯчеекЗаголовка - 1 Цикл
				Для Каждого ОписаниеМакетаОбласти Из ОписанияМакетовОбластей Цикл
					// Здесь подсказка криво работает из-за кривого синтакс-помощника 8.2.13.205
					// http://partners.v8.1c.ru/forum/thread.jsp?id=898023#898023
					ЯчейкаМакетаОбласти = ОписаниеМакетаОбласти.Макет.Ячейки[Индекс];
					Если ТипЗнч(ЯчейкаМакетаОбласти) <> Тип("ЯчейкаМакетаКоллекцииЗначенийОбластиКомпоновкиДанных") Тогда
						Продолжить;
					КонецЕсли;
					ПараметрЯчейки = ЯчейкаМакетаОбласти.Значение;
					Если ПараметрЯчейки = Неопределено Тогда
						Продолжить;
					КонецЕсли;
					Выражение = ОписаниеМакетаОбласти.Параметры["" + ПараметрЯчейки].Выражение;
					ПозицияТочки = Найти(Выражение, ".");
					Если Ложь
						Или ПозицияТочки = 0
						Или Найти(Выражение, " ") > 0
						Или Найти(Выражение, "(") > 0
					Тогда
						//ИмяПоля = "";
						Продолжить;
					Иначе
						ИмяПоля = Сред(Выражение, ПозицияТочки + 1);
					КонецЕсли;
					СхемаКолонок.Вставить(ЯчейкиЗаголовка[Индекс].Имя, ИмяПоля);
					Прервать;
				КонецЦикла;
			КонецЦикла;
		КонецЕсли;
	КонецЕсли;
	Возврат СхемаКолонок;

КонецФункции

Функция ПолучитьТекущуюДатуЛкс(НаСервере = Ложь) Экспорт
	
	Если НаСервере Тогда
		Результат = ирСервер.ПолучитьТекущуюДатуЛкс();
	Иначе
		Результат = ТекущаяДата();
	КонецЕсли; 
	Возврат Результат;
	
КонецФункции

Функция СтрокиРавныЛкс(Знач Строка1, Знач Строка2, СУчетомРегистра = Ложь, БезПравыхНепечатныхСимволов = Ложь) Экспорт
	
	Если Не СУчетомРегистра Тогда
		Строка1 = НРег(Строка1);
		Строка2 = НРег(Строка2);
	КонецЕсли; 
	Если БезПравыхНепечатныхСимволов Тогда
		Строка1 = СокрП(Строка1);
		Строка2 = СокрП(Строка2);
	КонецЕсли; 
	Результат = Строка1 = Строка2;
	Возврат Результат;
	
КонецФункции

// Поиск числа в строке
//
// Параметры:
//  ИсходнаяСтрока - Строка, строка в которой ищется число
//  ПозицияЧисла - Число, позиция начала числа
//  КоличествоСимволов - Число, количество символов числа
//
// Возвращаемое значение:
//  Булево - Истина, число найдено
//
Функция НайтиЧислоВСтрокеЛкс(ИсходнаяСтрока, ПозицияЧисла, КоличествоСимволов) Экспорт
	
	ПозицияЧисла = 0;
	КоличествоСимволов = 0;
	ДлинаСтроки = СтрДлина(ИсходнаяСтрока);
	Для Сч = 1 По ДлинаСтроки Цикл
		ТекущийСимвол = КодСимвола(Сред(ИсходнаяСтрока, Сч, 1));
		Если 48 <= ТекущийСимвол И ТекущийСимвол <= 57 Тогда
			Если ПозицияЧисла = 0 Тогда
				ПозицияЧисла = Сч;
				КоличествоСимволов = 1;
			Иначе
				КоличествоСимволов = КоличествоСимволов + 1;
			КонецЕсли;
		Иначе
			Если ПозицияЧисла <> 0 Тогда
				Прервать;
			КонецЕсли;
		КонецЕсли;
	КонецЦикла;
	Возврат ПозицияЧисла > 0;
	
КонецФункции // НайтиЧислоВСтроке()

Процедура ОчиститьКаталогЖурналаЛкс(КаталогЖурнала, НаСервере = Ложь, ВыводитьПредупрежденияИСообщения = Истина) Экспорт

	#Если Клиент Тогда
		Если ВыводитьПредупрежденияИСообщения Тогда
			Ответ = КодВозвратаДиалога.ОК;
			Если НаСервере Тогда
				ОбщийРазмер = ирСервер.ВычислитьРазмерКаталогаЛкс(КаталогЖурнала);
			Иначе
				ОбщийРазмер = ВычислитьРазмерКаталогаЛкс(КаталогЖурнала);
			КонецЕсли; 
			Если ОбщийРазмер > 0 Тогда
				Ответ = Вопрос("Действительно удалить рекурсивно все файлы (" + Формат(Цел(ОбщийРазмер/1000000), "ЧН=") + "МБ) в каталоге журнала?", РежимДиалогаВопрос.ОКОтмена);
			КонецЕсли; 
			Если Ответ <> КодВозвратаДиалога.ОК Тогда
				Возврат;
			КонецЕсли; 
		КонецЕсли; 
		Если НаСервере Тогда
			ирСервер.ОчиститьКаталогЖурналаЛкс(КаталогЖурнала, ВыводитьПредупрежденияИСообщения);
			Возврат;
		КонецЕсли; 
	#КонецЕсли 
	ФайлыЖурнала = НайтиФайлы(КаталогЖурнала, "*.*", Истина);
	Если ФайлыЖурнала.Количество() > 0 Тогда
		СчетчикНеудаленных = 0;
		Для Каждого ФайлЖурнала Из ФайлыЖурнала Цикл
			Попытка
				УдалитьФайлы(ФайлЖурнала.ПолноеИмя);
			Исключение
				СчетчикНеудаленных = СчетчикНеудаленных + 1;
			КонецПопытки; 
		КонецЦикла;
		Если ВыводитьПредупрежденияИСообщения Тогда
			Если СчетчикНеудаленных > 0 Тогда
				Сообщить("" + СчетчикНеудаленных + " файлов техножурнала удалить не удалось");
			КонецЕсли; 
		КонецЕсли; 
	КонецЕсли; 
	
КонецПроцедуры // ОчиститьКаталогЖурналаЛкс()

Функция ВычислитьРазмерКаталогаЛкс(Каталог, ВключаяПодкаталоги = Истина) Экспорт
	
	Файлы = НайтиФайлы(Каталог, "*.*", ВключаяПодкаталоги);
	ОбщийРазмер = 0;
	Для Каждого Файл Из Файлы Цикл
		Если Файл.ЭтоКаталог() Тогда
			Продолжить;
		КонецЕсли; 
		ОбщийРазмер = ОбщийРазмер + Файл.Размер();
	КонецЦикла;
	Возврат ОбщийРазмер;

КонецФункции

Процедура УстановитьПометкиРодителейЛкс(Знач ТекСтрока, Знач ИмяДанныхФлажка = "Пометка") Экспорт
	
	Родитель = ТекСтрока.Родитель;
	Если Родитель = Неопределено Тогда
		Возврат;
	КонецЕсли; 

	ТекСостояние       = Родитель[ИмяДанныхФлажка];
	НайденыВключенные  = Ложь;
	НайденыВыключенные = Ложь;
	Для каждого Строка из Родитель.Строки Цикл
		ЗначениеФлажка = Строка[ИмяДанныхФлажка];
        Если ЗначениеФлажка = 0 Тогда
			НайденыВыключенные = Истина;
		ИначеЕсли ЗначениеФлажка = 1 Тогда
			НайденыВключенные  = Истина;
		ИначеЕсли ЗначениеФлажка = 2 Тогда
			НайденыВключенные  = Истина;
			НайденыВыключенные = Истина;
			Прервать;
		КонецЕсли; 
		Если НайденыВключенные И НайденыВыключенные Тогда
			Прервать;
		КонецЕсли; 
	КонецЦикла;
	Если НайденыВключенные И НайденыВыключенные Тогда
		Включить = 2;
	ИначеЕсли НайденыВключенные И (Не НайденыВыключенные) Тогда
		Включить = 1;
	ИначеЕсли (Не НайденыВключенные) И НайденыВыключенные Тогда
		Включить = 0;
	ИначеЕсли (Не НайденыВключенные) И (Не НайденыВыключенные) Тогда
		Включить = 2;
	КонецЕсли;
	Если Включить = ТекСостояние Тогда
		Возврат;
	Иначе
		Родитель[ИмяДанныхФлажка] = Включить;
		УстановитьПометкиРодителейЛкс(Родитель, ИмяДанныхФлажка);
	КонецЕсли; 

КонецПроцедуры

Процедура УстановитьПометкиПодчиненныхЛкс(Знач ТекСтрока, Знач ИмяДанныхФлажка = "Пометка") Экспорт
	
	ТекСостояние = ТекСтрока[ИмяДанныхФлажка];
	Подчиненные  = ТекСтрока.Строки;

	Если ТекСостояние = 2 Тогда
		ТекСтрока[ИмяДанныхФлажка] = 0;
	КонецЕсли;
	Если Подчиненные.Количество() > 0 Тогда
		Для каждого Строка из Подчиненные Цикл
			Строка[ИмяДанныхФлажка] = ТекСостояние;
			УстановитьПометкиПодчиненныхЛкс(Строка, ИмяДанныхФлажка);
		КонецЦикла;
	КонецЕсли;
	
КонецПроцедуры

// Разбирает строку на две части: до подстроки разделителя и после
//
// Параметры:
//  Стр            - разбираемая строка
//  Разделитель    - подстрока-разделитель
//  Режим          - 0 - разделитель в возвращаемые подстроки не включается
//                   1 - разделитель включается в левую подстроку
//                   2 - разделитель включается в правую подстроку
//
// Возвращаемое значение:
//  Правая часть строки - до символа-разделителя
// 
Функция ОтделитьРазделителемЛкс(Стр, Знач Разделитель = ".", Режим = 0) Экспорт

	ПраваяЧасть = "";
	ПозРазделителя = Найти(Стр, Разделитель);
	ДлинаРазделителя = СтрДлина(Разделитель);
	Если ПозРазделителя > 0 Тогда
		ПраваяЧасть = Сред(Стр, ПозРазделителя + ?(Режим=2, 0, ДлинаРазделителя));
		Стр = СокрЛП(Лев(Стр, ПозРазделителя - ?(Режим=1, -ДлинаРазделителя+1, 1)));
	КонецЕсли;

	Возврат(ПраваяЧасть);
	
КонецФункции // вОтделитьРазделителем()

// Проверяет попадание даты внутрь интервала всключая границы
Функция ЛиДатаВИнтервалеСГраницамиЛкс(ПроверяемаяДата, НачалоПериода, КонецПериода) Экспорт

	ЛиДатаВНеИнтервале = Ложь
		Или (Истина
			И ЗначениеЗаполнено(НачалоПериода)
			И ПроверяемаяДата < НачалоПериода)
		Или (Истина
			И ЗначениеЗаполнено(КонецПериода)
			И ПроверяемаяДата > КонецПериода);
	Возврат Не ЛиДатаВНеИнтервале;

КонецФункции

// Проверяет попадание даты внутрь интервала исключая границы
Функция ЛиДатаВИнтервалеБезГраницЛкс(ПроверяемаяДата, НачалоПериода, КонецПериода) Экспорт

	ПустаяДата = Дата("00010101");
	ЛиДатаВНеИнтервале = Ложь
		Или (Истина
			И НачалоПериода <> ПустаяДата
			И ПроверяемаяДата <= НачалоПериода)
		Или (Истина
			И КонецПериода <> ПустаяДата
			И ПроверяемаяДата >= КонецПериода);
	Возврат Не ЛиДатаВНеИнтервале;

КонецФункции

Функция ЛиКаталогДоступенЛкс(Каталог, ВыводитьСообщения = Истина) Экспорт 

	ПроверочныйФайл = Новый Файл(Каталог);
	Попытка
		ЭтоКаталог = ПроверочныйФайл.ЭтоКаталог();
	Исключение
		Если ВыводитьСообщения Тогда
			Сообщить("Указанный путь """ + Каталог + """ не доступен: " + ОписаниеОшибки());
		КонецЕсли; 
		Возврат Ложь;
	КонецПопытки; 
	Если Не ЭтоКаталог Тогда
		Если ВыводитьСообщения Тогда
			Сообщить("Указанный путь """ + Каталог + """ не является каталогом");
		КонецЕсли; 
		Возврат Ложь;
	КонецЕсли; 
	Возврат Истина;

КонецФункции // ЛиКаталогДоступен()

Функция ПолучитьСтрокуФильтраДляВыбораФайлаЛкс(Расширение, ОписаниеФормата = "", РазрешитьВсеФайлы = Истина) Экспорт
	
	Результат = "(*." + Расширение + ")|*." + Расширение;
	Если ЗначениеЗаполнено(ОписаниеФормата) Тогда
		Результат = ОписаниеФормата + " " + Результат;
	КонецЕсли;
	Если РазрешитьВсеФайлы Тогда
		Результат = Результат + "|Все файлы (*.*)|*.*";
	КонецЕсли; 
	Возврат Результат;
	
КонецФункции

#Если Клиент Тогда
	
Процедура ОткрытьФайлСПредупреждениемЛкс(ИмяФайла, СтандартнаяОбработка = Неопределено) Экспорт
	
	СтандартнаяОбработка = Ложь;
	Ответ = Вопрос("Вы уверены, что хотите открыть """ + ИмяФайла + """?", РежимДиалогаВопрос.ОКОтмена);
	Если Ответ = КодВозвратаДиалога.ОК Тогда
		ЗапуститьПриложение(ИмяФайла);
	КонецЕсли;

КонецПроцедуры

#КонецЕсли