БЛАНКСШАБЛОНОМ "Отчет по ОКОФ";
-- Разработка бланка: ТБ.БЮДЖЕТ
-- Первый релиз: 10.12.2012
-- Константы
var MaskUserVoc  :String="ВД.*|ВКЛ.*|КТ.*|П.*|ПБС.*|ПГР.*|РБС.*";
var btnName_menu :String='Ведомость остатков ОС по ОКОФ';
var Sort_menu	 :String='10';
var infoVersion  :String="Версия отчета: 1.12.1227";
var crdГРП	 :String="РПО_ОКЕИ_ГРУППЫ";
var pfxУЧН	 :String="УЧН";
var Фокус	 :String="";
var Кнопка1	 :String="ОКОФ по источникам";
var Кнопка2	 :String="ОКОФ итого по коду";
var Кнопка3	 :String="ОКОФ по-объектно";
var Кнопка4	 :String="Итоги по счетам";
currКнопка	 :Integer=[2];
-- Объекты
btnClose  :Object; rbtAccВсе:Object;  rbtФинВсе :Object; cb_НстрВнВидОтч :Object; Bevel1 :Object;
btnРасчет :Object; rbtAccБал:Object;  rbtФинБдж :Object; cb_СкрытьПарОтч :Object; Bevel2 :Object;
btnExcel  :Object; rbtAccЗаб:Object;  rbtФинДхд :Object; lblVersion	 :Object;
--
СекцТ1З :Object; СекцТ1Д :Object; СекцТ1И :Object;
СекцТ2З :Object; СекцТ2Д :Object; СекцТ2И :Object;
СекцТ3З :Object; СекцТ3Д :Object; СекцТ3И :Object;
СекцТ4З :Object; СекцТ4Д :Object; СекцТ4И :Object;
СекцТ5З :Object; СекцТ5Д :Object; СекцТ5И :Object;

СекцТитул1 :Object;
СекцТитул2 :Object;
СекцТитул3 :Object;
Секц_ВнВид :Object;
СекцДопСпр :Object;
Секц_Услов :Object;
Секц_ЦенБМ :Object;
Секц_Одата :Object;
Секц_Кнопк :Object;

СекцArrayНФА :Object;

СекцWorkЗТ :Object; -- Основная таблица (ведомость) - строка заголовков
СекцWorkДТ :Object; -- Основная таблица (ведомость) - строки данных
СекцWorkИТ :Object; -- Основная таблица (ведомость) - строка итогов

Позиции 	 :Integer;  -- строки ведомости
ПозицииArrayНФА  :Integer;  -- строки вспомогательного массива

СтрокиТ1	 :Integer;  -- строки итоговых таблиц
СтрокиТ2	 :Integer;  -- строки итоговых таблиц
СтрокиТ3	 :Integer;  -- строки итоговых таблиц
СтрокиТ4	 :Integer;  -- строки итоговых таблиц

TimeCreationRep  :String;
СлужИнфоСЧТ	 :String;
СлужИнфоАНА	 :String;
СлужИнфоГРП	 :String;
var flgФиксТабл  :Logical=[False];
var flgФиксТабл_ :Logical=flgФиксТабл;

var Flag_onEnter :Logical;
flgClear	 :String;   -- контроль очистки бланков

VOCКОД	    :String;	      -- Дополнительный справочник
VOCИМЯ	    :String;
var VOCКОД_ :String=VOCКОД;

отчСЧТ	    :String;	      -- Фильтр по счету
отчКБК	    :String;	      -- Фильтр по КБК
valКБК	    :String;	      -- Фильтр по КБК (полное значение - для возвратов в меню)
отчМОЛ	    :String;	      -- Фильтр по МОЛ
nmsМОЛ	    :String;	      -- Ф.И.О. МОЛ
отчМХЭ	    :String;	      -- Фильтр по местонахождению
nmsМХЭ	    :String;	      -- Наименование местонахождения
keyГРП	    :String;	      -- Фильтр по группам НФА (ссылка на значение)
отчГРП	    :String;	      -- Фильтр по группам НФА (код аналитики)
nmsГРП	    :String;	      -- Наименование групп НФА
отчДОП	    :String;	      -- Фильтр по дополнителньому справочнику
nmsДОП	    :String;	      -- Наименование признака из дополнительного справочника
отчНФА	    :String;	      -- Фильтр по справочнику НФА
nmsНФА	    :String;	      -- Наименование признака НФА
--
ОтчАНА		 :String;     -- Фильтр по дополнительной аналитике
var OldОтчАНА	 :String;     -- Для запоминания и возвратов (дополнительная аналитика)
var LastGRP_num  :Integer;
var LastGRP_key  :String=["{0}"];
var OldЦена	 :Integer;    -- Для запоминания и возвратов

useЦеныЕЦ	 :Logical=[False];
var useЦеныЕЦ_	 :Logical=useЦеныЕЦ;
flgSgnЕЦ	 :Integer;
var flgSgnЕЦ_	 :Integer=flgSgnЕЦ;
БМЦеныЕЦ	 :Integer;

var отчСЧТ_ :String=отчСЧТ;
var отчКБК_ :String=отчКБК;
var отчМОЛ_ :String=отчМОЛ;
var отчМХЭ_ :String=отчМХЭ;
var отчГРП_ :String=отчГРП;
var отчДОП_ :String=отчДОП;
var отчНФА_ :String=отчНФА;

ДатОпер 	 :Date;2 0    -- дата отчета
var ДатОпер_	 :Date=ДатОпер;
var oldDate	 :Date;     -- для запоминания и возвратов
ДатИсп		 :Date;
УЧР_ИМЯ 	 :String;
УЧР_ОКПО	 :String;
УЧР_REC 	 :Record;
ПОД_ИМЯ 	 :String;
ПОД_КОД 	 :String;
ИспДол		 :String;
ИспФИО		 :String;
ИспREC		 :Record;

var flgСкрытьПарОтч  :Logical;
var flgНстрВнВидОтч  :Logical;

flgПечНовСтр	 :Logical=[False];

flgПечСлужИнф	 :Logical=[True];
flgСлужИнф	 :Logical=[True];
intСхемаЦветов	 :Integer=[1];

flgТолькоИнв	 :Logical=[False];
flgЧиститьАна	 :Logical=[True];

intРежимСохр	 :Integer;
intРежимСохр_	 :Integer=intРежимСохр;

flgСложнДаты	 :Logical=[False];
flgВдБезОКОФ	 :Logical=[True];
var flgВдБезОКОФ_:Logical=flgВдБезОКОФ;
flgНмГрпОКОФ	 :Logical=[False];
var flgНмГрпОКОФ_:Logical=flgНмГрпОКОФ;

currИст 	 :Integer=[1];
var oldsИст	 :Integer;
currAcc 	 :Integer=[1];
var oldsAcc	 :Integer;

var arr_REFНФА[] :String;
var arr_КОДНФА[] :String;

var LST_UNIQUE[] :String;
var LST_OSTСУМ[] :Numeric;
var LST_OSTКОЛ[] :Numeric;
var LST_КОДМХЭ[] :String;  -- код местонахождения
var LST_КОДИСТ[] :String;  -- источник (код)
var LST_КОДКБК[] :String;  -- КБК (код)
var LST_КОДСЧ6[] :String;  -- счет вида ???.?? (код)
var LST_ИМЯНФА[] :String;  -- наименование НФА
var LST_ИМЯИНВ[] :String;  -- инвентарный номер (расшифровка УЧН)
var LST_НЕТУЧН[] :Logical; -- без инвентарного номера

-- Основная ведомость
тSRTFLD[]    :String;	-- сортировочное поле
тНФАОКФ[]    :String;	-- группа ОКОФ ОС
тОКФНМН[]    :String;	-- наименование ОКОФ
тНФАКОД[]    :String;	-- НФА (код)
тНФАИМЯ[]    :String;	-- НФА (наименование)
тНФАЕДИ[]    :String;	-- НФА (единица измерения)
тНФАУЧН[]    :String;	-- учетный номер
тНФАИНВ[]    :String;	-- инвентарный номер
тНФАИСТ[]    :String;	-- вид финансового обеспечения (источник финансирования)
тНФАКБК[]    :String;	-- КБК
тНФАСЧ6[]    :String;	-- синтетический счет
тДАТПРН[]    :Date;	-- дата принятия ОС к учету
тДАТЭКС[]    :Date;	-- дата ввода ОС в эксплуатацию
тСРКПЛЗ[]    :String;	-- норма эксплуатации
тСРКФКТ[]    :String;	-- фактически эксплуатировалось
тКОЛНФА[]    :Numeric;	-- количество
тСУМБАЛ[]    :Numeric;	-- сумма балансовая
тСУМАМТ[]    :Numeric;	-- сумма амортизации
тСУМОСТ[]    :Numeric;	-- сумма остаточная

флагиACC	 :String;  -- для фильтра по счетам
Иерархия	 :String;  -- строка формирования порядка полей иерархической группировки

count_arrНФА	 :Integer;

-- Массивы
var NN[]	 :Integer=$;
var Buf[]	 :String;
var Txt[]	 :String;
var aAna[]	 :String;
var BufInt[]	 :Integer;
var BufMsk[]	 :String;
var BufStr[]	 :String;
var KeyMsk[]	 :String;
var KeyStr[]	 :String;
var BufFlag[]	 :Logical;
var иррхГРП[]	 :String;  -- группы для возможного создания иерархии отчета
var иррхUSE[]	 :Logical; -- вид отчета группы для возможного создания иерархии отчета (False - без вывода; True - иерархично)
var bindVOC[]	 :String;  -- Привязанный справочник
var bindINT[]	 :Integer; -- Количество привязок

GRPBUF[]	 :String; -- Группы НФА (для вывода)
GRPDAT[]	 :String; -- Группы НФА (данные)
GRPKEY[]	 :String; -- Группы НФА (системная инфа)

итгСУМКОЛвед :Numeric=SumOfArray(тКОЛНФА, Позиции);
итгСУМБАЛвед :Numeric=SumOfArray(тСУМБАЛ, Позиции);
итгСУМАМТвед :Numeric=SumOfArray(тСУМАМТ, Позиции);
итгСУМОСТвед :Numeric=SumOfArray(тСУМОСТ, Позиции);

-- ИТОГОВЫЕ ТАБЛИЦЫ
-- ### таблица 1 ###
иСЧТСкод[]   :String;
иСЧТСбалБ[]  :Numeric;	   вСЧТСбалБ  :Numeric;
иСЧТСамтБ[]  :Numeric;	   вСЧТСамтБ  :Numeric;
иСЧТСостБ[]  :Numeric;	   вСЧТСостБ  :Numeric;
иСЧТСбалВ[]  :Numeric;	   вСЧТСбалВ  :Numeric;
иСЧТСамтВ[]  :Numeric;	   вСЧТСамтВ  :Numeric;
иСЧТСостВ[]  :Numeric;	   вСЧТСостВ  :Numeric;
иСЧТСбалИ[]  :Numeric;	   вСЧТСбалИ  :Numeric;
иСЧТСамтИ[]  :Numeric;	   вСЧТСамтИ  :Numeric;
иСЧТСостИ[]  :Numeric;	   вСЧТСостИ  :Numeric;
иСЧТСзаб[]   :Numeric;	   вСЧТСзаб   :Numeric;
иСЧТСвсг[]   :Numeric;	   вСЧТСвсг   :Numeric;
-- ### таблица 2 ###
иСЧТБкод[]   :String;
иСЧТБбалБ[]  :Numeric;	   вСЧТБбалБ  :Numeric;
иСЧТБамтБ[]  :Numeric;	   вСЧТБамтБ  :Numeric;
иСЧТБостБ[]  :Numeric;	   вСЧТБостБ  :Numeric;
иСЧТБбалВ[]  :Numeric;	   вСЧТБбалВ  :Numeric;
иСЧТБамтВ[]  :Numeric;	   вСЧТБамтВ  :Numeric;
иСЧТБостВ[]  :Numeric;	   вСЧТБостВ  :Numeric;
иСЧТБбалИ[]  :Numeric;	   вСЧТБбалИ  :Numeric;
иСЧТБамтИ[]  :Numeric;	   вСЧТБамтИ  :Numeric;
иСЧТБостИ[]  :Numeric;	   вСЧТБостИ  :Numeric;
-- ### таблица 3 ###
иФКРБкод[]   :String;
иСЧТФбалБ[]  :Numeric;	   вСЧТФбалБ  :Numeric;
иСЧТФамтБ[]  :Numeric;	   вСЧТФамтБ  :Numeric;
иСЧТФостБ[]  :Numeric;	   вСЧТФостБ  :Numeric;
иСЧТФбалВ[]  :Numeric;	   вСЧТФбалВ  :Numeric;
иСЧТФамтВ[]  :Numeric;	   вСЧТФамтВ  :Numeric;
иСЧТФостВ[]  :Numeric;	   вСЧТФостВ  :Numeric;
иСЧТФбалИ[]  :Numeric;	   вСЧТФбалИ  :Numeric;
иСЧТФамтИ[]  :Numeric;	   вСЧТФамтИ  :Numeric;
иСЧТФостИ[]  :Numeric;	   вСЧТФостИ  :Numeric;
-- ### таблица 4 ###
иОКОФ_key[]:String;
иОКОФ_грп[]:String;
иОКОФ_элм[]:String;
иОКОФ_нмн[]:String;
иОКОФкол1[]:Numeric;   иОКОФкол2[]:Numeric;   иОКОФкол4[]:Numeric;   иОКОФкол5[]:Numeric;   иОКОФкол7[]:Numeric;   иОКОФколП[]:Numeric;   иОКОФколЗ[]:Numeric;
иОКОФбал1[]:Numeric;   иОКОФбал2[]:Numeric;   иОКОФбал4[]:Numeric;   иОКОФбал5[]:Numeric;   иОКОФбал7[]:Numeric;   иОКОФбалП[]:Numeric;   иОКОФбалЗ[]:Numeric;
иОКОФамт1[]:Numeric;   иОКОФамт2[]:Numeric;   иОКОФамт4[]:Numeric;   иОКОФамт5[]:Numeric;   иОКОФамт7[]:Numeric;   иОКОФамтП[]:Numeric;   иОКОФамтЗ[]:Numeric;
иОКОФост1[]:Numeric;   иОКОФост2[]:Numeric;   иОКОФост4[]:Numeric;   иОКОФост5[]:Numeric;   иОКОФост7[]:Numeric;   иОКОФостП[]:Numeric;   иОКОФостЗ[]:Numeric;
иОКОФколИ[]:Numeric=иОКОФкол1[$]+иОКОФкол2[$]+иОКОФкол4[$]+иОКОФкол5[$]+иОКОФкол7[$]+иОКОФколП[$];   иОКОФколВ[]:Numeric=иОКОФколИ[$]+иОКОФколЗ[$];
иОКОФбалИ[]:Numeric=иОКОФбал1[$]+иОКОФбал2[$]+иОКОФбал4[$]+иОКОФбал5[$]+иОКОФбал7[$]+иОКОФбалП[$];   иОКОФбалВ[]:Numeric=иОКОФбалИ[$]+иОКОФбалЗ[$];
иОКОФамтИ[]:Numeric=иОКОФамт1[$]+иОКОФамт2[$]+иОКОФамт4[$]+иОКОФамт5[$]+иОКОФамт7[$]+иОКОФамтП[$];   иОКОФамтВ[]:Numeric=иОКОФамтИ[$]+иОКОФамтЗ[$];
иОКОФостИ[]:Numeric=иОКОФост1[$]+иОКОФост2[$]+иОКОФост4[$]+иОКОФост5[$]+иОКОФост7[$]+иОКОФостП[$];   иОКОФостВ[]:Numeric=иОКОФостИ[$]+иОКОФостЗ[$];
вОКОФкол1:Numeric;   вОКОФкол2:Numeric;   вОКОФкол4:Numeric;   вОКОФкол5:Numeric;   вОКОФкол7:Numeric;	 вОКОФколП:Numeric;   вОКОФколЗ:Numeric;
вОКОФбал1:Numeric;   вОКОФбал2:Numeric;   вОКОФбал4:Numeric;   вОКОФбал5:Numeric;   вОКОФбал7:Numeric;	 вОКОФбалП:Numeric;   вОКОФбалЗ:Numeric;
вОКОФамт1:Numeric;   вОКОФамт2:Numeric;   вОКОФамт4:Numeric;   вОКОФамт5:Numeric;   вОКОФамт7:Numeric;	 вОКОФамтП:Numeric;   вОКОФамтЗ:Numeric;
вОКОФост1:Numeric;   вОКОФост2:Numeric;   вОКОФост4:Numeric;   вОКОФост5:Numeric;   вОКОФост7:Numeric;	 вОКОФостП:Numeric;   вОКОФостЗ:Numeric;
вОКОФколИ:Numeric=вОКОФкол1+вОКОФкол2+вОКОФкол4+вОКОФкол5+вОКОФкол7+вОКОФколП;	 вОКОФколВ:Numeric=вОКОФколИ+вОКОФколЗ;
вОКОФбалИ:Numeric=вОКОФбал1+вОКОФбал2+вОКОФбал4+вОКОФбал5+вОКОФбал7+вОКОФбалП;	 вОКОФбалВ:Numeric=вОКОФбалИ+вОКОФбалЗ;
вОКОФамтИ:Numeric=вОКОФамт1+вОКОФамт2+вОКОФамт4+вОКОФамт5+вОКОФамт7+вОКОФамтП;	 вОКОФамтВ:Numeric=вОКОФамтИ+вОКОФамтЗ;
вОКОФостИ:Numeric=вОКОФост1+вОКОФост2+вОКОФост4+вОКОФост5+вОКОФост7+вОКОФостП;	 вОКОФостВ:Numeric=вОКОФостИ+вОКОФостЗ;

2-- Общие процедуры и функции
Proc ОчиститьВспомМассив;
 ClearVariable(arr_REFНФА);
 ClearVariable(arr_КОДНФА);
 count_arrНФА=0;
end;

Proc ОчиститьLST;
 ClearVariable(LST_UNIQUE);
 ClearVariable(LST_OSTСУМ);
 ClearVariable(LST_OSTКОЛ);
 ClearVariable(LST_КОДМХЭ);
 ClearVariable(LST_КОДИСТ);
 ClearVariable(LST_КОДКБК);
 ClearVariable(LST_КОДСЧ6);
 ClearVariable(LST_ИМЯНФА);
 ClearVariable(LST_ИМЯИНВ);
 ClearVariable(LST_НЕТУЧН);
end;

Proc Очистить;
 ClearVariable(Buf);
 ClearVariable(Txt);
 ClearVariable(aAna);
 ClearVariable(BufInt);
 ClearVariable(BufMsk);
 ClearVariable(BufStr);
 ClearVariable(KeyMsk);
 ClearVariable(KeyStr);
 ClearVariable(BufFlag);
 --
 ClearVariable(иррхГРП);
 ClearVariable(иррхUSE);
 --
 ClearVariable(bindVOC);
 ClearVariable(bindINT);
 --
 ОчиститьВспомМассив;
 ОчиститьLST;
end;

Proc ОчиститьГРПНФА;
 ClearVariable(GRPBUF); ClearVariable(GRPDAT); ClearVariable(GRPKEY);
end;

Proc ОчиститьТаблицу;
 ClearVariable(Позиции);
 ClearVariable(тSRTFLD);
 ClearVariable(тНФАОКФ);
 ClearVariable(тОКФНМН);
 ClearVariable(тНФАКОД);
 ClearVariable(тНФАИМЯ);
 ClearVariable(тНФАЕДИ);
 ClearVariable(тНФАУЧН);
 ClearVariable(тНФАИНВ);
 ClearVariable(тНФАИСТ);
 ClearVariable(тНФАКБК);
 ClearVariable(тНФАСЧ6);
 ClearVariable(тДАТПРН);
 ClearVariable(тДАТЭКС);
 ClearVariable(тСРКПЛЗ);
 ClearVariable(тСРКФКТ);
 ClearVariable(тКОЛНФА);
 ClearVariable(тСУМБАЛ);
 ClearVariable(тСУМАМТ);
 ClearVariable(тСУМОСТ);
end;

Proc SetFLGСлужИнф;
 if flgПечСлужИнф and (СлужИнфоСЧТ<>"" or СлужИнфоАНА<>"" or СлужИнфоГРП<>"") and not flgНстрВнВидОтч: flgСлужИнф=True; else flgСлужИнф=False; fi;
end;

Proc ОчиститьТаблицуN1;
 ClearVariable(СтрокиТ1);
 ClearVariable(иСЧТСкод);
 ClearVariable(иСЧТСбалБ);	ClearVariable(вСЧТСбалБ);
 ClearVariable(иСЧТСамтБ);	ClearVariable(вСЧТСамтБ);
 ClearVariable(иСЧТСостБ);	ClearVariable(вСЧТСостБ);
 ClearVariable(иСЧТСбалВ);	ClearVariable(вСЧТСбалВ);
 ClearVariable(иСЧТСамтВ);	ClearVariable(вСЧТСамтВ);
 ClearVariable(иСЧТСостВ);	ClearVariable(вСЧТСостВ);
 ClearVariable(иСЧТСбалИ);	ClearVariable(вСЧТСбалИ);
 ClearVariable(иСЧТСамтИ);	ClearVariable(вСЧТСамтИ);
 ClearVariable(иСЧТСостИ);	ClearVariable(вСЧТСостИ);
 ClearVariable(иСЧТСзаб) ;	ClearVariable(вСЧТСзаб) ;
 ClearVariable(иСЧТСвсг) ;	ClearVariable(вСЧТСвсг) ;
end;

Proc ОчиститьТаблицуN2;
 ClearVariable(СтрокиТ2);
 ClearVariable(иСЧТБкод);
 ClearVariable(иСЧТБбалБ);   ClearVariable(вСЧТБбалБ);
 ClearVariable(иСЧТБамтБ);   ClearVariable(вСЧТБамтБ);
 ClearVariable(иСЧТБостБ);   ClearVariable(вСЧТБостБ);
 ClearVariable(иСЧТБбалВ);   ClearVariable(вСЧТБбалВ);
 ClearVariable(иСЧТБамтВ);   ClearVariable(вСЧТБамтВ);
 ClearVariable(иСЧТБостВ);   ClearVariable(вСЧТБостВ);
 ClearVariable(иСЧТБбалИ);   ClearVariable(вСЧТБбалИ);
 ClearVariable(иСЧТБамтИ);   ClearVariable(вСЧТБамтИ);
 ClearVariable(иСЧТБостИ);   ClearVariable(вСЧТБостИ);
end;

Proc ОчиститьТаблицуN3;
 ClearVariable(СтрокиТ3);
 ClearVariable(иФКРБкод);
 ClearVariable(иСЧТФбалБ);   ClearVariable(вСЧТФбалБ);
 ClearVariable(иСЧТФамтБ);   ClearVariable(вСЧТФамтБ);
 ClearVariable(иСЧТФостБ);   ClearVariable(вСЧТФостБ);
 ClearVariable(иСЧТФбалВ);   ClearVariable(вСЧТФбалВ);
 ClearVariable(иСЧТФамтВ);   ClearVariable(вСЧТФамтВ);
 ClearVariable(иСЧТФостВ);   ClearVariable(вСЧТФостВ);
 ClearVariable(иСЧТФбалИ);   ClearVariable(вСЧТФбалИ);
 ClearVariable(иСЧТФамтИ);   ClearVariable(вСЧТФамтИ);
 ClearVariable(иСЧТФостИ);   ClearVariable(вСЧТФостИ);
end;

Proc ОчиститьТаблицуN4;
 ClearVariable(СтрокиТ4);
 ClearVariable(иОКОФ_нмн);   ClearVariable(иОКОФкол1);	 ClearVariable(иОКОФкол2);   ClearVariable(иОКОФкол4);	 ClearVariable(иОКОФкол5);
 ClearVariable(иОКОФ_key);   ClearVariable(иОКОФбал1);	 ClearVariable(иОКОФбал2);   ClearVariable(иОКОФбал4);	 ClearVariable(иОКОФбал5);
 ClearVariable(иОКОФ_грп);   ClearVariable(иОКОФамт1);	 ClearVariable(иОКОФамт2);   ClearVariable(иОКОФамт4);	 ClearVariable(иОКОФамт5);
 ClearVariable(иОКОФ_элм);   ClearVariable(иОКОФост1);	 ClearVariable(иОКОФост2);   ClearVariable(иОКОФост4);	 ClearVariable(иОКОФост5);

 ClearVariable(иОКОФкол7);   ClearVariable(иОКОФколП);	 ClearVariable(иОКОФколИ);   ClearVariable(иОКОФколЗ);	 ClearVariable(иОКОФколВ);
 ClearVariable(иОКОФбал7);   ClearVariable(иОКОФбалП);	 ClearVariable(иОКОФбалИ);   ClearVariable(иОКОФбалЗ);	 ClearVariable(иОКОФбалВ);
 ClearVariable(иОКОФамт7);   ClearVariable(иОКОФамтП);	 ClearVariable(иОКОФамтИ);   ClearVariable(иОКОФамтЗ);	 ClearVariable(иОКОФамтВ);
 ClearVariable(иОКОФост7);   ClearVariable(иОКОФостП);	 ClearVariable(иОКОФостИ);   ClearVariable(иОКОФостЗ);	 ClearVariable(иОКОФостВ);

 ClearVariable(вОКОФкол1);   ClearVariable(вОКОФкол2);	 ClearVariable(вОКОФкол4);   ClearVariable(вОКОФкол5);
 ClearVariable(вОКОФбал1);   ClearVariable(вОКОФбал2);	 ClearVariable(вОКОФбал4);   ClearVariable(вОКОФбал5);
 ClearVariable(вОКОФамт1);   ClearVariable(вОКОФамт2);	 ClearVariable(вОКОФамт4);   ClearVariable(вОКОФамт5);
 ClearVariable(вОКОФост1);   ClearVariable(вОКОФост2);	 ClearVariable(вОКОФост4);   ClearVariable(вОКОФост5);

 ClearVariable(вОКОФкол7);   ClearVariable(вОКОФколП);	 ClearVariable(вОКОФколЗ);
 ClearVariable(вОКОФбал7);   ClearVariable(вОКОФбалП);	 ClearVariable(вОКОФбалЗ);
 ClearVariable(вОКОФамт7);   ClearVariable(вОКОФамтП);	 ClearVariable(вОКОФамтЗ);
 ClearVariable(вОКОФост7);   ClearVariable(вОКОФостП);	 ClearVariable(вОКОФостЗ);

end;

Proc ОчиститьИтоги;
 ОчиститьТаблицуN1;
 ОчиститьТаблицуN2;
 ОчиститьТаблицуN3;
 ОчиститьТаблицуN4;
end;

Proc ValidateВедомостьSection(СкрытьТаблицу:Logical);
var FF :Logical;
 if Позиции>0 and not СкрытьТаблицу: FF=True; else FF=False; fi;
 СекцWorkЗТ.Visible=FF;
 СекцWorkДТ.Visible=FF;
 СекцWorkИТ.Visible=FF;
 СекцТитул1.Visible=FF;
 СекцТитул2.Visible=FF;
 СекцТитул3.Visible=FF;
   btnExcel.Enabled=FF;
end;

Proc ValidateИтогиSection(СкрытьТаблицу:Logical);
var FF :Logical;
 FF=if(СтрокиТ1>0 and not СкрытьТаблицу, True, False);
 СекцТ1З.Visible=FF; СекцТ1Д.Visible=FF; СекцТ1И.Visible=FF;
 FF=if(СтрокиТ2>0 and not СкрытьТаблицу, True, False);
 СекцТ2З.Visible=FF; СекцТ2Д.Visible=FF; СекцТ2И.Visible=FF;
 FF=if(СтрокиТ3>0 and not СкрытьТаблицу, True, False);
 СекцТ3З.Visible=FF; СекцТ3Д.Visible=FF; СекцТ3И.Visible=FF;
 FF=if(СтрокиТ4>0 and not СкрытьТаблицу, True, False);
 СекцТ4З.Visible=FF; СекцТ4Д.Visible=FF; СекцТ4И.Visible=FF;
 СекцТ5З.Visible=FF; СекцТ5Д.Visible=FF; СекцТ5И.Visible=FF;
end;


Proc ВидимостьОтчетныхТаблиц_Меню(TV1:Logical; TV2:Logical; TV3:Logical; TV4:Logical);
var sysTxt, sysShd :Integer;

 sysTxt=РАБ.ЦВЕТА.GetColor("coBtnText");
 sysShd=РАБ.ЦВЕТА.GetColor("coBtnShadow");

 Секц_Кнопк.Cell(3, 3, CellFontColor, if(TV1, sysTxt, sysShd));
 Секц_Кнопк.Cell(3, 5, CellFontColor, if(TV2, sysTxt, sysShd));
 Секц_Кнопк.Cell(3, 7, CellFontColor, if(TV3, sysTxt, sysShd));
 Секц_Кнопк.Cell(3, 9, CellFontColor, if(TV4, sysTxt, sysShd));

end;

Proc ВидимостьОтчетныхТаблиц_Work(TV1:Logical; TV2:Logical; TV3:Logical; TV4:Logical; ЭтоНастройка:Logical);
var F10, F21, F22, F23, F30, F40, EXL :Logical;

 F10=if(Позиции >0 and TV3 and not ЭтоНастройка, True, False);
 F21=if(СтрокиТ1>0 and TV4 and not ЭтоНастройка, True, False);
 F22=if(СтрокиТ1>0 and TV4 and not ЭтоНастройка, True, False);
 F23=if(СтрокиТ1>0 and TV4 and not ЭтоНастройка, True, False);
 F30=if(СтрокиТ4>0 and TV1 and not ЭтоНастройка, True, False);
 F40=if(СтрокиТ4>0 and TV2 and not ЭтоНастройка, True, False);
 EXL=(F10 or F21 or F22 or F23 or F30 or F40);

 Template.Freeze(0, 0);

 Секц_Кнопк.Visible=EXL;

 СекцWorkЗТ.Visible=F10; СекцWorkДТ.Visible=F10; СекцWorkИТ.Visible=F10;
 СекцТитул1.Visible=F10; СекцТитул2.Visible=F10; СекцТитул3.Visible=F10;

 СекцТ1З.Visible=F21;	 СекцТ1Д.Visible=F21;	 СекцТ1И.Visible=F21;
 СекцТ2З.Visible=F22;	 СекцТ2Д.Visible=F22;	 СекцТ2И.Visible=F22;
 СекцТ3З.Visible=F23;	 СекцТ3Д.Visible=F23;	 СекцТ3И.Visible=F23;

 СекцТ4З.Visible=F30;	 СекцТ4Д.Visible=F30;	 СекцТ4И.Visible=F30;

 СекцТ5З.Visible=F40;	 СекцТ5Д.Visible=F40;	 СекцТ5И.Visible=F40;

 btnExcel.Enabled=EXL;

 ВидимостьОтчетныхТаблиц_Меню(F30, F40, F10, (F21 or F22 or F23));

end;

--Proc ValidateОтчетSection;
-- ValidateВедомостьSection(False);
-- ValidateИтогиSection(False);
--end;

Proc ValidateОтчетSectionInit(fINI:Logical);
 if not (currКнопка>0 and currКнопка<5): currКнопка=2; fi;
 if currКнопка=1: ВидимостьОтчетныхТаблиц_Work(True , False, False, False, fINI);
 |  currКнопка=2: ВидимостьОтчетныхТаблиц_Work(False, True , False, False, fINI);
 |  currКнопка=3: ВидимостьОтчетныхТаблиц_Work(False, False, True , False, fINI);
 |  currКнопка=4: ВидимостьОтчетныхТаблиц_Work(False, False, False, True , fINI);
 else		  ВидимостьОтчетныхТаблиц_Work(False, False, False, False, fINI);
 fi;
end;

Proc ValidateОтчетSection;
 ValidateОтчетSectionInit(False);
 SetFLGСлужИнф;
end;

Proc ОчисткаОтчета;
 Очистить;
 ОчиститьТаблицу;
 ОчиститьИтоги;
 Template.Freeze(0, 0);
 TimeCreationRep="";
 СлужИнфоСЧТ="";
 СлужИнфоАНА="";
 СлужИнфоГРП="";
 ValidateОтчетSection;
end;

Proc ValidateSection(флгСкрытьУсловия:Logical; флгНастройки:Logical);
var Flag :Logical;
 ShowProgress(1, "Работаем...");
 Try
   Flag = not (флгСкрытьУсловия or флгНастройки);
   --
   if	  флгСкрытьУсловия and not флгНастройки: flgНстрВнВидОтч=False; cb_НстрВнВидОтч.State=False; cb_НстрВнВидОтч.Visible=False;
   |  not флгСкрытьУсловия and	   флгНастройки: flgСкрытьПарОтч=False; cb_СкрытьПарОтч.State=False; cb_СкрытьПарОтч.Visible=False;
   |  not флгСкрытьУсловия and not флгНастройки: cb_СкрытьПарОтч.Visible=True; cb_НстрВнВидОтч.Visible=True ;
   fi;
   --
   СекцДопСпр.Visible=Flag;
   Секц_Услов.Visible=Flag;
   Секц_ЦенБМ.Visible=Flag;
   Секц_Одата.Visible=Flag;
   --
   btnРасчет.Visible=Flag;
   --
   rbtAccВсе.Visible=Flag; rbtФинВсе.Visible=Flag;
   rbtAccБал.Visible=Flag; rbtФинБдж.Visible=Flag;
   rbtAccЗаб.Visible=Flag; rbtФинДхд.Visible=Flag;
   --
   Bevel1.Visible=Flag;
   Bevel2.Visible=Flag;
   --
   ValidateОтчетSectionInit(флгНастройки);
   SetFLGСлужИнф;
   --
 Finally
   CloseProgress;
 end;
end;

Proc ОчиститьУсловияОтбора(МожноСчт:Logical; МожноГрп:Logical; МожноАна:Logical);
 if МожноСчт:
   отчКБК=""; valКБК="";
 fi;
 if МожноГрп:
   keyГРП=""; отчГРП=""; nmsГРП=""; LastGRP_key="{0}"; LastGRP_num=0; ОчиститьГРПНФА;
 fi;
 if МожноАна:
   отчМОЛ=""; nmsМОЛ="";
   отчМХЭ=""; nmsМХЭ="";
   отчДОП=""; nmsДОП="";
   отчНФА=""; nmsНФА="";
 fi;
end;

Func ОтменитьИзмененияУсловийОтчета :Logical;
var FF :Logical;
var qq :Integer;
 FF=False;
 if Позиции>0:
   qq=EnqOkCancel("Условия отбора данных для отчета изменились!^MОчистить отчет?", mtConfirmation);
   if qq=cmOk: ОчисткаОтчета;
   |  qq=cmCancel: FF=True;
   fi;
 fi;
 ^FF;
end;

Func ВыборДаты(srcDate:Date) :Date;
var dd :Date;
 if srcDate>1.1.100: dd=Calendar(srcDate); else dd=Calendar(ToDay); fi;
 if not(dd<=1.1.100): ^dd; else ^srcDate; fi;
end;

Func GetDate :Date;  -- считываем в заданном поле дату
var name :String;
 name=Up(AsString(Template.Field));
 if name="ДатОпер": ^ДатОпер;
 |  name="ДатИсп" : ^ДатИсп;
 fi;
end;

Proc SetDate(Value:Date); -- устанавливаем в заданном поле дату; Value - значение даты, которое необходимо присвоить
var name :String;
 name=Up(AsString(Template.Field));
 if name="ДатОпер": ДатОпер = Value;
 |  name="ДатИсп" : ДатИсп  = Value;
 fi;
end;

Func Объединить(Value1:String; Value2:String; Separator:String) :String;
var Ret :String;
 if Value1<>"" and Value2<>"": Ret=Value1+Separator+Value2;
 |  Value1= "" and Value2<>"": Ret=Value2;
 |  Value1<>"" and Value2="" : Ret=Value1;
 |  True: Ret="";
 fi;
 ^Ret;
end;

Func TimeToHMSstring_adv(valTime:Integer; valSep:String) :String;
var ihh, imm, icc :Integer;
var shh, smm, scc :String;
 shh=''; smm=''; scc='';
 ihh=Int(Trunc(valTime/3600));
 imm=Int(Trunc((valTime-ihh*3600)/60));
 icc=valTime-ihh*3600-imm*60;
 shh=Format("%.2d", ihh);
 smm=Format("%.2d", imm);
 scc=Format("%.2d", icc);
 ^(shh+valSep+smm+valSep+scc);
end;

Func ВыбратьРежимСохранения(ТекущийРежим:Integer) :Integer;
var num:Integer;
 ClearVariable(Buf);
 Buf[01]="Всегда сохранять";
 Buf[02]="Сохранять по запросу";
 Buf[03]="Никогда не сохранять";
 num=Alternate("Выберите режим сохранения ведомости", Buf, -1, ТекущийРежим+1, 12);
 if not num>0: ^ТекущийРежим; else ^(num-1); fi;
end;

Proc ВзятьРеквизиты(saveREC:Record; Auto:Logical);
var RO, num :Integer;
var REC :Record;
 if Auto:
   if Trim(УЧР_ИМЯ)="":
     RO=OpenWorkArea("КОНТРАГЕНТ", "", "НАШЕ");
     Try
       num=Records(RO);
       if num<1: REC=NIL;
       |  num=1: REC=GetRecordKey(RO, 1);
       |  num>1: REC=GetRecordKey(RO, 1);
		 SetFilter(RO, "НАШЕ and РПО_УМОЛЧАНИЕ");
		 if Records(RO)>0: REC=GetRecordKey(RO, 1); fi;
       fi;
       if REC=NIL and saveREC<>NIL: REC=saveREC; fi;
       if REC<>NIL:
	 SetFilter(RO, "UKey="+RecordToString(REC));
	 if Records(RO)=1:
	    УЧР_ИМЯ = GetFieldS(RO, 1, "КОРИМЯ");
	   УЧР_ОКПО = GetFieldS(RO, 1, "ОКПО");
	 fi;
       fi;
     Finally
       CloseWorkArea(RO);
     end;
   fi;
 else
   REC=OpenCardFile("КОНТРАГЕНТ", "НАШЕ", saveREC, crdRecordOnly);
   if REC=NIL: Exit; fi;
   RO=OpenWorkArea("КОНТРАГЕНТ", "", "UKey="+RecordToString(REC));
   Try
     if Records(RO)=1:
	УЧР_ИМЯ = GetFieldS(RO, 1, "КОРИМЯ");
       УЧР_ОКПО = GetFieldS(RO, 1, "ОКПО");
     fi;
   Finally
     CloseWorkArea(RO);
   end;
 fi;
end;

Proc ПО_Выбор(prevVal:String);
var КОД, ИМЯ, Value :String;
 Value=AnaElection("П.*", False, False, prevVal);
 if Value="": Exit; fi;
 КОД=Value;
 Value=Name_A(КОД);
 ИМЯ=if(Value<>"" and Value<>" ", Value, КОД);
 ПОД_ИМЯ=ИМЯ;
 ПОД_КОД=КОД;
end;

Proc Счета_МассивФлаговVПеременные(FTRсчета:Integer);
var Value :String;
var ii :Integer;
 Value="";
 if FTRсчета=2:
   -- 1111111110000000
   for ii=1 to 09 do Value=Value+if(BufFlag[ii], "1", "0"); od;
   флагиACC=Value+"0000000";
 |  FTRсчета=3:
   -- 0000000001111111
   for ii=1 to 07 do Value=Value+if(BufFlag[ii], "1", "0"); od;
   флагиACC="000000000"+Value;
 else
   -- 1111111111111111
   for ii=1 to 16 do Value=Value+if(BufFlag[ii], "1", "0"); od;
   флагиACC=Value;
 fi;
end;

Proc Счета_ПеременныеVМассивФлагов(FTRсчета:Integer);
var Value :String;
var ii :Integer;
 if FTRсчета=2:
   -- 1111111110000000
   Value=SubStr(флагиACC, 01, 09);
   for ii=1 to 09 do BufFlag[ii]=if(SubStr(Value, ii, 1)="1", True, False); od;
 |  FTRсчета=3:
   -- 0000000001111111
   Value=SubStr(флагиACC, 10, 07);
   for ii=1 to 07 do BufFlag[ii]=if(SubStr(Value, ii, 1)="1", True, False); od;
 else
   -- 1111111111111111
   Value=флагиACC;
   for ii=1 to 16 do BufFlag[ii]=if(SubStr(Value, ii, 1)="1", True, False); od;
 fi;
end;

Proc Счета_СоздатьМассивВидовНФА(FTRсчета:Integer);
 if Length(флагиACC)<>16: флагиACC="0000000000000000"; fi;
 -- XXXXXXXXYZZZZZZZ
 -- 1234567890123456
 if FTRсчета=2:
   -- 11111111110000000
   BufMsk[01] = "101.?1"; BufStr[01] = "жилые помещения";
   BufMsk[02] = "101.?2"; BufStr[02] = "нежилые помещения";
   BufMsk[03] = "101.?3"; BufStr[03] = "сооружения";
   BufMsk[04] = "101.?4"; BufStr[04] = "машины и оборудование";
   BufMsk[05] = "101.?5"; BufStr[05] = "транспортные средства";
   BufMsk[06] = "101.?6"; BufStr[06] = "производственный и хозяйственный инвентарь";
   BufMsk[07] = "101.?7"; BufStr[07] = "библиотечный фонд";
   BufMsk[08] = "101.?8"; BufStr[08] = "прочие основные средства";
   BufMsk[09] = "102.?0"; BufStr[09] = "нематериальные активы";
 |  FTRсчета=3:
   -- 00000000001111111
   BufMsk[01] = "105.?1"; BufStr[01] = "медикаменты и перевязочные средства";
   BufMsk[02] = "105.?2"; BufStr[02] = "продукты питания";
   BufMsk[03] = "105.?3"; BufStr[03] = "горюче-смазочные материалы";
   BufMsk[04] = "105.?4"; BufStr[04] = "строительные материалы";
   BufMsk[05] = "105.?5"; BufStr[05] = "мягкий инвентарь";
   BufMsk[06] = "105.?6"; BufStr[06] = "прочие материальные запасы";
   BufMsk[07] = "105.?7"; BufStr[07] = "готовая продукция";
 else
   -- 11111111111111111
   BufMsk[01] = "101.?1"; BufStr[01] = "жилые помещения";
   BufMsk[02] = "101.?2"; BufStr[02] = "нежилые помещения";
   BufMsk[03] = "101.?3"; BufStr[03] = "сооружения";
   BufMsk[04] = "101.?4"; BufStr[04] = "машины и оборудование";
   BufMsk[05] = "101.?5"; BufStr[05] = "транспортные средства";
   BufMsk[06] = "101.?6"; BufStr[06] = "производственный и хозяйственный инвентарь";
   BufMsk[07] = "101.?7"; BufStr[07] = "библиотечный фонд";
   BufMsk[08] = "101.?8"; BufStr[08] = "прочие основные средства";
   BufMsk[09] = "102.?0"; BufStr[09] = "нематериальные активы";
   BufMsk[10] = "105.?1"; BufStr[10] = "медикаменты и перевязочные средства";
   BufMsk[11] = "105.?2"; BufStr[11] = "продукты питания";
   BufMsk[12] = "105.?3"; BufStr[12] = "горюче-смазочные материалы";
   BufMsk[13] = "105.?4"; BufStr[13] = "строительные материалы";
   BufMsk[14] = "105.?5"; BufStr[14] = "мягкий инвентарь";
   BufMsk[15] = "105.?6"; BufStr[15] = "прочие материальные запасы";
   BufMsk[16] = "105.?7"; BufStr[16] = "готовая продукция";
 fi;
end;

Proc Счета_ОбновитьМеню(Iter:Integer; MaxK:Integer);
 if Iter>MaxK: Buf[Iter]="КОД$"+BufMsk[Iter-MaxK]+"-->> "+if(BufFlag[Iter-MaxK], "[ВКЛ.]: ", "[ВЫКЛ.]: ")+BufStr[Iter-MaxK]; fi;
end;

Proc Счета_ФлагиВТекст(FTRсчета:Integer);
var num, ii, kk, j1, j2, j5 :Integer;
var res, res101, res102, res105 :String;
 num=LengthOfArray(BufFlag);
 kk=0; j1=0; j2=0; j5=0;
 res101=""; res102=""; res105="";
 for ii=1 to num do
   if BufFlag[ii]:
     kk=kk+1;
     if FTRсчета=2:
       if Match(BufMsk[ii], "101.??"): j1=j1+1; res101=res101+" "+BufMsk[ii];
       |  Match(BufMsk[ii], "102.??"): j2=j2+1; res102=res102+" "+BufMsk[ii];
       fi;
     |	FTRсчета=3:
       if Match(BufMsk[ii], "105.??"): j5=j5+1; res105=res105+" "+BufMsk[ii]; fi;
     else
       if Match(BufMsk[ii], "101.??"): j1=j1+1; res101=res101+" "+BufMsk[ii];
       |  Match(BufMsk[ii], "102.??"): j2=j2+1; res102=res102+" "+BufMsk[ii];
       |  Match(BufMsk[ii], "105.??"): j5=j5+1; res105=res105+" "+BufMsk[ii];
       fi;
     fi;
   fi;
 od;
 res101=Trim(res101);
 res102=Trim(res102);
 res105=Trim(res105);
 if j1=8: res101="101.??"; fi; -- субсчетов 101 - 8 штук
 if j2=1: res102="102.?0"; fi; -- субсчетов 102 - 1 штук
 if j5=7: res105="105.??"; fi; -- субсчетов 105 - 7 штук
 res="";
 if FTRсчета=2:
    if kk=num: res="101.?? 102.?0"; else res=res101+" "+res102; fi;
 |  FTRсчета=3:
    if kk=num: res="105.??"; else res=res105; fi;
 else
    if kk=num: res="101.?? 102.?0 105.??"; else res=res101+" "+res102+" "+res105; fi;
 fi;
 отчСЧТ=Trim(res);
end;

Proc Счета_ОбновитьВидыНФА(FTRсчета:Integer);
 Счета_СоздатьМассивВидовНФА(FTRсчета);
 Счета_ПеременныеVМассивФлагов(FTRсчета);
 Счета_ФлагиВТекст(FTRсчета);
end;

Proc Счета_ВнешнийВид;
 Счета_ОбновитьВидыНФА(2); -- Применяются только ОС
end;

Proc Счета_ВыборВидаНФА(FTRсчета:Integer);
var kk, MaxK, num, ii :Integer;
 ClearVariable(Buf); ClearVariable(BufMsk); ClearVariable(BufStr); ClearVariable(BufFLAG);
 MaxK=0;
 Buf[1]=Chr(149)+"-->> Отмена изменений";
 Buf[2]=Chr(169)+"-->> Утвердить изменения";
 Buf[3]=Chr(187)+Chr(043)+Chr(171)+"-->> Выделить все счета НФА";
 Buf[4]=Chr(171)+Chr(151)+Chr(187)+"-->> Сбросить все счета НФА";
 Buf[5]="КОД$-->> Счета учета НФА.";
 MaxK=LengthOfArray(Buf);
 Счета_СоздатьМассивВидовНФА(FTRсчета);
 Счета_ПеременныеVМассивФлагов(FTRсчета);
 num=LengthOfArray(BufMsk);
 for ii=1 to num do Buf[ii+MaxK]="КОД$"+BufMsk[ii]+"-->> "+if(BufFlag[ii], "[ВКЛ.]: ", "[ВЫКЛ.]: ")+BufStr[ii]; od;
 kk=0;
 while kk=0 or kk>MaxK do
   Счета_ОбновитьМеню(kk, MaxK);
   kk=AlternateTree("", Buf, -1, if(kk>MaxK, kk, MaxK), 12, "$", "Параметр", "Комментарий", -1, False);
   if kk=1:
     Exit;
   |  kk=2:
     if SearchInArray(BufFlag, True, False, 1)<1:
	Message("[Утвердить изменения]^MНет выбранных счетов!", mtWarning);
	kk=0;
     fi;
   |  kk=3:
     for ii=1 to num do BufFlag[ii]=True;  Счета_ОбновитьМеню(ii+MaxK, MaxK); od;
     kk=0;
   |  kk=4:
     for ii=1 to num do BufFlag[ii]=False; Счета_ОбновитьМеню(ii+MaxK, MaxK); od;
     kk=0;
   |  kk>MaxK:
     BufFlag[kk-MaxK]=not(BufFlag[kk-MaxK]);
   fi;
 od;
 --
 Счета_МассивФлаговVПеременные(FTRсчета);
 Счета_ФлагиВТекст(FTRсчета);
end;

Proc ВнешнийВид_Забаланс(ЕстьЗабаланс:Logical);
var цвFont, цвBack :Integer;
var ТЧ :Logical;
 if ЕстьЗабаланс: цвFont=coBlack; цвBack=coTransparent; ТЧ=True; else цвFont=coWhite; цвBack=coTeal; ТЧ=False; fi;
 if ТЧ: отчКБК=""; valКБК=""; fi;
 Секц_Услов.Cell(3, 3, CellFontColor, цвFont);
 Секц_Услов.Cell(3, 3, CellBgColor,   цвBack);
 Секц_Услов.Cell(3, 3, CellReadOnly,  ТЧ);
end;

Proc ВнешнийВид_ФильтрДопСпр;
var ТЧ, ЕстьОтбор :Logical;
var цвFont, цвBack :Integer;
 if Name_A(VOCКОД+".")<>" ": ЕстьОтбор=True; else ЕстьОтбор=False; fi;
 if ЕстьОтбор: цвFont=coWhite; цвBack=coTeal; ТЧ=False; else цвFont=coBlack; цвBack=coTransparent; ТЧ=True; fi;
 Секц_Услов.Cell(10, 3, CellFontColor, цвFont);
 Секц_Услов.Cell(10, 3, CellBgColor,   цвBack);
 Секц_Услов.Cell(10, 3, CellReadOnly,  ТЧ);
end;

Func AddVocOPER(PrevValue:String; Auto:Logical) :String;
var res, tmp, voc :String;
var RO, OA, i, num, len, k :Integer;
var REC :Record;
var OK :Logical;
 RefreshAna;
 res="";
 REC=SignToRecord("ДНФА.ВНПР.ЭЭ", False);
 if REC<>NIL:
   RO=OpenWorkArea("РПО_ДНФА", "", "Ukey="+RecordToString(REC));
   Try
     if Records(RO)=1:
       OA=OpenArray(RO, 1, "ЗАПРОС", "ПОЛЕПОДТАБЛИЦЫ", "Match(ПОЛЕПОДТАБЛИЦЫ, 'АН*')");
       num=Records(OA);
       if num>0:
	 ClearVariable(Txt);
	 voc=GetFieldS(RO, 1, "НЕДЕЙСТВСПР");
	 len=WordsCount(voc, "|");
	 if len>0:
	   for i=1 to len do
	     tmp=Up(ExtractWord(i, voc, "|"));
	     if SearchInArray(Txt, tmp, True, 1)=-1: k=InsertInArraySort(Txt, tmp); fi;
	   od;
	 fi;
	 voc=GetFieldS(RO, 1, "НЕДЕЙСТВОСТ");
	 len=WordsCount(voc, "|");
	 if len>0:
	   for i=1 to len do
	     tmp=Up(ExtractWord(i, voc, "|"));
	     if SearchInArray(Txt, tmp, True, 1)=-1: k=InsertInArraySort(Txt, tmp); fi;
	   od;
	 fi;
	 ClearVariable(Buf);
	 for i=1 to num do
	   tmp=GetFieldS(OA, i, "ОТВЕТ");
	   OK=GetFieldL(OA, i, "ОСТАТОК");
	   if not Match(tmp, "НФА.*") and
	      not Match(tmp, "МОЛ.*") and
	      not Match(tmp, "М.*")   and
	      not Match(tmp, pfxУЧН+".*") and OK:
	      tmp=Up(ExtractWord(1, tmp, "."));
	      if SearchInArray(Txt, tmp, True, 1)=-1 and SearchInArray(Buf, tmp, True, 1)=-1:
		k=InsertInArraySort(Buf, tmp);
	      fi;
	   fi;
	 od;
       fi;
       CloseWorkArea(OA);
       num=LengthOfArray(Buf);
       if num>0:
	 res="";
	 for i=1 to num do res=Объединить(res, Buf[i], "|"); od;
       else
	 if not Auto: Message("В операции 'ДНФА.ВНПР.ЭЭ'^Mне найдено дополнительной аналитики!", mtInformation); fi;
	 ^PrevValue;
       fi;
     fi;
   Finally
     CloseWorkArea(RO);
   end;
 else
   if not Auto: Message("В базе операции нет 'ДНФА.ВНПР.ЭЭ'", mtInformation); fi;
   ^PrevValue;
 fi;
 ^res;
end;

Func ВыборСправочникаФильтра(VOC:String) :String;
var ANA, Value :String;
var ii, num :Integer;
 ANA="";
 ANA=AddVocOPER("", True);
 ClearVariable(Buf);
 if ANA<>"":
   num=WordsCount(ANA, "|");
   if num>0:
     for ii=1 to num do
       Value=ExtractWord(ii, ANA, "|")+".*";
       AddInArray(Buf, True, False, Value);
     od;
   fi;
 fi;
 num=WordsCount(MaskUserVoc, "|");
 if num>0:
   for ii=1 to num do
     Value=ExtractWord(ii, MaskUserVoc, "|");
     AddInArray(Buf, True, False, Value);
   od;
 fi;
 Value="";
 num=LengthOfArray(Buf);
 if num>0: for ii=1 to num do Value=Value+"|"+Buf[ii]; od; fi;
 if SubStr(Value, 1, 1)="|": Value=Trim(SubStr(Value, 2, 255)); fi;
 --
 ANA=AnaElection(Value+"&~(М.*|МОЛ.*|НФА.*|УЧН.*)", True, False, VOC+".");
 if ANA="": ^VOC; else ^ANA; fi;
 ^"";
end;

Proc ВыборДопСправочника(onExit:Logical);
var StoreVoc, NewVoc :String;
var SaveValue :Logical;
 SaveValue=False;
 StoreVoc=VOCКОД;
 if onExit: NewVoc=""; else NewVoc=ВыборСправочникаФильтра(StoreVoc); fi;
 if NewVoc<>StoreVoc: if not ОтменитьИзмененияУсловийОтчета: SaveValue=True; fi; fi;
 if SaveValue:
   VOCКОД=NewVoc;
   VOCИМЯ=Name_A(VOCКОД+".");
   ОТЧДОП="";
   NMSДОП="";
   ВнешнийВид_ФильтрДопСпр;
 fi;
end;

Proc Счета_ВыборВидаНФАonEnter(FTRсчета:Integer);
var StoreСЧТ :String;
 StoreСЧТ=отчСЧТ;
 Счета_ВыборВидаНФА(FTRсчета);
 if отчСЧТ<>StoreСЧТ: 
   if ОтменитьИзмененияУсловийОтчета: 
     отчСЧТ=StoreСЧТ;
   else
     ОчиститьУсловияОтбора(True, True, flgЧиститьАна);
     if not flgЧиститьАна: отчНФА=""; nmsНФА=""; fi;
   fi;
 fi;
 ВнешнийВид_Забаланс(if(currAcc<>2, True, False));
 ValidateОтчетSection;
end;

Func ПравильнаяМаскаСчетовОС(maskСчета:String) :String;
var num, ii :Integer;
var res :String;
 res="";
 num=WordsCount(maskСчета, " ");
 if num>0: for ii=1 to num do res=res+"|"+"*."+ExtractWord(ii, maskСчета, " ")+"*"; od; fi;
 if SubStr(res, 1, 1)="|": res=Trim(SubStr(res, 2, 255)); fi;
 ^res;
end;

Func ИтоговаяМаскаСчета(flgИсточникФинансирования:Integer; maskСЧТ:String; maskКБК:String; useБАЛ:Logical; useЗАБ:Logical) :String;
var ИФД, maskUSEсчт, maskUSEкбк, resMask :String;
 if flgИсточникФинансирования=2: ИФД="1"; | flgИсточникФинансирования=3: ИФД="2"; else ИФД="?"; fi;
 if maskКБК<>"": maskUSEкбк=maskКБК; else maskUSEкбк="???.????.???????.???"; fi;
 if maskСЧТ<>"": maskUSEсчт=ПравильнаяМаскаСчетовОС(maskСЧТ); else maskUSEсчт="*.101.??.?10|*.102.?0.?20"; fi;
 resMask="("+maskUSEсчт+")&("+if(useБАЛ, maskUSEкбк+"."+ИФД+".???.??.???", "")+if(useБАЛ and useЗАБ, "|", "")+if(useЗАБ, "ЗАБ.??.101.??", "")+")";
 ^resMask;
end;

Func ИмяЭлементаСтруктурыКБК(НомерЭлемента:Integer; ТипСтруктуры:String) :String;
--???.????.???????.??? - Глава # Подраздел # Целевая статья # Вид расходов
--???.?.??.?????.??.???? - Администратор # Группа # Подгруппа # Статья # Элемент # Программа, Подпрограмма
--???.??.??.??.??.??.???? - Администратор # Группа # Подгруппа # Статья # Подстатья # Элемент # Программа, Подпрограмма
 if ТипСтруктуры="ФКР":  ТипСтруктуры="КР"; fi;
 if ТипСтруктуры="КИФД": ТипСтруктуры="ФД"; fi;
 if ТипСтруктуры="КР":
   if НомерЭлемента=1: ^"Глава";
   |  НомерЭлемента=2: ^"Подраздел";
   |  НомерЭлемента=3: ^"Целевая статья";
   |  НомерЭлемента=4: ^"Вид расходов";
   fi;
 |  ТипСтруктуры="КД":
   if НомерЭлемента=1: ^"Администратор";
   |  НомерЭлемента=2: ^"Группа";
   |  НомерЭлемента=3: ^"Подгруппа";
   |  НомерЭлемента=4: ^"Статья";
   |  НомерЭлемента=5: ^"Элемент";
   |  НомерЭлемента=6: ^"Программа, подпрограмма";
   fi;
 |  ТипСтруктуры="ФД":
   if НомерЭлемента=1: ^"Администратор";
   |  НомерЭлемента=2: ^"Группа";
   |  НомерЭлемента=3: ^"Подгруппа";
   |  НомерЭлемента=4: ^"Статья";
   |  НомерЭлемента=5: ^"Подстатья";
   |  НомерЭлемента=6: ^"Элемент";
   |  НомерЭлемента=7: ^"Программа, подпрограмма";
   fi;
 fi;
 ^"";
end;

Proc КБК_ОбновитьМенюВсе(isMaxA:Integer; isMaxS:Integer; isResVal:String; isResMsk:String; isтипКБК:String);
var ii :Integer;
 for ii=1 to isMaxS do
   BufStr[ii]=ExtractWord(ii, isResVal, ".");
   BufMsk[ii]=ExtractWord(ii, isResMsk, ".");
   Buf[ii+isMaxA]=BufMsk[ii]+"--"+Chr(187)+" "+ИмяЭлементаСтруктурыКБК(ii, isтипКБК);
 od;
end;

Proc КБК_ОбновитьМенюЭлемент(Iter:Integer; isMaxA:Integer; isтипКБК:String);
 if Iter>isMaxA: Buf[Iter]=BufMsk[Iter-isMaxA]+"--"+Chr(187)+" "+ИмяЭлементаСтруктурыКБК(Iter-isMaxA, isтипКБК); fi;
end;

Func КБК_СформироватьМенюМасокКБК(StoreКБКMsk:String; StoreКБКVal:String; maskСЧТ:String; ModeКБК:Integer; editКБК:Logical) :String;
var MaxA, MaxS, num, ii :Integer;
var типКБК, ResVal, ResMsk, маскКБК, tmp :String;
 if ModeКБК=1: типКБК="КР";   MaxS=4; маскКБК="???.????.???????.???";
 |  ModeКБК=2: типКБК="КД";   MaxS=6; маскКБК="???.?.??.?????.??.????";
 |  ModeКБК=3: типКБК="КИФД"; MaxS=7; маскКБК="???.??.??.??.??.??.????";
 else типКБК="";
 fi;
 if типКБК="": ^StoreКБКMsk; fi;
 --
 ClearVariable(Buf); ClearVariable(BufStr); ClearVariable(BufMsk);
 --
 if Match(StoreКБКVal, маскКБК) and not Pos("?", StoreКБКVal)>0: РАБ.УПП.КБК2005.StoreКБК=StoreКБКVal; fi;
 if editКБК: if not Match(StoreКБКVal, маскКБК) or Pos("?", StoreКБКVal)>0: editКБК=False; fi; fi;
 if editКБК:
   ResMsk=StoreКБКMsk;
   ResVal=StoreКБКVal;
 else

   ResMsk=Trim(РАБ.УПП.КБК2005.ВыборКБКиерарх2005(maskСЧТ, типКБК, False));
   if ResMsk="": ^StoreКБКMsk; fi;
   ResVal=ResMsk;
 fi;
 --
 Buf[1]="...--К выбору КБК";
 Buf[2]=Chr(169)+"--Утвердить маску";
 MaxA=LengthOfArray(Buf);
 КБК_ОбновитьМенюВсе(MaxA, MaxS, ResVal, ResMsk, типКБК);
 num=0;
 while num<>2 do
   КБК_ОбновитьМенюЭлемент(num, MaxA, типКБК);
   num=AlternateTree("", Buf, 35, num, 12, "$", "Параметр", "Комментарий", -1, False);
   if num=1:
     ResMsk=Trim(РАБ.УПП.КБК2005.ВыборКБКиерарх2005(maskСЧТ, типКБК, False));
     if ResMsk="": ^StoreКБКMsk; fi;
     ResVal=ResMsk;
     КБК_ОбновитьМенюВсе(MaxA, MaxS, ResVal, ResMsk, типКБК);
   | num=2: Break;
   | num>2:
     tmp=BufMsk[num-MaxA];
     if Pos("?", tmp)>0:
       BufMsk[num-MaxA]=BufStr[num-MaxA];
     else
       BufMsk[num-MaxA]=RepStr("?", Length(tmp));
     fi;
   else
     ^StoreКБКMsk;
   fi;
 od;
 ResMsk="";
 for ii=1 to MaxS do ResMsk=ResMsk+"."+BufMsk[ii]; od;
 if SubStr(ResMsk, 1, 1)=".": ResMsk=SubStr(ResMsk, 2, Length(ResMsk)-1); fi;
 valКБК=ResVal;
 ^ResMsk;
end;

Func КБК_ВыборКБК(maskСЧТ:String; SaveКБК:String) :String;
var Value :String;
var Edit :Logical;
 Value="";
 if Match(SaveКБК, "???.????.???????.???"):  Edit=True; else Edit=False; fi;
 РАБ.БЮДЖЕТ2005.РежимМаски="?";
 Value=КБК_СформироватьМенюМасокКБК(SaveКБК, valКБК, maskСЧТ, 1, Edit);
 if Value="" or Value=" ": ^SaveКБК; fi;
 ^Value;
end;

Proc КБК_ВыбратьФильтрКБК(OnExit:Logical);
var StoreКБК, NewКБК, mskСЧТ :String;
var SaveValue :Logical;
 SaveValue=False;
 StoreКБК=отчКБК;
 --
 if OnExit:
   NewКБК="";
 else
   mskСЧТ=ИтоговаяМаскаСчета(currИст, отчСЧТ, "", True, False);
   NewКБК=КБК_ВыборКБК(mskСЧТ, StoreКБК);
 fi;
 --
 if NewКБК<>StoreКБК: if not ОтменитьИзмененияУсловийОтчета: SaveValue=True; fi; fi;
 if SaveValue: 
   ОчиститьУсловияОтбора(False, False, flgЧиститьАна);
   отчКБК=NewКБК;
 fi;
end;

Func ЗаменитьСимволСтрокиВпозиции(valStr:String; repChar:String; repPos:Integer) :String;
var tmpFirst, tmpLast, out :String;
var len :Integer;
 tmpFirst=""; tmpLast=""; out="";
 len=Length(valStr);
 if repPos<1: repPos=1; fi;
 if repPos>len or repChar="" or valStr="": ^valStr; fi;
 repChar=SubStr(repChar, 1, 1);
 if repPos>1: tmpFirst=SubStr(valStr, 1, repPos-1); else tmpFirst=""; fi;
 if repPos<len: tmpLast=SubStr(valStr, repPos+1, len-repPos); else tmpLast=""; fi;
 out=tmpFirst+repChar+tmpLast;
 ^out;
end;

Func УдалитьРазделитель_дляНашаСорт(Value:String) :String;
var nn :Integer;
 nn=Pos("#", Value);
 while nn>0 do Value=ЗаменитьСимволСтрокиВпозиции(Value, "_", nn); nn=Pos("#", Value);	    od;
 nn=Pos(Chr(169), Value);
 while nn>0 do Value=ЗаменитьСимволСтрокиВпозиции(Value, "_", nn); nn=Pos(Chr(169), Value); od;
 ^Value;
end;

Func УдалитьРазделительЧерта(Value:String) :String;
var nn :Integer;
 nn=Pos("|", Value);
 while nn>0 do Value=ЗаменитьСимволСтрокиВпозиции(Value, "_", nn); nn=Pos("|", Value); od;
 ^Value;
end;

Func ВхожденийНет(ANA:String; MSK:String) :Logical;
 ^(Pos(ANA, MSK)=0);
end;

Func КорректныеСимволыПризнака(Value:String) :String;
var num, ii, intChars :Integer;
var Res, Chars :String;
 Res="";
 num=Length(Value);
 if num>0:
   for ii=1 to num do
     Chars=SubStr(Value, ii, 1);
     intChars=Ascii(Chars);
     if intChars=46 or			      -- точка
	(intChars>= 48 and intChars<= 57) or  -- цифры
	(intChars>= 65 and intChars<= 90) or  -- латиница заглавные
	intChars=95 or			      -- нижнее подчеркивание
	(intChars>= 97 and intChars<=122) or  -- латиница строчные
	(intChars>=192 and intChars<=255):    -- национальный алфавит
	   Res=Res+Chars; else Res=Res+"_";
     fi;
   od;
 fi;
 ^Res;
end;

Func MatchMask(Src:String; Mask:String; SepMask:String) :Logical;
var ii, num :Integer;
var tmp :String;
 num=WordsCount(Mask, SepMask);
 for ii=1 to num do
   tmp=ExtractWord(ii, Mask, SepMask);
   if Match(Src, tmp): ^True; fi;
 od;
 ^if(num=0, Match(Src, Mask), False);
end;

Func СоответствуетФильтруПоСчетам(ftrAcc:String; grpAcc:String) :Logical;
var num1, num2, ii, jj :Integer;
var OK :Logical;
 ClearVariable(KeyMsk);
 num1=WordsCount(ftrAcc, " ");
 if num1>0: for ii=1 to num1 do KeyMsk[ii]=ExtractWord(ii, ftrAcc, " "); od; fi; -- фильтр счетов отчета
 ClearVariable(KeyStr);
 num2=WordsCount(grpAcc, " ");
 if num2>0: for jj=1 to num2 do KeyStr[jj]=ExtractWord(jj, grpAcc, " "); od; fi; -- фильтр счетов группы НФА
 if num1>0 and num2>0:
   for ii=1 to num1 do
     for jj=1 to num2 do
       OK=MatchMask(KeyStr[jj], KeyMsk[ii], " ");
       if OK: ^True; fi;
     od;
   od;
 fi;
 ^False;
end;

Func ГруппаНФА_СчитатьСправочник(maskAcc:String; FlagUpdate:Logical) :Logical;
var RO, jj, num, kk :Integer;
var OK, Work :Logical;
var GRPUNQ, GRPВИД, GRPКОД, GRPИМЯ, GRPСЧТ, Value :String;
 OK=False;
 if not FlagUpdate:
    if GRPBUF[1]="" or not LengthOfArray(GRPBUF)>0:
      FlagUpdate=True;
    else
      if LengthOfArray(GRPBUF)<>LengthOfArray(GRPDAT) or LengthOfArray(GRPBUF)<>LengthOfArray(GRPKEY):
	FlagUpdate=True;
      fi;
    fi;
 fi;
 if not FlagUpdate: ^True; fi;
 RO=OpenWorkArea(crdГРП, "ВИД", "КОД<>'' or НАИМЕНОВАНИЕ<>''");
 ShowProgress(0, "Считывание групп НФА...");
 Try
   num=Records(RO);
   if num>0:
     ОчиститьГРПНФА;
     ShowProgress(num, "Считывание групп НФА...");
     for jj=1 to num do
       ProgressPos(jj);
       GRPСЧТ=Lo(Trim(GetFieldS(RO, jj, "ГРНФА")));
       Work=СоответствуетФильтруПоСчетам(maskAcc, GRPСЧТ);
       if Work:
	 GRPUNQ=RecordToString(GetRecordKey(RO, jj));
	 GRPВИД=КорректныеСимволыПризнака(Lo(Trim(GetFieldS(RO, jj, "ВИД"))));
	 if GRPВИД="": GRPВИД="_без группировки"; fi;
	 GRPКОД=КорректныеСимволыПризнака(Lo(Trim(GetFieldS(RO, jj, "КОД"))));
	 GRPИМЯ=УдалитьРазделительЧерта(Lo(Trim(GetFieldS(RO, jj, "НАИМЕНОВАНИЕ"))));
	 if GRPКОД=""  and GRPИМЯ<>"": GRPКОД=GRPИМЯ;
	 |  GRPКОД<>"" and GRPИМЯ="" : GRPИМЯ=GRPКОД;
	 fi;
	 Value=Up(GRPВИД)+"|"+Up(GRPКОД)+"--Подгруппа '"+GRPИМЯ+"'";
	 if SearchInArray(GRPBUF, Value, True, 1)<0:
	   kk=InsertInArraySort(GRPBUF, Value);
	   InsertInArray(GRPDAT, kk, GRPВИД+"|"+GRPКОД+"|"+GRPИМЯ);
	   InsertInArray(GRPKEY, kk, GRPUNQ);
	 fi;
	 Value=Up(GRPВИД)+"|--Группа '"+GRPВИД+"'";
	 if SearchInArray(GRPBUF, Value, True, 1)<0:
	   kk=InsertInArraySort(GRPBUF, Value);
	   InsertInArray(GRPDAT, kk, GRPВИД);
	   InsertInArray(GRPKEY, kk, "{0}");
	 fi;
       fi;
     od;
     if LengthOfArray(GRPBUF)>0: OK=True; else OK=False; fi;
     InsertInArray(GRPBUF, 1, "*--Перечитать группы НФА");
     InsertInArray(GRPDAT, 1, "");
     InsertInArray(GRPKEY, 1, "");
   fi;
 Finally
   CloseProgress;
   CloseWorkArea(RO);
 end;
 ^OK;
end;

Proc ГруппыНФА_ВзятьИменаГрупп(грпValue:String; кейValue:String; Sep:String);
var Final_NAME, currVal, currKey, ИМЯGRP, GRPвер, GRPниж, tmp1, tmp2, tmp3 :String;
var num, ii, pp :Integer;
var OK: Logical;
 Final_NAME="";
 num=WordsCount(грпValue, Sep);
 if num>0:
   for ii=1 to num do
     ИМЯGRP="";
     currVal=ExtractWord(ii, грпValue, Sep);
     currKey=ExtractWord(ii, кейValue, Sep);
     GRPвер=ExtractWord(1, currVal, "$");
     GRPниж=ExtractWord(2, currVal, "$");
     if GRPниж="*":
       ИМЯGRP="Вся группа "+Up(GRPвер);
     else
       if currKey<>"{0}":
	 pp=SearchInArray(GRPKEY, currKey, False, 1);
	 if pp>0:
	   OK=False;
	   tmp1=Lo(ExtractWord(1, GRPDAT[pp], "|"));
	   tmp2=Lo(ExtractWord(2, GRPDAT[pp], "|"));
	   tmp3=Lo(ExtractWord(3, GRPDAT[pp], "|"));
	   if Lo(GRPвер)=tmp1 and Lo(GRPниж)=tmp2: OK=True; fi;
	   if OK: ИМЯGRP=Up(GRPвер)+" "+Chr(151)+" "+Lo(tmp3); fi;
	 fi;
       fi;
       if ИМЯGRP="": ИМЯGRP=Up(GRPвер)+" "+Chr(151)+" "+Lo(GRPниж); fi;
     fi;
     Final_NAME=Объединить(Final_NAME, ИМЯGRP, " | ");
   od;
 fi;
 nmsГРП=Final_NAME;
end;

Func ГруппыНФА_ВыборФильтраОтбораГруппНФА(StoreVal:String; StoreKey:String; Sep:String) :String;
var len, ii, num1, num2, kk, nn, pp :Integer;
var NewValue, tmp, ANA, UKG, currVal, currKey, ВИДGRP, КОДGRP, КЛЧGRP :String;
var ВыбранаМаска, f1, f2 :Logical;
 if not ГруппаНФА_СчитатьСправочник(отчСЧТ, False):
   Message("Не заполнен справочник групп НФА ["+crdГРП+"]!", mtError);
   keyГРП=StoreKey;
   ^StoreVal;
 fi;
 currVal=Up(StoreVal);
 currKey=Up(StoreKey);
 kk=-1;
 if Pos("|", currVal)<1:
   ii=Length(currVal);
   if Pos("*", currVal)=ii and ii>2:
     tmp=Up(SubStr(currVal, 1, ii-2))+"|--Группа '"+Lo(SubStr(currVal, 1, ii-2))+"'";
     kk=SearchInArray(GRPBUF, tmp, True, 1);
   else
     if LastGRP_key<>"{0}": kk=SearchInArray(GRPKEY, LastGRP_key, False, 1); fi;
   fi;
 fi;
 if kk=-1: if LastGRP_num>0: kk=LastGRP_num; else kk=1; fi; fi;
 len=1;
 while len=1 do
   len=AlternateTree("Выберите группу...", GRPBUF, -1, kk, 12, "|", "ГРУППЫ", "ПОЯСНЕНИЕ", -1, True);
   if len=0:
     --Message("Отказ от выбора группы!", mtInformation);
     keyГРП=StoreKey;
     ^StoreVal;
   |  len=1:
     if not ГруппаНФА_СчитатьСправочник(отчСЧТ, True):
       Message("Не заполнен справочник групп НФА ["+crdГРП+"]!", mtError);
       keyГРП=StoreKey;
       ^StoreVal;
     fi;
   fi;
 od;
 ВыбранаМаска=False;
 ВИДGRP=ExtractWord(1, GRPDAT[len], "|");
 КОДGRP=ExtractWord(2, GRPDAT[len], "|");
 КЛЧGRP=GRPKEY[len];
 if Pos("|--", GRPBUF[len])>0: NewValue=Up(ВИДGRP+"$*"); tmp=SubStr(NewValue, 1, Length(NewValue)-2); ВыбранаМаска=True; else NewValue=Up(ВИДGRP+"$"+КОДGRP); tmp=NewValue; fi;
 if currVal="": LastGRP_key=КЛЧGRP; LastGRP_num=len; keyГРП=КЛЧGRP; ^NewValue; fi;
 --
 ClearVariable(Buf); ClearVariable(BufMsk); ClearVariable(BufStr); ClearVariable(KeyMsk); ClearVariable(KeyStr); ClearVariable(aAna);
 num1=WordsCount(currVal, Sep);
 for ii=1 to num1 do
   ANA=ExtractWord(ii, currVal, Sep);
   UKG=ExtractWord(ii, currKey, Sep);
   if Pos("*", ANA)>0:
     pp=InsertInArraySort(BufMsk, ANA);
     InsertInArray(KeyMsk, pp, UKG);
   else
     pp=InsertInArraySort(BufStr, ANA);
     InsertInArray(KeyStr, pp, UKG);
   fi;
 od;
 num1=LengthOfArray(BufMsk);
 num2=LengthOfArray(BufStr);
 if ВыбранаМаска:
   pp=InsertInArraySort(Buf, NewValue); InsertInArray(aAna, pp, КЛЧGRP);
   if num1>0:
     for ii=1 to num1 do
       f1=Match(NewValue, BufMsk[ii]);
       f2=ВхожденийНет(tmp, BufMsk[ii]);
       if (not f1) and f2: pp=InsertInArraySort(Buf, BufMsk[ii]); InsertInArray(aAna, pp, KeyMsk[ii]); fi;
     od;
   fi;
   if num2>0:
     for ii=1 to num2 do
       f1=Match(BufStr[ii], NewValue);
       f2=ВхожденийНет(BufStr[ii], NewValue);
       if (not f1) and f2: pp=InsertInArraySort(Buf, BufStr[ii]); InsertInArray(aAna, pp, KeyStr[ii]); fi;
     od;
   fi;
 else
   if num1>0:
     for ii=1 to num1 do
       f1=Match(NewValue+"$", BufMsk[ii]);
       if not f1:
	 pp=InsertInArraySort(Buf, BufMsk[ii]); InsertInArray(aAna, pp, KeyMsk[ii]);
       else
	 nn=Enquiry("Выберите действие...", "Значение '"+NewValue+"' соответствует маске '"+BufMsk[ii]+"'!", "Заменить маску на значение;Сохранить маску, значение опустить", mtConfirmation);
	 if nn=2: pp=InsertInArraySort(Buf, BufMsk[ii]); InsertInArray(aAna, pp, KeyMsk[ii]); NewValue=""; fi;
       fi;
     od;
   fi;
   if num2>0:
     for ii=1 to num2 do
       pp=InsertInArraySort(Buf, BufStr[ii]);
       InsertInArray(aAna, pp, KeyStr[ii]);
     od;
   fi;
   --
   if NewValue<>"":
     num1=SearchInArray(Buf, NewValue, True, 1);
     if num1=-1: pp=InsertInArraySort(Buf, NewValue); InsertInArray(aAna, pp, КЛЧGRP); fi;
   fi;
 fi;
 num1=LengthOfArray(Buf);
 ANA=""; UKG="";
 for ii=1 to num1 do
   ANA=Объединить(ANA,	Buf[ii], Sep);
   UKG=Объединить(UKG, aAna[ii], Sep);
   if Length(ANA)>255:
     Message("Строка аналитики не может быть больше 255 символов.^MВыбор отменен!", mtWarning);
     keyГРП=StoreKey;
     ^StoreVal;
   fi;
 od;
 -- Заполняем служебную инфу
 if Pos("|", ANA)<1: LastGRP_key=КЛЧGRP; else LastGRP_key="{0}"; fi;
 LastGRP_num=len;
 keyГРП=UKG;
 ^ANA;
end;

Func УдалитьСловоНомер(strNumber:Integer; strValue:String; strSep:String) :String;
var ii, num :Integer;
var newValue :String;
 newValue=strValue;
 num=WordsCount(strValue, strSep);
 if num>0:
   newValue="";
   if num>=strNumber:
     for ii=1 to num do
       if not strNumber=ii: 
	 newValue=Объединить(newValue,	ExtractWord(ii, strValue, strSep), strSep);
       fi;
     od;
   fi;
 fi;
 ^newValue;
end;

Func ГруппыНФА_УдалитьИзНабора_Диалог(грпVal:String; грпKey:String; грпSep:String) :String;
var num, ii, nn :Integer;
var currVal, currKey, ИМЯGRP, GRPвер, GRPниж, tmp1, tmp2, tmp3 :String;
var OK :Logical;
 ClearVariable(Buf);
 num=WordsCount(грпVal, грпSep);
 if num<2: keyГРП=""; ^""; fi;
   for ii=1 to num do
     ИМЯGRP="";
     currVal=ExtractWord(ii, грпVal, грпSep);
     currKey=ExtractWord(ii, грпKey, грпSep);
     GRPвер=ExtractWord(1, currVal, "$");
     GRPниж=ExtractWord(2, currVal, "$");
     if GRPниж="*":
       ИМЯGRP="Вся группа "+Up(GRPвер);
     else
       if currKey<>"{0}":
	 nn=SearchInArray(GRPKEY, currKey, False, 1);
	 if nn>0:
	   OK=False;
	   tmp1=Lo(ExtractWord(1, GRPDAT[nn], "|"));
	   tmp2=Lo(ExtractWord(2, GRPDAT[nn], "|"));
	   tmp3=Lo(ExtractWord(3, GRPDAT[nn], "|"));
	   if Lo(GRPвер)=tmp1 and Lo(GRPниж)=tmp2: OK=True; fi;
	   if OK: ИМЯGRP=Up(GRPвер)+" "+Chr(151)+" "+Lo(tmp3); fi;
	 fi;
       fi;
       if ИМЯGRP="": ИМЯGRP=Up(GRPвер)+" "+Chr(151)+" "+Lo(GRPниж); fi;
     fi;
     Buf[ii+1]=ИМЯGRP;
   od;
 Buf[1]="* Удалить все значения *";
 nn=Alternate("Удаление...", Buf, -1, 1, 12);
 if nn<1:
   keyГРП=грпKey;
   ^грпVal;
 |  nn=1:
   keyГРП="";
   ^"";
 |  nn>1:
   грпVal=УдалитьСловоНомер(nn-1, грпVal, грпSep);
   грпKey=УдалитьСловоНомер(nn-1, грпKey, грпSep);
   keyГРП=грпKey;
   ^грпVal;
 fi;
end;

Proc ГруппыНФА_ВыбратьФильтрГруппыНФА(OnExit:Logical);
var StoreАНА, StoreКЕЙ, NewАНА :String;
var SaveValue :Logical;
 SaveValue=False;
 StoreАНА=отчГРП;
 StoreКЕЙ=keyГРП;
 --
 if OnExit:
   NewАНА=ГруппыНФА_УдалитьИзНабора_Диалог(StoreАНА, StoreКЕЙ, "|");
 else
   NewАНА=ГруппыНФА_ВыборФильтраОтбораГруппНФА(StoreАНА, StoreКЕЙ, "|");
 fi;
 --
 if NewАНА<>StoreАНА: if not ОтменитьИзмененияУсловийОтчета: SaveValue=True; fi; fi;
 if SaveValue:
   отчГРП=NewАНА;
   ГруппыНФА_ВзятьИменаГрупп(отчГРП, keyГРП, "|");
 fi;
end;

Func УдалитьСловоИзНабора_Диалог(Set:String; SepSet:String) :String;
var num, ii, nn :Integer;
 ClearVariable(Buf);
 num=WordsCount(Set, SepSet);
 if num<2: ^""; fi;
 for ii=1 to num do Buf[ii+1]=ExtractWord(ii, Set, SepSet); od;
 Buf[1]="Удалить все";
 nn=Alternate("Удаление...", Buf, -1, 1, 12);
 if nn=0: ^Set; fi;
 Set="";
 if nn=1: ^Set; fi;
 num=num+1;
 for ii=2 to num do if not ii=nn: Set=Set+SepSet+Buf[ii]; fi; od;
 Set=SubStr(Set, Length(SepSet)+1, 255);
 ^Set;
end;

Func СформироватьУсловиеОтбораНФА :String;
var ii, num :Integer;
var Res, Value :String;
 Res="";
 num=WordsCount(отчСЧТ, " ");
 if num>0:
   for ii=1 to num do
     Value=ExtractWord(ii, отчСЧТ, " ");
     Res=Объединить(Res, "НФА."+Value+".*", "|");
   od;
 fi;
 if Res="": Res="НФА.*"; fi;
 ^Res;
end;

Func Аналитика_ВыборПризнака(VOC:String; StoreANA:String) :String;
var Value, MaskAnaElec :String;
 Value="";
 RefreshAna;
 if Up(VOC)="НФА": MaskAnaElec=СформироватьУсловиеОтбораНФА; else MaskAnaElec=VOC+".*"; fi;
 Value=AnaElection(MaskAnaElec, False, True, StoreANA);
 if Trim(Value)="": ^""; fi;
 ^Value;
end;

Func Аналитика_ВыборПризнакаИзПроводок(VOC:String; StoreANA:String) :String;
var Путь, Value, MaskAnaElec, MaskAcc, tmp :String;
var num, kk, jj :Integer;
var ИзСписка, OK :Logical;
var Отч1 :Report;
 Value="";
 ИзСписка=False;
 ClearVariable(Buf);
 ClearVariable(BufMsk);
 ClearVariable(BufStr);
 Путь=PlanVar("НФА")+"\ОТЧЕТЫ\НФАОТЧ2007.lst";
 if not ExistFile(Путь): Message("Файл с отчетами отсутствует!", mtError); ИзСписка=True; fi;
 if not ИзСписка:
   Try
     MaskAcc=ИтоговаяМаскаСчета(currИст, отчСЧТ, отчКБК, if(currAcc=1 or currAcc=2, True, False), if(currAcc=1 or currAcc=3, True, False));
     if Up(VOC)="НФА": 
       MaskAnaElec=СформироватьУсловиеОтбораНФА;
       if (Length(MaskAcc)+Length(MaskAnaElec)+7)>255: MaskAnaElec=VOC+".*"; fi;
     else
       MaskAnaElec=VOC+".*";
     fi;
     Refresh(False);
     Отч1=RepOpen(Путь+"|По_признакам_БАЛиЗАБ", MaskAcc, MaskAnaElec, 1.1.100, if(ДатОпер>1.1.2000, ДатОпер+1, ToDay+1), "", VOC);
     RepReset(Отч1);
     Try
       while RepNext(Отч1) do
	 if RepIdent(Отч1)<>"":
	   tmp=Trim(Name_A(RepIdent(Отч1)));
	   if tmp="": tmp=" "; fi;
	   kk=InsertInArraySort(BufStr, tmp);
	   InsertInArray(BufMsk, kk, RepIdent(Отч1));
	   InsertInArray(Buf,	 kk, RepIdent(Отч1)+"--"+tmp);
	 fi;
       end;
     Finally
       Отч1=RepClose(Отч1);
     end;
   Except
     ИзСписка=True;
     --Message("Ошибка создания отчета^Mпри выборке аналитики из проводок!", mtError);
     --Raise;
     --^"";
   end;
   num=LengthOfArray(BufMsk);
   if not ИзСписка and num>0:
     InsertInArray(Buf,    1, Chr(149)+"--");
     InsertInArray(Buf,    1, Chr(169)+"--Выбор признака или группы признаков из списка");
     kk=SearchInArray(BufMsk, StoreANA, False, 1);
     OK=True;
     while OK do
       jj=AlternateTree("Выберите признак...", Buf, -1, kk+2, 12, "#", "Код признака", "Расшифровка признака", -1, False);
       if jj=0: OK=False; ^"";
       |  jj=1: OK=False; Value=Аналитика_ВыборПризнака(VOC, StoreANA);
       |  jj>2: OK=False; Value=BufMsk[jj-2];
       fi;
     od;
   else
     ИзСписка=True;
   fi;
 fi;
 if ИзСписка: Value=Аналитика_ВыборПризнака(VOC, StoreANA); fi;
 if Trim(Value)="": ^""; fi;
 ^Value;
end;

Func Аналитика_ВыборГрупповойАналитики(VOC:String; StoreANA:String; Sep:String; МаскаЗначение:Logical) :String;
var ANA, wrd, curValue, newValue :String;
var ВыбранаМаска, flg1, flg2 :Logical;
var ii, num1, num2, nn :Integer;
 ВыбранаМаска=False;
 curValue=Up(StoreANA);
 if Pos(Sep, curValue)>0:
   wrd="";
 else
   ii=Length(curValue);
   if Pos("*", curValue)=ii and ii>2:
     wrd=SubStr(curValue, 1, ii-1);
   else
     wrd=if(ValidSign(curValue), curValue, "");
   fi;
 fi;
 --
 -- newValue=Up(Аналитика_ВыборПризнака(VOC, wrd));
 newValue=Up(Аналитика_ВыборПризнакаИзПроводок(VOC, wrd));
 --
 if newValue="": ^StoreANA; fi;
 if SubStr(newValue, Length(newValue), 1)=".": newValue=newValue+"*"; wrd=SubStr(newValue, 1, Length(newValue)-2); ВыбранаМаска=True; else wrd=newValue; fi;
 if curValue="" or (ВыбранаМаска and (WordsCount(newValue, ".")<3)): ^newValue; fi;
 --
 ClearVariable(Buf); ClearVariable(BufMsk); ClearVariable(BufStr);
 -- отделяем маски значений от конкретных значений
 num1=WordsCount(curValue, Sep);
 for ii=1 to num1 do
   ANA=ExtractWord(ii, curValue, Sep);
   if Pos("*", ANA)>0: InsertInArraySort(BufMsk, ANA); else InsertInArraySort(BufStr, ANA); fi;
 od;
 num1=LengthOfArray(BufMsk);
 num2=LengthOfArray(BufStr);
 -- синхронизируем выбранное значение или маску с результирующим набором
 if ВыбранаМаска:
   InsertInArraySort(Buf, newValue);
   if num1>0:
     for ii=1 to num1 do
       flg1=Match(newValue, BufMsk[ii]);
       flg2=ВхожденийНет(wrd, BufMsk[ii]);
       if not flg1 and flg2: InsertInArraySort(Buf, BufMsk[ii]); fi;
     od;
   fi;
   if num2>0:
     for ii=1 to num2 do
       flg1=Match(BufStr[ii], newValue);
       flg2=ВхожденийНет(BufStr[ii], newValue);
       if not flg1 and flg2: InsertInArraySort(Buf, BufStr[ii]); fi;
     od;
   fi;
 else
   if num1>0:
     for ii=1 to num1 do
       flg1=Match(newValue+".", BufMsk[ii]);
       if not flg1:
	 InsertInArraySort(Buf, BufMsk[ii]);
       else
	 if МаскаЗначение:
	   nn=Enquiry("Выберите действие...", "Значение '"+newValue+"' соответствует маске '"+BufMsk[ii]+"'!", "Заменить маску на значение;Сохранить маску, значение опустить;Вставить значение и сохранить маску", mtConfirmation);
	   if nn=2: InsertInArraySort(Buf, BufMsk[ii]); newValue="";
	   |  nn=3: InsertInArraySort(Buf, BufMsk[ii]);
	   fi;
	 else
	   nn=Enquiry("Выберите действие...", "Значение '"+newValue+"' соответствует маске '"+BufMsk[ii]+"'!", "Заменить маску на значение;Сохранить маску, значение опустить", mtConfirmation);
	   if nn=2: InsertInArraySort(Buf, BufMsk[ii]); newValue=""; fi;
	 fi;
       fi;
     od;
   fi;
   if num2>0:
     CopyArray(BufStr, Buf, 1, LengthOfArray(Buf)+1);
   fi;
   SortArray(Buf, True);
   if newValue<>"":
     num1=SearchInArray(Buf, newValue, True, 1);
     if num1=-1: InsertInArraySort(Buf, newValue); fi;
   fi;
 fi;
 num1=LengthOfArray(Buf);
 ANA="";
 for ii=1 to num1 do
   ANA=Объединить(ANA, Buf[ii], Sep);
   if Length(ANA)>253:
     Message("Строка аналитики не может быть больше 253 символов.^MВыбор отменен!", mtWarning);
     ^StoreANA;
   fi;
 od;
 ^ANA;
end;

Func Аналитика_ВыбранВесьСправочник(voc:String) :String;
 if voc="ВД"  : ^"Все виды деятельности ["+voc+".*]";
 |  voc="ВКЛ" : ^"Вся ведомственная классификация ["+voc+".*]";
 |  voc="КТ"  : ^"Все категории ["+voc+".*]";
 |  voc="М"   : ^"Все местонахождения ["+voc+".*]";
 |  voc="МОЛ" : ^"Все материально ответственные лица ["+voc+".*]";
 |  voc="П"   : ^"Все подразделения ["+voc+".*]";
 |  voc="ПБС" : ^"Все получатели средств бюджета ["+voc+".*]";
 |  voc="ПГР" : ^"Все пункты генерального разрешния ["+voc+".*]";
 |  voc="РБС" : ^"Все распорядители бюджетных средств ["+voc+".*]";
 |  voc=""    : ^"";
 else ^"Все элементы справочника ["+voc+".*]";
 fi;
end;

Func Аналитика_ИмяГруппы(ANA:String) :String;
var nn :Integer;
var tmp :String;
 tmp="";
 nn=Length(ANA);
 if Pos("*", ANA)=nn and nn>2: tmp=(Name_A(SubStr(ANA, 1, nn-1))); else tmp=""; fi;
 if tmp="": tmp="нет наименования"; fi;
 ^tmp;
end;

Func Аналитика_FormatSetANA(Set:String; SepSet:String; SepOut:String) :String;-- набор описаний признаков в одной строке (разделители разные)
var num, i :Integer;
var OUT, ANA, tmp, tmp2, voc :String;
 OUT="";
 if SepSet<>"":
   num=WordsCount(Set, SepSet);
   for i=1 to num do
     ANA=ExtractWord(i, Set, SepSet);
     voc=ExtractWord(1, ANA, ".");
     tmp=Name_A(ANA);
     tmp2=if(tmp<>"" and tmp<>" ", tmp, if(ANA=voc+".*", Аналитика_ВыбранВесьСправочник(voc), Аналитика_ИмяГруппы(ANA)));
     OUT=Объединить(OUT, tmp2, SepOut);
   od;
 fi;
 ^OUT;
end;

Proc Аналитика_ВыбратьФильтрАналитики(refField:String; OnExit:Logical);
var ValueСПР, FieldАНА, FieldИМЯ, StoreАНА, NewАНА, NewИМЯ :String;
var SaveValue :Logical;
 SaveValue=False;
 --
 FieldАНА=Up(SubStr(refField, 1, Length(refField)-1));
 if FieldАНА="отчМОЛ": ValueСПР="МОЛ";
 |  FieldАНА="отчМХЭ": ValueСПР="М";
 |  FieldАНА="отчДОП": ValueСПР=VOCКОД;
 |  FieldАНА="отчНФА": ValueСПР="НФА";
 fi;
 FieldИМЯ="nms"+SubStr(FieldАНА, 4, 3);
 --
 StoreАНА=GetVariableS(FieldАНА);
 --
 if OnExit:
   NewАНА=УдалитьСловоИзНабора_Диалог(StoreАНА, "|");
 else
   NewАНА=Аналитика_ВыборГрупповойАналитики(ValueСПР, StoreАНА, "|", False);
 fi;
 --
 if NewАНА<>StoreАНА: if not ОтменитьИзмененияУсловийОтчета: SaveValue=True; fi; fi;
 if SaveValue:
    PutVariableS(FieldАНА, NewАНА);
    NewИМЯ=Аналитика_FormatSetANA(NewАНА, "|", " | ");
    PutVariableS(FieldИМЯ, NewИМЯ);
 fi;
end;

Func Оператор :String;
var nn :Integer;
 ClearVariable(Buf);
 Buf[1]="И";
 Buf[2]="ИЛИ";
 Buf[3]="И ИСКЛЮЧИТЬ";
 nn=Alternate("Выбор оператора",Buf, 20, 1, 12);
 if nn=1: ^"&";
 |  nn=2: ^"|";
 |  nn=3: ^"&~";
 fi;
 ^"";
end;

Func СчетаНФА_вУчете(maskСЧТ:String; ddBP:Date; ddEP:Date) :Integer;
var Путь, Acc :String;
var num, kk :Integer;
var Отч1 :Report;
 ClearVariable(Buf);
 Путь=PlanVar("НФА")+"\ОТЧЕТЫ\НФАОТЧ2007.lst";
 if not ExistFile(Путь): ^-1; fi;
 Try
   Отч1=RepOpen(Путь+"|По_счетам_НФА_Бал_Заб", maskСЧТ, "", if(ddBP>1.1.1990, ddBP, 1.1.100), if(ddEP>1.1.1990, ddEP, ToDay));
   RepReset(Отч1);
   Try
     num=RepRowsCount(Отч1);
     kk=0;
     while RepNext(Отч1) do
       Acc=RepIdent(Отч1);
       if Match(Acc, "???.????.???????.???.?.???.??.???")    or
	  Match(Acc, "???.??.??.??.??.??.????.?.???.??.???") or
	  Match(Acc, "ЗАБ.??.???.??"):
	 kk=kk+1;
	 Buf[kk]=Объединить(SignsMask(Acc, True), SignsMask(Acc, False), "|");
       fi;
     end; -- while
   Finally
     Отч1=RepClose(Отч1);
   end;
 Except
   ^-1;
 end;
 ^LengthOfArray(Buf);
end;

Func СчетаНФА_поСтруктуре(maskСЧТ:String) :Integer;
var Acc :String;
var kk :Integer;
 ClearVariable(Buf);
 kk=0;
 for Account Acc=maskСЧТ, Sort do 
   kk=kk+1;
   Buf[kk]=Объединить(SignsMask(Acc, True), SignsMask(Acc, False), "|");
 od;
 ^LengthOfArray(Buf);
end;

Func СправочникиСтруктурыПоМаскеСчетовПрогресс(maskСЧТ:String; ddBP:Date; ddEP:Date; OnlyUseAcc:Logical; EnableProgress:Logical) :String;
var Voc, MaskVoc :String;
var xx, ii, num, jj, kk :Integer;
var qq :Numeric;
 Try qq=Saldo(maskСЧТ, 1.1.100); Except ^" "; end;
 ClearVariable(bindVOC); ClearVariable(bindINT);
 if EnableProgress: ShowProgress(0, "Подготовка..."); fi;
 MaskVoc="";
 Try
   xx=0;
   if OnlyUseAcc: xx=СчетаНФА_вУчете(maskСЧТ, ddBP, ddEP); fi;
   if not xx>0:   xx=СчетаНФА_поСтруктуре(maskСЧТ); fi;
   if xx>0:
     if EnableProgress: ShowProgress(xx, "Анализ привязки справочников к счетам..."); fi;
     for ii=1 to xx do
       if EnableProgress: ProgressPos(ii); fi;
       num=WordsCount(Buf[ii], "|");
       for jj=1 to num do
	 Voc=ExtractWord(jj, Buf[ii], "|");
	 kk=SearchInArray(bindVOC, Voc, True, 1);
	 if kk>0:
	   bindINT[kk]=bindINT[kk]+1;
	 else
	   kk=InsertInArraySort(bindVOC, Voc);
	   InsertInArray(bindINT, kk, 1);
	 fi;
       od;
     od;
     num=LengthOfArray(bindVOC);
     if num>0:
       if EnableProgress: ShowProgress(num, "Обработка полученных данных..."); fi;
       jj=num; -- удаляем с конца
       for ii=1 to num do
	 if EnableProgress: ProgressPos(ii); fi;
	 -- xx - количество рабочих счетов
	 if bindINT[jj]<>xx: DeleteFromArray(bindVOC, jj); else MaskVoc=Объединить(MaskVoc, bindVOC[jj], "|"); fi;
	 jj=jj-1;
       od;
     fi;
   fi; -- xx>0
 Finally
   if EnableProgress: CloseProgress; fi;
 end;
 ^MaskVoc;
end;

Func ПравильныйСимволАналитики(Value:String) :Logical;
var intChars :Integer;
 intChars=Ascii(Value);
 if intChars=42 or			  -- звездочка (*)
    intChars=46 or			  -- точка
    (intChars>= 48 and intChars<= 57) or  -- цифры
    intChars=63 or			  -- знак вопроса (?)
    (intChars>= 65 and intChars<= 90) or  -- латиница заглавные
    intChars=95 or			  -- нижнее подчеркивание
    (intChars>= 97 and intChars<=122) or  -- латиница строчные
    (intChars>=192 and intChars<=255):	  -- национальный алфавит
       ^True;
 fi;
 ^False;
end;

Func ВсеСправочникиДопАналитикиПривязаны(vДопАна:String) :Integer;
var ii, num :Integer;
var Value, tmp :String;
 vДопАна=Trim(vДопАна);
 if vДопАна<>"" and LengthOfArray(bindVOC)>0:
   num=Length(vДопАна);
   if num>0:
     ClearVariable(Buf);
     Value="";
     for ii=1 to num do
       tmp=SubStr(vДопАна, ii, 1);
       if ПравильныйСимволАналитики(tmp):
	 Value=Value+tmp;
       else
	 if Value<>"":
	   if Pos(".", Value)>0: Value=ExtractWord(1, Value, ".")+".*"; fi;
	   AddInArray(Buf, True, False, Value);
	   Value="";
	 fi;
       fi;
     od;
     if Value<>"": AddInArray(Buf, True, False, Value); Value=""; fi;
     num=LengthOfArray(Buf);
     if num>0:
       for ii=1 to num do
	 if SearchInArray(bindVOC, Buf[ii], True, 1)<1:
	   Message("Длинное условие отбора аналитики.^MИспользуется свертка...^M^MСправочник '"+Buf[ii]+"' не привязан к выбранному фильтру по счетам!", mtError);
	   ^-1;
	 fi;
       od;
       ^+1;
     fi;
   fi;
 fi;
 ^0;
end;

Func ИтогоФильтрАналитики :String;
var Value, tmpНФА :String;
var len, kk, num :Integer;
var OK :Logical;
 Value=""; len=0; OK=False;
 if отчНФА<>"": tmpНФА=отчНФА; else tmpНФА="НФА.*"; fi;
 if tmpНФА<>"": if OK: num=3; else num=2; OK=True; fi; kk=Length(tmpНФА)+num; if (len+kk)<=255: len=len+kk; Value=Объединить("("+tmpНФА+")", Value, "&"); fi; fi;
 if отчМОЛ<>"": if OK: num=3; else num=2; OK=True; fi; kk=Length(отчМОЛ)+num; if (len+kk)<=255: len=len+kk; Value=Объединить("("+отчМОЛ+")", Value, "&"); fi; fi;
 if отчМХЭ<>"": if OK: num=3; else num=2; OK=True; fi; kk=Length(отчМХЭ)+num; if (len+kk)<=255: len=len+kk; Value=Объединить("("+отчМХЭ+")", Value, "&"); fi; fi;
 if отчДОП<>"": if OK: num=3; else num=2; OK=True; fi; kk=Length(отчДОП)+num; if (len+kk)<=255: len=len+kk; Value=Объединить("("+отчДОП+")", Value, "&"); fi; fi;
 if отчАНА<>"": if OK: num=3; else num=2; OK=True; fi; kk=Length(отчАНА)+num; if (len+kk)<=255: len=len+kk; Value=Объединить("("+отчАНА+")", Value, "&"); fi; fi;
 if Value="": Value="нет"; fi;
 ^Value;
end;

Func ПризнакСоотвМаске(Призн:String; услANA:String) :Logical;
-- Призн должно являтся полным значением, а не маской!
var Ana :String;
 if услANA="": ^False; fi;
 if Name_A(Призн)=" ": ^False; fi;
 if услANA="*": ^True; fi;
 for Sign Ana=услANA, Sort do if Призн=Ana: ^True; fi; od;
 ^False;
end;

Func ПризнакСоотвНабору(ANA:String; Набор:String) :Logical;
-- ANA должно являтся полным значением, а не маской!
var ii, num :Integer;
var Value :String;
 num=WordsCount(Набор, "|");
 if num>0:
   for ii=1 to num do
     Value=Up(ExtractWord(ii, Набор, "|"));
     if Match(Up(ANA), Value): ^True; fi;
   od;
 fi;
 ^False;
end;

Func ПроводкаПроходитОтборПоАналитике(len:Integer; УслАналитики:String; СложноеУсловие:Logical) :Logical;
var OK, MatchOK :Logical;
var ii, pp :Integer;
var Value, tmp :String;
 if Trim(УслАналитики)<>"":
   OK=False;
   if len>0: -- у проводки есть аналитика
     MatchOK=False;
     for ii=1 to len do  -- цикл по аналитике проводки
       pp=Pos(":", aAna[ii]);
       if pp>0: Value=SubStr(aAna[ii], 1, pp-1); else Value=aAna[ii]; fi;
       tmp=SubStr(Value, 1, 1);
       if tmp="+" or tmp="-": Value=Trim(SubStr(Value, 2, 255)); fi;
       if СложноеУсловие: -- простое условие - один признак или набор признаков через логическое "или" ( "|" )
	 MatchOK=ПризнакСоотвМаске(Value, Trim(УслАналитики));
       else
	 MatchOK=ПризнакСоотвНабору(Value, Trim(УслАналитики));
       fi;
       if MatchOK: Break; fi;
     od;
     if MatchOK: OK=True; fi;
   fi;
 else
   OK=True;
 fi;
 ^OK;
end;

Func USE_ИНВЕНТАРНЫЙ_НОМЕР(ACC:String; SUM:Numeric; KOL:Numeric; ddОТЧ:Date; FindУЧН:String; ctНФА100П:Numeric; ctНФА_ИНВ:Numeric) :Logical;
var Цена :Numeric;
 if Match(ACC, "*.?.101.??.???"):
    if Match(ACC, "*.?.101.?7.???"):
      if Match(FindУЧН, pfxУЧН+".*"): ^True; else if ctНФА100П>0.00 and SUM<>0.00 and KOL<>0.00: Цена=Abs(SUM)/Abs(KOL); if Цена>ctНФА100П: ^True; fi; fi; fi;
    else 
      if Match(FindУЧН, pfxУЧН+".*"): ^True; else if ctНФА_ИНВ>0.00 and SUM<>0.00 and KOL<>0.00: Цена=Abs(SUM)/Abs(KOL); if Цена>ctНФА_ИНВ: ^True; fi; fi; fi;
    fi;
 |  Match(ACC, "*.?.102.??.???"): ^True;
 |  Match(ACC, "*.?.103.??.???"): ^True;
 fi;
 ^False;
end;

Func СоответствуетФильтруПоГруппеНФА(аФтрГРП:String; аКОДГРП:String; аКОДПГР:String) :Logical;
var aValГРП, aValПГР, wdValue :String;
var ii, num :Integer;
var OK :Logical;
 if аФтрГРП<>"":
   num=WordsCount(аФтрГРП, "|");
   if num>0:
     OK=False;
     for ii=1 to num do
       wdValue=Lo(ExtractWord(ii, аФтрГРП, "|"));
       aValГРП=ExtractWord(1, wdValue, "$");
       aValПГР=ExtractWord(2, wdValue, "$");
       if (aValГРП=Lo(аКОДГРП) and aValПГР=Lo(аКОДПГР)) or (aValГРП=Lo(аКОДГРП) and aValПГР="*"): OK=True; fi;
       if OK: Break; fi;
     od;
     if OK: ^True; else ^False; fi;
   fi;
 else
   ^True;
 fi;
 ^False;
end;

Func СчетАмортизацииПоСчетуНФА(СЧТНФА:String) :String;
var sLeft, s1ACC, s2ACC, RES :String;
 RES="";
 if Match(СЧТНФА, "???.????.???????.???.?.101.??.???"):
    sLeft=SubStr(СЧТНФА, 1, 23);
    s1ACC=SubStr(СЧТНФА, 28, 1);
    s2ACC=SubStr(СЧТНФА, 29, 1);
    if s2ACC="1": RES=sLeft+"104."+s1ACC+"1.410";
    |  s2ACC="2": RES=sLeft+"104."+s1ACC+"2.410";
    |  s2ACC="3": RES=sLeft+"104."+s1ACC+"3.410";
    |  s2ACC="4": RES=sLeft+"104."+s1ACC+"4.410";
    |  s2ACC="5": RES=sLeft+"104."+s1ACC+"5.410";
    |  s2ACC="6": RES=sLeft+"104."+s1ACC+"6.410";
    |  s2ACC="7": RES=sLeft+"104."+s1ACC+"7.410";
    |  s2ACC="8": RES=sLeft+"104."+s1ACC+"8.410";
    else ^"";
    fi;
 |  Match(СЧТНФА, "???.????.???????.???.?.102.??.???"):
    sLeft=SubStr(СЧТНФА, 1, 23);
    s1ACC=SubStr(СЧТНФА, 28, 1);
    s2ACC=SubStr(СЧТНФА, 29, 1);
    if s2ACC="0": RES=sLeft+"104."+s1ACC+"9.420"; else ^""; fi;
 else ^"";
 fi;
 ^RES;
end;

Func ПроверкаДат :Logical;
var ddНачало :Date;
 ddНачало=1.1.1990;
 if ДатОпер<=1.1.100: Message('Не задана дата отчетного периода!',		 mtWarning); Template.Field="ДатОпер"; ^False; fi;
 if ДатОпер<ddНачало: Message('Не задана корректная дата отчетного периода!',	 mtWarning); Template.Field="ДатОпер"; ^False; fi;
 ^True;
end;

Func ПроверкаЗаполнения :Logical;
 if not ПроверкаДат: ^False; fi;
 if currAcc<1: currAcc=1; oldsAcc=currAcc; fi;
 if currИст<1: currИст=1; oldsИст=currИст; fi;
 if useЦеныЕЦ:
   if БМЦеныЕЦ=0:
     Message("Не задан фильтр цены!^M(Выбран пункт 'Выводить НФА с ценой больше (меньше) чем указанная')", mtWarning);
     Template.Field="БМЦеныЕЦ";
     ^False;
   fi;
   if flgSgnЕЦ<1:
     Message("Не задан знак сравнения цены!^M(Выбран пункт 'Выводить НФА с ценой больше (меньше) чем указанная')", mtWarning);
     Template.Field="flgSgnЕЦ";
     ^False;
   fi;
 fi;
 ^True;
end;

Func АнализФильтраАналитики(uMaskAcc:String; ИгнорПроводкиБезНФА:Logical) :String;
var uАНА, uДОП, uМОЛ, uМХЭ, uНФА, len_Max, len, xx, num :Integer;
var useMaskAna, Value, BindANA :String;
var OK :Logical;
 --
 useMaskAna="";
 ClearVariable(BufFlag);
 uАНА=0; uНФА=0; uДОП=0; uМОЛ=0; uМХЭ=0;
 len=Length(uMaskAcc)+7; -- 7=5+2  -5[знак()'*]  -2[{}]
 len_Max=255-len;
 len=0; xx=0;
 OK=False;
 --
 Value=отчАНА;
 if Value<>"":
   if OK: num=3; else num=2; OK=True; fi;
   xx=Length(Value)+num;
   if (len+xx)<=len_Max: len=len+xx; useMaskAna=Объединить(useMaskAna, "("+Value+")",  "&"); uАНА=+1; else uАНА=-1; fi;
 fi;
 --
 Value=отчНФА;
 if not ИгнорПроводкиБезНФА and Value="": Value="НФА.*"; fi;
 if Value<>"":
   if OK: num=3; else num=2; OK=True; fi;
   xx=Length(Value)+num;
   if (len+xx)<=len_Max: len=len+xx; useMaskAna=Объединить(useMaskAna, "("+Value+")",  "&"); uНФА=+1; else uНФА=-1; fi;
 fi;
 --
 Value=отчДОП;
 if Value<>"":
   if OK: num=3; else num=2; OK=True; fi;
   xx=Length(Value)+num;
   if (len+xx)<=len_Max: len=len+xx; useMaskAna=Объединить(useMaskAna, "("+Value+")",  "&"); uДОП=+1; else uДОП=-1; fi;
 fi;
 --
 Value=отчМОЛ;
 if Value<>"":
   if OK: num=3; else num=2; OK=True; fi;
   xx=Length(Value)+num;
   if (len+xx)<=len_Max: len=len+xx; useMaskAna=Объединить(useMaskAna, "("+Value+")",  "&"); uМОЛ=+1; else uМОЛ=-1; fi;
 fi;
 --
 Value=отчМХЭ;
 if Value<>"":
   if OK: num=3; else num=2; OK=True; fi;
   xx=Length(Value)+num;
   if (len+xx)<=len_Max: len=len+xx; useMaskAna=Объединить(useMaskAna, "("+Value+")",  "&"); uМХЭ=+1; else uМХЭ=-1; fi;
 fi;
 --
 BindANA=СправочникиСтруктурыПоМаскеСчетовПрогресс(uMaskAcc, 1.1.100, ДатОпер+1, True, True);
 if BindANA=" ": ^" "; fi; -- если был Except
 -- Проверка на привязку счетов для "неуместившейся" аналитики
 if SearchInArray(bindVOC, "НФА.*", True, 1)<1: Message("Справочник 'НФА' не привязан к выбранному фильтру по счетам учета НФА.", mtError); ^" "; fi;
 --
 if uМОЛ<0:
   if SearchInArray(bindVOC, "МОЛ.*", True, 1)<1:
     Message("Справочник 'МОЛ' не привязан к выбранному фильтру по счетам учета НФА.", mtError);
     ^" ";
   fi;
 fi;
 --
 if uМХЭ<0:
   if SearchInArray(bindVOC, "М.*", True, 1)<1:
     Message("Справочник 'М' не привязан к выбранному фильтру по счетам учета НФА.", mtError);
     ^" ";
   fi;
 fi;
 --
 if uДОП<0:
   if SearchInArray(bindVOC, VOCКОД+".*", True, 1)<1:
     Message("Длинное условие отбора аналитики.^MИспользуется свертка...^M^MСправочник '"+VOCКОД+"' не привязан к выбранному фильтру по счетам учета НФА.", mtError);
     ^" ";
   fi;
 fi;
 --
 if uАНА<0:
   num=ВсеСправочникиДопАналитикиПривязаны(отчАНА);
   if num>0:
   |  num=0: Message("Длинное условие отбора аналитики.^MИспользуется свертка...^M^MСправочник(и) из строки 'Допол. признаки' не привязан к выбранному фильтру по счетам учета НФА.", mtError);
	     ^" ";
   |  num<0: ^" ";
   fi;
 fi;
 BufFlag[1]=if(uНФА<0, True, False);
 BufFlag[2]=if(uМОЛ<0, True, False);
 BufFlag[3]=if(uМХЭ<0, True, False);
 BufFlag[4]=if(uДОП<0, True, False);
 BufFlag[5]=if(uАНА<0, True, False);
 --
 ^Trim(useMaskAna);
end;

Func ВзятьДЭКСПЛ_КМНТ(КМНТ:String) :Date;
var ДЭКСПЛ :Date;
var pp :Integer;
 КМНТ=' '+КМНТ;
 pp=Pos(' ДЭКСПЛ=', КМНТ);
 if pp>0:
   КМНТ=Trim(SubStr(КМНТ, pp+8, 10));
   Try ДЭКСПЛ=StringToDate(КМНТ); Except ДЭКСПЛ=1.1.100; end;
 fi;
 ^ДЭКСПЛ;
end;

Func ВзятьДУЧЕТ_КМНТ(КМНТ:String):Date;
var ДУЧЕТ :Date;
var pp :Integer;
 КМНТ=' '+КМНТ;
 pp=Pos(' ДУЧЕТ=',  КМНТ);
 if pp>0:
   КМНТ=Trim(SubStr(КМНТ, pp+8, 10));
   if Match(КМНТ, '?.??.????'): КМНТ='1'+КМНТ; fi;
   Try ДУЧЕТ=StringToDate(КМНТ); Except ДУЧЕТ=1.1.100; end;
 fi;
 ^ДУЧЕТ;
end;

Func ВзятьДатуВводаЭксплуат_Сложный(Fnc_Date:Date; Crd_Date:Date; vКОДНФА:String; vКОДУЧН:String; vКОДСЧТ:String; vКОДМХЭ:String; ddEND:Date; vXconstНФА100П:Numeric) :Date;
var MskAna, СЧТКОД :String;
var dd_Null, Rep_Date :Date;
var Цена :Numeric;
var pp :Integer;
 dd_Null=1.1.1800;
 if Crd_Date > dd_Null and Fnc_Date > dd_Null : if Crd_Date<Fnc_Date: Rep_Date=Crd_Date; else Rep_Date=Fnc_Date; fi;
 |  Crd_Date > dd_Null and Fnc_Date = 1.1.100 : Rep_Date=Crd_Date;
 |  Crd_Date = 1.1.100 and Fnc_Date > dd_Null : Rep_Date=Fnc_Date;
 else Rep_Date=1.1.100;
 fi;
 if Rep_Date>dd_Null: ^Rep_Date; fi;
 --
 Rep_Date=1.1.100;
 MskAna=vКОДСЧТ+"/(*.?.???.??.???|00){"+vКОДНФА+"&"+vКОДУЧН+"}";
 for Transaction pp=MskAna, 1.1.100, ddEnd  do
   Rep_Date=ВзятьДЭКСПЛ_КМНТ(TransComment(pp));
   if Rep_Date>dd_Null: ^Rep_Date; fi;
   Try Цена=Abs(TransSum(pp, "РУБ"))/Abs(TransSum(pp, "КОЛ")); Except Цена=0.00; end;
   СЧТКОД=TransCre(pp);
   if Match(vКОДМХЭ, "М.Э.*") or (СЧТКОД="00" and TransCardFile(pp)="РПО_ОСТ_НФА"): Rep_Date=TransDate(pp); fi;
   if Rep_Date>dd_Null: ^Rep_Date; fi;
   if Rep_Date=1.1.100:
     if Match(СЧТКОД, "*.?.101.??.3?0") or -- внутренние перемещения
	Match(СЧТКОД, "*.?.106.??.3?0") or -- принятие к учету
	Match(СЧТКОД, "*.?.304.04.3?0") or -- централизованное снабжение
	Match(СЧТКОД, "*.?.401.10.14?") or
	Match(СЧТКОД, "*.?.401.10.15?") or
	Match(СЧТКОД, "*.?.401.10.180") or
	((Match(СЧТКОД, "*.?.401.20.271") or Match(СЧТКОД, "*.2.109.??.271")) and Цена<=vXconstНФА100П):
	  Rep_Date=TransDate(pp);
	  if Rep_Date>dd_Null: ^Rep_Date; fi;
     fi;
   fi;
 end;
 ^Rep_Date;
end;

Func ВзятьДатуПринятияУчету_Сложный(Fnc_Date:Date; Crd_Date:Date; vКОДНФА:String; vКОДУЧН:String; vКОДСЧТ:String; ddEND:Date) :Date;
var dd_Null, Rep_Date :Date;
var MskAna :String;
var pp :Integer;
 dd_Null=1.1.1800;
 if Crd_Date > dd_Null and Fnc_Date > dd_Null : if Crd_Date<Fnc_Date: Rep_Date=Crd_Date; else Rep_Date=Fnc_Date; fi;
 |  Crd_Date > dd_Null and Fnc_Date = 1.1.100 : Rep_Date=Crd_Date;
 |  Crd_Date = 1.1.100 and Fnc_Date > dd_Null : Rep_Date=Fnc_Date;
 else Rep_Date=1.1.100;
 fi;
 if Rep_Date>dd_Null: ^Rep_Date; fi;
 --
 Rep_Date=1.1.100;
 MskAna=vКОДСЧТ+"/(*.106.??.3?0|*.304.04.3?0|*.401.10.14?|*.401.10.15?|*.401.10.172|*.401.10.180|00)"+"{"+vКОДНФА+"&"+vКОДУЧН+"}";
 for Transaction pp=MskAna, 1.1.100, ddEnd  do
   Rep_Date=ВзятьДУЧЕТ_КМНТ(TransComment(pp));
   if Rep_Date>dd_Null: ^Rep_Date; fi;
   Rep_Date=TransDate(pp);
   if Rep_Date>dd_Null: ^Rep_Date; fi;
 end;
 ^Rep_Date;
end;

Func ВзятьДатуВводаЭксплуат_П(vR1:Integer; vIter:Integer; Сложный:Logical; rvКОДНФА:String; rvКОДУЧН:String; rvКОДСЧТ:String; rvКОДМХЭ:String; RddEND:Date; rXconstНФА100П:Numeric) :Date;
var dd_Null, Rep_Date, clcFnc_Date, clcCrd_Date :Date;
 dd_Null  = 1.1.1800;
 Rep_Date = 1.1.100;
 if Name_A(rvКОДНФА)=" " or Name_A(rvКОДУЧН)=" ": ^Rep_Date; fi;
 clcFnc_Date = 1.1.100+Int(Saldo("ЗАБ.НФА.ДЭКСПЛ{"+rvКОДНФА+"&"+rvКОДУЧН+"}", RddEND));
 if Сложный:
   clcCrd_Date = 1.1.100;
   if vIter>0 and Up(WorkAreaCardFile(vR1))="РПО_ИНВКАРТ_ОС": clcCrd_Date = GetFieldD(vR1, vIter, "ДАТ_ВЭКСП"); fi;
   Rep_Date=ВзятьДатуВводаЭксплуат_Сложный(clcFnc_Date, clcCrd_Date, rvКОДНФА, rvКОДУЧН, rvКОДСЧТ, rvКОДМХЭ, RddEND, rXconstНФА100П);
 else
   if clcFnc_Date>dd_Null and Year(clcFnc_Date)<2050: Rep_Date=clcFnc_Date; fi;
 fi;
 ^Rep_Date;
end;

Func ВзятьДатуПринятияУчету_П(vR1:Integer; vIter:Integer; Сложный:Logical; rvКОДНФА:String; rvКОДУЧН:String; rvКОДСЧТ:String; RddEND:Date) :Date;
var dd_Null, Rep_Date, clcFnc_Date, clcCrd_Date :Date;
 dd_Null=1.1.1800;
 Rep_Date=1.1.100;
 if Name_A(rvКОДНФА)=" " or Name_A(rvКОДУЧН)=" ": ^Rep_Date; fi;
 clcFnc_Date = 1.1.100+Int(Saldo("ЗАБ.НФА.ДУЧЕТ{"+rvКОДНФА+"&"+rvКОДУЧН+"}", RddEND));
 if Сложный:
   clcCrd_Date = 1.1.100;
   if vIter>0 and Up(WorkAreaCardFile(vR1))="РПО_ИНВКАРТ_ОС": clcCrd_Date = GetFieldD(vR1, vIter, "ОПРИХ_ДАТА"); fi;
   Rep_Date=ВзятьДатуПринятияУчету_Сложный(clcFnc_Date, clcCrd_Date, rvКОДНФА, rvКОДУЧН, rvКОДСЧТ, RddEND);
 else
   if clcFnc_Date>dd_Null and Year(clcFnc_Date)<2050: Rep_Date=clcFnc_Date; fi;
 fi;
 ^Rep_Date;
end;

Func ВзятьСрокЭксплуатМес(ddVU:Date; vRинв:Integer; vIинв:Integer; vRнфа:Integer; vIнфа:Integer) :Integer;
var srok1, srok2 :Numeric;
var Res, len, ii :Integer;
 Res=0; srok1=0.00; srok2=0.00;
 if vIинв>0 and Up(WorkAreaCardFile(vRинв))="РПО_ИНВКАРТ_ОС": Try srok1 = Int(12*GetFieldN(vRинв, vIинв, "АМОРТ_СРОК")); Except srok1=0; end; fi;
 if srok1=0.00:
   if vIнфа>0 and Up(WorkAreaCardFile(vRнфа))="РПО_НФА":
     ClearVariable(Buf);
     if ddVU>31.12.2008: len=3; Buf[1]=" 09"; Buf[2]="	 "; Buf[3]=" 02";
     |	ddVU<01.01.2007: len=1; Buf[1]=" 02";
     else		 len=2; Buf[1]="   "; Buf[2]=" 02";
     fi;
     srok2=0;
     for ii=1 to len do if srok2=0: Try srok2=Int(12*GetFieldN(vRнфа, vIнфа, "СРОКАМ"+Trim(Buf[ii]))); Except srok2=0; end; else Break; fi; od;
   fi;
 fi;
 Res=if(srok1>0.00, Int(srok1), Int(srok2));
 ^Abs(Res);
end;

Func ВзятьДатуКонцаЭксплуат_П(ddVE:Date; СрокЭксплМес:Integer) :Date;
var dd_Null, Rep_Date :Date;
 dd_Null=1.1.1800;
 Rep_Date=1.1.100;
 if ddVE>dd_Null and СрокЭксплМес>0: ^(AddMon(ddVE, СрокЭксплМес)); fi;
 ^Rep_Date;
end;

Proc ПоискДанных_ИщемОстакиНФА101(vДатОпер:Date; vЕстьБал:Logical; vЕстьЗаб:Logical; vMaskACC:String; vMaskANA:String; vИспНФА:Logical; vИспМОЛ:Logical; vИспМХЭ:Logical; vИспДОП:Logical; vИспАНА:Logical; constНФА100П:Numeric; constНФА_ИНВ:Numeric);
var ВременныйФайл, aVal1, aVal2, aDeb, aCre, aComment, svrANA, svrSGN, refStrНФА :String;
var КОДСЧТ, КОДИСТ, КОДКБК, КОДСЧ6, КОДНФА, КОДУЧН, КОДМОЛ, КОДМХЭ, КОДДОП, NAMНФА, NAMУЧН :String;
var aSum1, aSum2, SUM, QUA, KOL :Numeric;
var len, xx, ii, jj, pp, hh :Integer;
var СЧДЕБ, НЕТУЧН, Work :Logical;
var aDate :Date;
 ClearVariable(aAna);
 ВременныйФайл=PlanVar('CACHE')+"\"+GetGUID;
 xx=TujRepNoNullBal+TujRepCombinedAna+if(vЕстьБал, TujRepBalAccount, 0)+if(vЕстьЗаб, TujRepZabalance, 0);
 len=TujReport(ВременныйФайл, 1.1.100, vДатОпер, vMaskACC, vMaskANA, "ДНФА", "", "", xx, False);
 if len>0:
   ShowProgress(len, "Выборка остатков ОС...");
   OpenTextJur(ВременныйФайл);
   Try
     ii=1;
     while not GetTransFromTextJur(aDate, aSum1, aVal1, aSum2, aVal2, aDeb, aCre, aAna, aComment) do
       ProgressPos(ii);
       ii=ii+1;
       -- Очистка аналитики
       КОДИСТ=""; КОДКБК=""; КОДСЧ6=""; КОДСЧТ=""; КОДНФА=""; КОДУЧН=""; КОДМОЛ=""; КОДМХЭ=""; КОДДОП=""; svrANA=""; svrSGN="";
       SUM=0.00; KOL=0.00; QUA=0.00;
       -- Отбор счетов
       if aDeb="00" or aDeb="00Z": КОДСЧТ=aCre; СЧДЕБ=False; fi;
       if aCre="00" or aCre="00Z": КОДСЧТ=aDeb; СЧДЕБ=True;  fi;
       if Match(КОДСЧТ, "???.????.???????.???.?.101.??.???")   : КОДСЧТ=SubStr(КОДСЧТ, 1, 30)+"???"; НЕТУЧН=False; КОДИСТ=SubStr(КОДСЧТ, 22, 1); КОДКБК=SubStr(КОДСЧТ, 1, 20); КОДСЧ6=SubStr(КОДСЧТ, 24, 6);
       |  Match(КОДСЧТ, "???.????.???????.???.?.102.??.???")   : КОДСЧТ=SubStr(КОДСЧТ, 1, 30)+"???"; НЕТУЧН=False; КОДИСТ=SubStr(КОДСЧТ, 22, 1); КОДКБК=SubStr(КОДСЧТ, 1, 20); КОДСЧ6=SubStr(КОДСЧТ, 24, 6);
       |  Match(КОДСЧТ, "???.????.???????.???.?.105.??.???")   : КОДСЧТ=SubStr(КОДСЧТ, 1, 30)+"???"; НЕТУЧН=True;  КОДИСТ=SubStr(КОДСЧТ, 22, 1); КОДКБК=SubStr(КОДСЧТ, 1, 20); КОДСЧ6=SubStr(КОДСЧТ, 24, 6);
       |  Match(КОДСЧТ, "ЗАБ.??.10?.??")		       : КОДСЧТ=КОДСЧТ; 		     НЕТУЧН=True;  КОДИСТ="З";			 КОДКБК="Забаланс";	       КОДСЧ6=SubStr(КОДСЧТ,  8, 6);
       else КОДИСТ=""; КОДКБК=""; КОДСЧ6=""; КОДСЧТ="";
       fi;
       if КОДСЧТ<>"":
	 if (aVal1="" or aVal1="РУБ") and aSum1<>0: if СЧДЕБ: SUM=aSum1; else SUM=-aSum1; fi;
	 |  (aVal2="" or aVal2="РУБ") and aSum2<>0: if СЧДЕБ: SUM=aSum2; else SUM=-aSum2; fi;
	 else SUM=0.00;
	 fi;
	 -- Проводим далее отбор аналитики
	 xx=LengthOfArray(aAna);
	 if xx>0:
	   for jj=1 to xx do
	     pp=Pos(":", aAna[jj]);
	     if pp>0:
	       QUA=StringToNumeric(SubStr(aAna[jj], pp+1, Length(aAna[jj])-pp));
	       svrANA=SubStr(aAna[jj], 1, pp-1);
	     else
	       svrANA=aAna[jj];
	     fi;
	     svrSGN=SubStr(svrANA, 1, 1);
	     if svrSGN="+" or svrSGN="-": svrANA=SubStr(svrANA, 2, 255); fi;
	     -- НФА и инв.номер нужны всегда
	     if Match(svrANA,	  "НФА.*"): КОДНФА=svrANA; KOL=if(СЧДЕБ, QUA, -QUA);
	     |	Match(svrANA, pfxУЧН+".*"): КОДУЧН=svrANA;
	     fi;
	     -- вытаскиваем только ту аналитику, которая не уместилась в условие отбора свертки
	     if vИспМОЛ: if Match(svrANA,     "МОЛ.*"): КОДМОЛ=svrANA; fi; fi;
	     if vИспДОП: if Match(svrANA, VOCКОД+".*"): КОДДОП=svrANA; fi; fi;
	     if vИспМХЭ or flgСложнДаты: if Match(svrANA,	"М.*"): КОДМХЭ=svrANA; fi; fi;
	   od; -- цикл по аналитике
	 fi; --xx>0
	 -- формирование задействованной аналитики
	 -- НФА
	 if КОДНФА="": КОДНФА="НФА.$$$"; fi;
	 -- УЧН
	 if Trim(КОДУЧН)="" or НЕТУЧН:
	   КОДУЧН=pfxУЧН+".$$$"; 
	 else
	   if not USE_ИНВЕНТАРНЫЙ_НОМЕР(КОДСЧТ, SUM, KOL, vДатОпер, КОДУЧН, constНФА100П, constНФА_ИНВ): КОДУЧН=pfxУЧН+".$$$"; fi;
	 fi;
	 -- МОЛ
	 if КОДМОЛ="": КОДМОЛ="МОЛ.$$$"; fi;
	 -- МХЭ
	 if КОДМХЭ="": КОДМХЭ="М.Э.$$$"; fi;
	 -- Дополнительный справочник
	 if КОДДОП="": if Name_A(VOCКОД+".")<>" ": КОДДОП=VOCКОД+".$$$"; else КОДДОП="$$$.$$$"; fi; fi;
	 --  *** Отбор по условию ***
	 Work=True;
	 if Work and vИспНФА: Work=ПризнакСоотвНабору(КОДНФА, отчНФА); fi;
	 if Work and vИспМОЛ: Work=ПризнакСоотвНабору(КОДМОЛ, отчМОЛ); fi;
	 if Work and vИспМХЭ: Work=ПризнакСоотвНабору(КОДМХЭ, отчМХЭ); fi;
	 if Work and vИспДОП: Work=ПризнакСоотвНабору(КОДДОП, отчДОП); fi;
	 if Work and vИспАНА: Work=ПроводкаПроходитОтборПоАналитике(xx, отчАНА, True); fi;
	 -- *** Проводка отобрана ***
	 if Work:
	   refStrНФА=""; NAMНФА=""; NAMУЧН=""; svrANA="";
	   -- Формирование ссылок на аналитику НФА
	   hh=SearchInArray(arr_КОДНФА, КОДНФА, True, 1);
	   if hh=-1:
	     count_arrНФА=count_arrНФА+1;
	     refStrНФА=Format("%.10d", count_arrНФА);
	     pp=InsertInArraySort(arr_КОДНФА, КОДНФА);
	     InsertInArray(arr_REFНФА, pp, refStrНФА);
	   else
	     refStrНФА=arr_REFНФА[hh];
	   fi;
	   -- *** СТРОКА ОТБОРА ОБЪЕКТОВ УЧЕТА ***
	   svrANA=КОДСЧТ+"#"+refStrНФА+"#"+КОДУЧН;
	   -- ПОДУМАТЬ над МЕСТОНАХОЖДЕНИЕМ !!!!!!!!!!!!
	   hh=SearchInArray(LST_UNIQUE, svrANA, True, 1);
	   if hh=-1:
	     -- НФА
	     NAMНФА=УдалитьРазделитель_дляНашаСорт(Trim(Name_A(КОДНФА)));
	     if NAMНФА="": if КОДНФА="НФА.$$$": NAMНФА="нет кода НФА"; else NAMНФА=КОДНФА; fi; fi;
	     -- УЧН
	     NAMУЧН=УдалитьРазделитель_дляНашаСорт(Trim(Name_A("ИНВВЕД."+КОДНФА+"."+КОДУЧН)));
	     if NAMУЧН="": NAMУЧН="не присвоен"; fi;
	     --
	     pp=InsertInArraySort(LST_UNIQUE, svrANA);
	     InsertInArray(LST_OSTСУМ, pp, SUM);
	     InsertInArray(LST_OSTКОЛ, pp, KOL);
	     InsertInArray(LST_КОДМХЭ, pp, КОДМХЭ);
	     InsertInArray(LST_КОДИСТ, pp, КОДИСТ);
	     InsertInArray(LST_КОДКБК, pp, КОДКБК);
	     InsertInArray(LST_КОДСЧ6, pp, КОДСЧ6);
	     InsertInArray(LST_ИМЯНФА, pp, NAMНФА);
	     InsertInArray(LST_ИМЯИНВ, pp, NAMУЧН);
	     InsertInArray(LST_НЕТУЧН, pp, НЕТУЧН);
	   else
	     LST_OSTСУМ[hh]=LST_OSTСУМ[hh]+SUM;
	     LST_OSTКОЛ[hh]=LST_OSTКОЛ[hh]+KOL;
	   fi; -- объект найден
	 fi; --Work (проводка отобрана)
       fi; --КОДСЧТ
     end; -- while
   Finally
     CloseTextJur;
     CloseProgress;
   end; -- Try
   Try DeleteFile(ВременныйФайл); Except end;
 fi; -- len>0 (TujReport)
end;

Func ДнейМесяца(Days:Date) :Integer;
var Month :Integer;
 Month=Mon(Days);
 if Month=1 : ^31;
 |  Month=2 : if РАБ.НФА.FUNC_LIB.Mod(Year(Days), 4)=0: ^29; else ^28; fi;
 |  Month=3 : ^31;
 |  Month=4 : ^30;
 |  Month=5 : ^31;
 |  Month=6 : ^30;
 |  Month=7 : ^31;
 |  Month=8 : ^31;
 |  Month=9 : ^30;
 |  Month=10: ^31;
 |  Month=11: ^30;
 |  Month=12: ^31;
 fi;
end;

Func JulianDays(ГД:Date) :Integer;
-- Вычисляем дни по Юлианскому календарю (без учета полудня [JD=JD+0.5 или вместо 1720994 - 1720994,5])
-- ГД - дата по григорианскому календарю
var КГ, КМ, КД :Integer; -- календарный григорианский год, месяц, день
var JD, ММ, ГГ, IA, IB, IS, GDAT :Integer;
 КГ=Year(ГД); КМ=Mon(ГД); КД=Day(ГД);
 if КМ>2 : ГГ=КГ; ММ=КМ+1; else ГГ=КГ-1; ММ=КМ+13; fi;
 if ГГ=0 : IS=1; else IS=Int(Trunc(ГГ/Abs(ГГ))); ГГ=Abs(ГГ); fi;
 GDAT=ГГ*10000+ММ*100+КД;
 if IS>0 :
   IB=0;
   if GDAT>=15821115 :
     IA=Int(Trunc(ГГ/100))*IS;
     IB=2-IA+Int(Trunc(Abs(IA)/4))*IS;
   fi;
   JD=1720994+КД+Int(Trunc(365.25*ГГ))+Int(Trunc(30.6001*ММ))+IB;
 else
   JD=1720994+КД-Int(Trunc(365.25*ГГ+0.75))+Int(Trunc(30.6001*ММ));
 fi;
 ^JD;
end;

Func НаписаниеИнтервала(strTrans:String) :String;
var val, nn, len :Integer;
 if strTrans="0": ^""; fi;
 len=Length(strTrans);
 if len<2: val=0; else val=Int(SubStr(strTrans, len-1, 1)); fi;
 nn=Int(SubStr(strTrans, len, 1));
 if nn=1 and val<>1		     : ^(strTrans+" год");
 | (nn=2 or nn=3 or nn=4) and val<>1 : ^(strTrans+" года");
 else				       ^(strTrans+" лет");
 fi;
 ^"";
end;

Func СрокЭксплуатацииПрописью(dayНач:Date; dayКон:Date) :String;
var JDн, JDк, JDв, Г1, Г2, М1, М2, Д1, Д2, РГ, РМ, РД, откл, a, b, c :Integer;
var DayNull, DayВ :Date;
var strRes, tmp1, tmp2 :String;
 strRes="";
 DayNull=1.1.1800;
 if dayНач>DayNull and dayКон>DayNull and dayКон>dayНач:
   JDн=JulianDays(dayНач); JDк=JulianDays(dayКон);
   Г1=Year(dayНач); М1=Mon(dayНач); Д1=Day(dayНач); a=ДнейМесяца(dayНач);
   Г2=Year(dayКон); М2=Mon(dayКон); Д2=Day(dayКон); b=ДнейМесяца(dayКон);
   if Д1>b: c=b; else c=Д1; fi;
   DayВ=Dat(c, Mon(dayКон), Year(dayКон));
   JDв=JulianDays(DayВ);
   c=JDк-JDв;
   if c>=0:
     откл=0;
     РД=c;
   else
     откл=1;
     c=ДнейМесяца(AddMon(dayКон,-1));
     РД=c-Д1+Д2;
   fi;
   if (М2-М1-откл)<0 :
     РГ=Г2-Г1-1; РМ=12-(Abs(М2-М1)+откл);
   else
     РГ=Г2-Г1; РМ=М2-М1-откл;
   fi;
   tmp1=Trim(НаписаниеИнтервала(Str(РГ)));
   if РМ>0: tmp2=Str(РМ)+" мес"; else tmp2=""; fi;
   if tmp1<>"" and tmp2<>"": strRes=tmp1+" "+tmp2; else strRes=tmp1+tmp2; fi;
 fi;
 ^strRes;
end;

Func ПоискДанных_ИщемДанные(avДатОпер	    :Date;
			    avЕстьБал	    :Logical;
			    avЕстьЗаб	    :Logical;
			    avMskACC101     :String;
			    avMskANA101     :String;
			    avUНФА101	    :Logical;
			    avUМОЛ101	    :Logical;
			    avUМХЭ101	    :Logical;
			    avUДОП101	    :Logical;
			    avUАНА101	    :Logical;
			VconstНФА100П	:Numeric;
			    VconstНФА_ИНВ   :Numeric
			    ) :Logical;
var СЧТБАЛ, СЧТАМТ, КОДНФА, КОДУЧН, refStrНФА, grpГРП, grpПГР, grpИМЯ, КОДОКФ, ОКФНМН :String;
var okData, Режим, Work, flgW1, flgW2, flgW3, flgW4 :Logical;
var SUM, KOL, Цена :Numeric;
var R2, R1, RO, len, xx, ii, pp, ppНФА, ppИНВ, SrokMes :Integer;
var ddve, ddpu, ddke, ddvv :Date;
var REC :Record;
 okData=False;
 Refresh(False);
 Режим=AutoRefresh;
 ToggleAutoRefresh(False);
 ShowProgress(0, "Подготовка данных...");
 R2=OpenWorkArea("РПО_ОКОФ", "КОД_ОКОФ", "");
 R1=OpenWorkArea("РПО_ИНВКАРТ_ОС", "", "");
 RO=OpenWorkArea("РПО_НФА", "", "");
 Try
   -- Служебная инфа
   TimeCreationRep="Время создания отчета: "+DateToString(ToDay)+" "+TimeToHMSstring_adv(Time, ":");
   СлужИнфоСЧТ="Отбор по счетам: "+Trim(avMskACC101);
   СлужИнфоАНА="Отбор по признакам: "+ИтогоФильтрАналитики;
   СлужИнфоГРП="Отбор по группам НФА: "+if(отчГРП<>"", nmsГРП, "нет");
   -- Очистка переменных
   ОчиститьВспомМассив;
   ОчиститьLST;
   count_arrНФА=0;
   -- **************** --
   -- * Отбор данных * --
   -- **************** --
   ПоискДанных_ИщемОстакиНФА101(avДатОпер, avЕстьБал, avЕстьЗаб, avMskACC101, avMskANA101, avUНФА101, avUМОЛ101, avUМХЭ101, AVUДОП101, avUАНА101, VconstНФА100П, VconstНФА_ИНВ);
   --
   len=LengthOfArray(LST_UNIQUE);
   if len>0:
     if count_arrНФА>0:
	ПозицииArrayНФА=count_arrНФА;
	CloseProgress;
	ShowProgress(1, "Сортировка промежуточных данных...");
	SortSection(ПозицииArrayНФА, "arr_REFНФА", True, False);
     fi;
     ShowProgress(len, "Расчет ведомости ОКОФ...");
     ОчиститьТаблицу;
     ОчиститьИтоги;
     ValidateОтчетSection;
     xx=0;
     -- ********************** --
     -- * Группировка данных * --
     -- ********************** --
     for ii=1 to len do
       ProgressPos(ii);
       SUM=LST_OSTСУМ[ii];
       KOL=LST_OSTКОЛ[ii];
       if SUM<>0.00 or KOL<>0.00:
	 -- Очитстка аналитики
	 КОДНФА=""; КОДУЧН=""; СЧТБАЛ=""; СЧТАМТ=""; refStrНФА=""; grpГРП=""; grpПГР=""; grpИМЯ=""; КОДОКФ=""; ОКФНМН="";
	 REC=NIL; flgW1=False; flgW2=False; flgW3=False; flgW4=False; ppНФА=0; ppИНВ=0; SrokMes=0; Цена=0.00;
	 --
	 СЧТБАЛ    = Trim(ExtractWord(1, LST_UNIQUE[ii], "#"));
	 refStrНФА = Trim(ExtractWord(2, LST_UNIQUE[ii], "#")); pp=SearchInArray(arr_REFНФА, refStrНФА, True, 1); if pp>0: КОДНФА=arr_КОДНФА[pp]; else КОДНФА=""; fi;
	 КОДУЧН    = Trim(ExtractWord(3, LST_UNIQUE[ii], "#")); if КОДУЧН=(pfxУЧН+".$$$"): КОДУЧН="не присвоен"; fi;
	 -- Пользовательская группировка НФА
	 if Name_A(КОДНФА)<>" ":
	   pp=0;
	   REC=SignToRecord(КОДНФА, False);
	   if REC<>NIL:
	     pp=GetRecordNumber(RO, REC);
	     if pp>0:
	       ppНФА=pp;
	       if отчГРП<>"":
		 grpГРП=КорректныеСимволыПризнака(Lo(Trim(GetFieldS(RO, pp, "ГРУППАВИД"))));
		 if grpГРП="": grpГРП="_без группировки"; fi;
		 grpПГР=КорректныеСимволыПризнака(Lo(Trim(GetFieldS(RO, pp, "ГРУППАКОД"))));
		 grpИМЯ=УдалитьРазделительЧерта(Lo(Trim(GetFieldS(RO, pp, "ГРУППАССЫЛКА"))));
		 if grpПГР=""  and grpИМЯ<>"": grpПГР=grpИМЯ;
		 |  grpПГР<>"" and grpИМЯ="" : grpИМЯ=grpПГР;
		 |  grpПГР=""  and grpИМЯ="" : grpПГР="_без группировки"; grpИМЯ=grpПГР;
		 fi;
	       fi;
	       КОДОКФ=Up(Trim(GetFieldS(RO, ppНФА, "ОКОФ")));
	     fi;
	   fi;
	 fi;
	 -- * Условия на выборку *
	 Work=False;
	 --1)
	 if ValidSign(КОДНФА) or КОДНФА="НФА.$$$": flgW1=True; else flgW1=False; fi;
	 --2)
	 flgW2=СоответствуетФильтруПоГруппеНФА(отчГРП, grpГРП, grpПГР);
	 --3)
	 if useЦеныЕЦ:
	   flgW3=False;
	   if KOL>0: Цена=Abs(SUM)/Abs(KOL); else Цена=0.00; fi;
	   if flgSgnЕЦ=1: if Цена <  БМЦеныЕЦ and Цена<>0.00: flgW3=True; fi; -- <
	   |  flgSgnЕЦ=2: if Цена <= БМЦеныЕЦ and Цена<>0.00: flgW3=True; fi; -- <=
	   |  flgSgnЕЦ=3: if Цена >  БМЦеныЕЦ and Цена<>0.00: flgW3=True; fi; -- >
	   |  flgSgnЕЦ=4: if Цена >= БМЦеныЕЦ and Цена<>0.00: flgW3=True; fi; -- >=
	   |  flgSgnЕЦ=5: if Цена =  БМЦеныЕЦ and Цена<>0.00: flgW3=True; fi; -- =
	   |  flgSgnЕЦ=6: if Цена <> БМЦеныЕЦ and Цена<>0.00: flgW3=True; fi; -- <>
	   fi;
	 else
	   Цена=0.00;
	   flgW3=True;
	 fi;
	 --4)
	 if flgВдБезОКОФ: flgW4=True; else if КОДОКФ="": flgW4=False; else flgW4=True; fi; fi;
	 -- X) суммируем
	 if flgW1 and flgW2 and flgW3 and flgW4: Work=True ;else Work=False; fi;
	 -- Собственно выборка
	 if Work:
	   xx=xx+1;
	   2тSRTFLD0[xx]=if(Match(КОДОКФ, "??.???????"), КОДОКФ, "zz.zzzzzzz")+"#"+КОДНФА;
	   if Match(КОДОКФ, "??.???????"):
	     pp=Search(R2, 1, КОДОКФ);
	     if pp>0: ОКФНМН=GetFieldS(R2, pp, "ИМЯ_ОКОФ1"); fi;
	     2тНФАОКФ0[xx]=КОДОКФ;
	     2тОКФНМН0[xx]=ОКФНМН;
	   else
	     2тНФАОКФ0[xx]="не присвоен";
	     2тОКФНМН0[xx]="не присвоен";
	   fi;
	   2тНФАКОД0[xx]=КОДНФА;
	   2тНФАИМЯ0[xx]=LST_ИМЯНФА[ii];
	   2тНФАЕДИ0[xx]=Lo(Unit(КОДНФА));
	   2тНФАУЧН0[xx]=Lo(КОДУЧН);
	   2тНФАИНВ0[xx]=Lo(LST_ИМЯИНВ[ii]);
	   2тНФАИСТ0[xx]=LST_КОДИСТ[ii];
	   2тНФАКБК0[xx]=LST_КОДКБК[ii];
	   2тНФАСЧ60[xx]=LST_КОДСЧ6[ii];
	   if Name_A(КОДНФА)<>" " and Name_A(КОДУЧН)<>" ":
	     REC=SignToRecord("ИНВВЕД."+КОДНФА+"."+КОДУЧН, False);
	     if REC<>NIL: ppИНВ=GetRecordNumber(R1, REC); fi;
	     СЧТАМТ = СчетАмортизацииПоСчетуНФА(СЧТБАЛ);
	     if Name_S(СЧТАМТ)<>" ": 2тСУМАМТ0[xx]=Round(Abs(Saldo(СЧТАМТ+"{"+КОДНФА+"&"+КОДУЧН+"}", avДатОпер)), 2); else 2тСУМАМТ0[xx]=0.00; fi;
	     ddpu=ВзятьДатуПринятияУчету_П(R1, ppИНВ, flgСложнДаты, КОДНФА, КОДУЧН, СЧТБАЛ, avДатОпер);
	     ddve=ВзятьДатуВводаЭксплуат_П(R1, ppИНВ, flgСложнДаты, КОДНФА, КОДУЧН, СЧТБАЛ, LST_КОДМХЭ[ii], avДатОпер, VconstНФА100П);
	     if ddpu>1.1.1800: 2тДАТПРН0[xx]=ddpu; fi;
	     if ddve>1.1.1800: 2тДАТЭКС0[xx]=ddve; fi;
	     SrokMes=ВзятьСрокЭксплуатМес(ddpu, R1, ppИНВ, RO, ppНФА);
	     if SrokMes>0:
	       --тМЕСНРМ[xx]=Str(100/SrokMes, 2)+" %";
	       ddke=ВзятьДатуКонцаЭксплуат_П(ddve, SrokMes);
	       if ddke>1.1.1800:
		 if Mon(avДатОпер-1)<12: ddvv=Dat(1, Mon(avДатОпер-1)+1, Year(avДатОпер-1)); else ddvv=Dat(1, 1, Year(avДатОпер-1)+1); fi;
		 2тСРКПЛЗ0[xx]=СрокЭксплуатацииПрописью(ddve, ddke);
		 2тСРКФКТ0[xx]=СрокЭксплуатацииПрописью(ddve, ddvv);
	       fi;
	     fi;
	     if ppНФА>0: 2тНФАОКФ0[xx]=Trim(GetFieldS(RO, ppНФА, "ОКОФ")); fi;
	   fi; -- if Name_A(КОДНФА)<>" " and Name_A(КОДУЧН)<>" "
	   2тКОЛНФА0[xx]=KOL;
	   2тСУМБАЛ0[xx]=SUM;
	   if LST_НЕТУЧН[ii]: 2тСУМОСТ0[xx]=0.00; else 2тСУМОСТ0[xx]=тСУМБАЛ[xx]-тСУМАМТ[xx]; fi;
	 fi; --Work=True - проводка отобрана
       fi; --SUM<>0.00 or KOL<>0.00
     od;
   else
     Message("По заданнам условиям отбора^Mданных для выборки не обнаружено!", mtInformation);
     ^False;
   fi;
   len=LengthOfArray(тSRTFLD);
   if len>0:
     okData=True;
   else
     Message("По заданнам условиям отбора^Mненулевых остатков не обнаружено!", mtError);
     okData=False;
   fi;
 Finally
   CloseWorkArea(RO);
   CloseWorkArea(R1);
   CloseWorkArea(R2);
   CloseProgress;
   ToggleAutoRefresh(Режим);
 end;
 ^okData;
end;

Proc ЗаключительныеИтогиТаблицаN1(r_SUM:Numeric; r_AMT:Numeric; r_OST:Numeric; vКОДСЧТ:String; vКОДИСТ:String);
var jj, xx :Integer;
 jj=SearchInArray(иСЧТСкод, vКОДСЧТ, True, 1);
 if jj>0: -- накапливаем результат итогов
   xx=jj;
   if vКОДИСТ="З":
      -- ЗАБАЛАНС
      иСЧТСзаб[xx] = иСЧТСзаб[xx]+r_SUM;					    иСЧТСвсг[xx]=иСЧТСбалИ[xx]+иСЧТСзаб[xx];
   |  vКОДИСТ="1":
      -- БЮДЖЕТ
      иСЧТСбалБ[xx]=иСЧТСбалБ[xx]+r_SUM; иСЧТСбалИ[xx]=иСЧТСбалБ[xx]+иСЧТСбалВ[xx]; иСЧТСвсг[xx]=иСЧТСбалИ[xx]+иСЧТСзаб[xx];
      иСЧТСамтБ[xx]=иСЧТСамтБ[xx]+r_AMT; иСЧТСамтИ[xx]=иСЧТСамтБ[xx]+иСЧТСамтВ[xx];
      иСЧТСостБ[xx]=иСЧТСостБ[xx]+r_OST; иСЧТСостИ[xx]=иСЧТСостБ[xx]+иСЧТСостВ[xx];
   else
      -- ВНЕБЮДЖЕТ
      иСЧТСбалВ[xx]=иСЧТСбалВ[xx]+r_SUM; иСЧТСбалИ[xx]=иСЧТСбалБ[xx]+иСЧТСбалВ[xx]; иСЧТСвсг[xx]=иСЧТСбалИ[xx]+иСЧТСзаб[xx];
      иСЧТСамтВ[xx]=иСЧТСамтВ[xx]+r_AMT; иСЧТСамтИ[xx]=иСЧТСамтБ[xx]+иСЧТСамтВ[xx];
      иСЧТСостВ[xx]=иСЧТСостВ[xx]+r_OST; иСЧТСостИ[xx]=иСЧТСостБ[xx]+иСЧТСостВ[xx];
   fi; --vКОДИСТ
 else -- новый элемент итогов
   xx=InsertInArraySort(иСЧТСкод, vКОДСЧТ);
   if vКОДИСТ="З":
       -- ЗАБАЛАНС
      InsertInArray(иСЧТСбалБ, xx, 0.00); InsertInArray(иСЧТСбалВ, xx, 0.00); InsertInArray(иСЧТСбалИ, xx, 0.00); InsertInArray(иСЧТСзаб, xx, r_SUM);
      InsertInArray(иСЧТСамтБ, xx, 0.00); InsertInArray(иСЧТСамтВ, xx, 0.00); InsertInArray(иСЧТСамтИ, xx, 0.00); InsertInArray(иСЧТСвсг, xx, r_SUM);
      InsertInArray(иСЧТСостБ, xx, 0.00); InsertInArray(иСЧТСостВ, xx, 0.00); InsertInArray(иСЧТСостИ, xx, 0.00);
   |  vКОДИСТ="1":
      -- БЮДЖЕТ
      InsertInArray(иСЧТСбалБ, xx, r_SUM); InsertInArray(иСЧТСбалВ, xx, 0.00); InsertInArray(иСЧТСбалИ, xx, r_SUM); InsertInArray(иСЧТСзаб, xx, 0.00);
      InsertInArray(иСЧТСамтБ, xx, r_AMT); InsertInArray(иСЧТСамтВ, xx, 0.00); InsertInArray(иСЧТСамтИ, xx, r_AMT); InsertInArray(иСЧТСвсг, xx, r_SUM);
      InsertInArray(иСЧТСостБ, xx, r_OST); InsertInArray(иСЧТСостВ, xx, 0.00); InsertInArray(иСЧТСостИ, xx, r_OST);
      --
   else
      -- ВНЕБЮДЖЕТ
      InsertInArray(иСЧТСбалБ, xx, 0.00); InsertInArray(иСЧТСбалВ, xx, r_SUM); InsertInArray(иСЧТСбалИ, xx, r_SUM); InsertInArray(иСЧТСзаб, xx, 0.00);
      InsertInArray(иСЧТСамтБ, xx, 0.00); InsertInArray(иСЧТСамтВ, xx, r_AMT); InsertInArray(иСЧТСамтИ, xx, r_AMT); InsertInArray(иСЧТСвсг, xx, r_SUM);
      InsertInArray(иСЧТСостБ, xx, 0.00); InsertInArray(иСЧТСостВ, xx, r_OST); InsertInArray(иСЧТСостИ, xx, r_OST);
      --
   fi; --vКОДИСТ
 fi; --jj>0
end;

Proc ЗаключительныеИтогиТаблицаN2(r_SUM:Numeric; r_AMT:Numeric; r_OST:Numeric; vКОДСЧТ:String; vКОДИСТ:String; vКОДКБК:String);
var jj, xx :Integer;
var Value :String;
 Value=vКОДКБК+"."+vКОДИСТ+"."+vКОДСЧТ+".???";
 if vКОДИСТ<>"З" and Match(Value, "???.????.???????.???.?.???.??.???"):
   jj=SearchInArray(иСЧТБкод, Value, True, 1);
   if jj>0: -- накапливаем результат итогов
     xx=jj;
     if vКОДИСТ="1":
       иСЧТБбалБ[xx]=иСЧТБбалБ[xx]+r_SUM; иСЧТБбалИ[xx]=иСЧТБбалБ[xx]+иСЧТБбалВ[xx];
       иСЧТБамтБ[xx]=иСЧТБамтБ[xx]+r_AMT; иСЧТБамтИ[xx]=иСЧТБамтБ[xx]+иСЧТБамтВ[xx];
       иСЧТБостБ[xx]=иСЧТБостБ[xx]+r_OST; иСЧТБостИ[xx]=иСЧТБостБ[xx]+иСЧТБостВ[xx];
     else
       иСЧТБбалВ[xx]=иСЧТБбалВ[xx]+r_SUM; иСЧТБбалИ[xx]=иСЧТБбалБ[xx]+иСЧТБбалВ[xx];
       иСЧТБамтВ[xx]=иСЧТБамтВ[xx]+r_AMT; иСЧТБамтИ[xx]=иСЧТБамтБ[xx]+иСЧТБамтВ[xx];
       иСЧТБостВ[xx]=иСЧТБостВ[xx]+r_OST; иСЧТБостИ[xx]=иСЧТБостБ[xx]+иСЧТБостВ[xx];
     fi;
   else -- новый элемент итогов
     xx=InsertInarraySort(иСЧТБкод, Value);
     if vКОДИСТ="1":
       InsertInArray(иСЧТБбалБ, xx, r_SUM); InsertInArray(иСЧТБбалВ, xx, 0.00);  InsertInArray(иСЧТБбалИ, xx, r_SUM);
       InsertInArray(иСЧТБамтБ, xx, r_AMT); InsertInArray(иСЧТБамтВ, xx, 0.00);  InsertInArray(иСЧТБамтИ, xx, r_AMT);
       InsertInArray(иСЧТБостБ, xx, r_OST); InsertInArray(иСЧТБостВ, xx, 0.00);  InsertInArray(иСЧТБостИ, xx, r_OST);
     else
       InsertInArray(иСЧТБбалБ, xx, 0.00);  InsertInArray(иСЧТБбалВ, xx, r_SUM); InsertInArray(иСЧТБбалИ, xx, r_SUM);
       InsertInArray(иСЧТБамтБ, xx, 0.00);  InsertInArray(иСЧТБамтВ, xx, r_AMT); InsertInArray(иСЧТБамтИ, xx, r_AMT);
       InsertInArray(иСЧТБостБ, xx, 0.00);  InsertInArray(иСЧТБостВ, xx, r_OST); InsertInArray(иСЧТБостИ, xx, r_OST);
     fi;
   fi;
 fi;
end;

Proc ЗаключительныеИтогиТаблицаN3(r_SUM:Numeric; r_AMT:Numeric; r_OST:Numeric; vКОДИСТ:String; vКОДКБК:String);
var jj, xx :Integer;
var Value :String;
 Value=vКОДКБК;
 if Match(Value, "???.????.???????.???"):
   jj=SearchInArray(иФКРБкод, Value, True, 1);
   if jj>0: -- накапливаем результат итогов
     xx=jj;
     if vКОДИСТ="1":
       иСЧТФбалБ[xx]=иСЧТФбалБ[xx]+r_SUM; иСЧТФбалИ[xx]=иСЧТФбалБ[xx]+иСЧТФбалВ[xx];
       иСЧТФамтБ[xx]=иСЧТФамтБ[xx]+r_AMT; иСЧТФамтИ[xx]=иСЧТФамтБ[xx]+иСЧТФамтВ[xx];
       иСЧТФостБ[xx]=иСЧТФостБ[xx]+r_OST; иСЧТФостИ[xx]=иСЧТФостБ[xx]+иСЧТФостВ[xx];
     else
       иСЧТФбалВ[xx]=иСЧТФбалВ[xx]+r_SUM; иСЧТФбалИ[xx]=иСЧТФбалБ[xx]+иСЧТФбалВ[xx];
       иСЧТФамтВ[xx]=иСЧТФамтВ[xx]+r_AMT; иСЧТФамтИ[xx]=иСЧТФамтБ[xx]+иСЧТФамтВ[xx];
       иСЧТФостВ[xx]=иСЧТФостВ[xx]+r_OST; иСЧТФостИ[xx]=иСЧТФостБ[xx]+иСЧТФостВ[xx];
     fi;
   else -- новый элемент итогов
     xx=InsertInarraySort(иФКРБкод, Value);
     if vКОДИСТ="1":
       InsertInArray(иСЧТФбалБ, xx, r_SUM); InsertInArray(иСЧТФбалВ, xx, 0.00);  InsertInArray(иСЧТФбалИ, xx, r_SUM);
       InsertInArray(иСЧТФамтБ, xx, r_AMT); InsertInArray(иСЧТФамтВ, xx, 0.00);  InsertInArray(иСЧТФамтИ, xx, r_AMT);
       InsertInArray(иСЧТФостБ, xx, r_OST); InsertInArray(иСЧТФостВ, xx, 0.00);  InsertInArray(иСЧТФостИ, xx, r_OST);
     else
       InsertInArray(иСЧТФбалБ, xx, 0.00);  InsertInArray(иСЧТФбалВ, xx, r_SUM); InsertInArray(иСЧТФбалИ, xx, r_SUM);
       InsertInArray(иСЧТФамтБ, xx, 0.00);  InsertInArray(иСЧТФамтВ, xx, r_AMT); InsertInArray(иСЧТФамтИ, xx, r_AMT);
       InsertInArray(иСЧТФостБ, xx, 0.00);  InsertInArray(иСЧТФостВ, xx, r_OST); InsertInArray(иСЧТФостИ, xx, r_OST);
     fi;
   fi;
 fi;
end;

Proc ЗаключительныеИтогиТаблицаN4(r_SUM:Numeric; r_AMT:Numeric; r_OST:Numeric; r_KOL:Numeric; vКОДИСТ:String; vКОДОКФ:String; vНМНОКФ:String; RefToRO:Integer);
var KEY1, KEY2, грп, элм, Value :String;
var jj, xx, num :Integer;
 if Match(vКОДОКФ, "??.???????"): элм=vКОДОКФ; else элм="zz.zzzzzzz"; fi; -- "не присвоен"
 грп=SubStr(элм, 1, 2);
 KEY1=грп+"# ";
 KEY2=грп+"#"+элм;
 if flgНмГрпОКОФ:
   if Up(WorkAreaCardFile(RefToRO))="РПО_ОКОФ" and грп<>"zz": Value=грп+".0000000"; num=Search(RefToRO, 1, Value); else num=0; fi;
   Value="";
   if num>0: Value=Up(GetFieldS(RefToRO, num, "ИМЯ_ОКОФ1")); else Value=""; fi;
 fi;
 -- KEY1
 jj=SearchInArray(иОКОФ_key, KEY1, True, 1);
 if jj>0: -- накапливаем результат итогов
   xx=jj;
   if vКОДИСТ="З": иОКОФколЗ[xx]=иОКОФколЗ[xx]+r_KOL; иОКОФбалЗ[xx]=иОКОФбалЗ[xx]+r_SUM; иОКОФамтЗ[xx]=иОКОФамтЗ[xx]+r_AMT; иОКОФостЗ[xx]=иОКОФостЗ[xx]+r_OST;
   |  vКОДИСТ="1": иОКОФкол1[xx]=иОКОФкол1[xx]+r_KOL; иОКОФбал1[xx]=иОКОФбал1[xx]+r_SUM; иОКОФамт1[xx]=иОКОФамт1[xx]+r_AMT; иОКОФост1[xx]=иОКОФост1[xx]+r_OST;
   |  vКОДИСТ="2": иОКОФкол2[xx]=иОКОФкол2[xx]+r_KOL; иОКОФбал2[xx]=иОКОФбал2[xx]+r_SUM; иОКОФамт2[xx]=иОКОФамт2[xx]+r_AMT; иОКОФост2[xx]=иОКОФост2[xx]+r_OST;
   |  vКОДИСТ="4": иОКОФкол4[xx]=иОКОФкол4[xx]+r_KOL; иОКОФбал4[xx]=иОКОФбал4[xx]+r_SUM; иОКОФамт4[xx]=иОКОФамт4[xx]+r_AMT; иОКОФост4[xx]=иОКОФост4[xx]+r_OST;
   |  vКОДИСТ="5": иОКОФкол5[xx]=иОКОФкол5[xx]+r_KOL; иОКОФбал5[xx]=иОКОФбал5[xx]+r_SUM; иОКОФамт5[xx]=иОКОФамт5[xx]+r_AMT; иОКОФост5[xx]=иОКОФост5[xx]+r_OST;
   |  vКОДИСТ="7": иОКОФкол7[xx]=иОКОФкол7[xx]+r_KOL; иОКОФбал7[xx]=иОКОФбал7[xx]+r_SUM; иОКОФамт7[xx]=иОКОФамт7[xx]+r_AMT; иОКОФост7[xx]=иОКОФост7[xx]+r_OST;
   else 	   иОКОФколП[xx]=иОКОФколП[xx]+r_KOL; иОКОФбалП[xx]=иОКОФбалП[xx]+r_SUM; иОКОФамтП[xx]=иОКОФамтП[xx]+r_AMT; иОКОФостП[xx]=иОКОФостП[xx]+r_OST;
   fi;
 else
   xx=InsertInArraySort(иОКОФ_key, KEY1);
   InsertInArray(иОКОФ_грп, xx, грп);
   InsertInArray(иОКОФ_элм, xx, "");
   InsertInArray(иОКОФ_нмн, xx, if(flgНмГрпОКОФ, Value, ""));
   if vКОДИСТ="З": InsertInArray(иОКОФколЗ, xx, r_KOL); InsertInArray(иОКОФбалЗ, xx, r_SUM); InsertInArray(иОКОФамтЗ, xx, r_AMT); InsertInArray(иОКОФостЗ, xx, r_OST);
   |  vКОДИСТ="1": InsertInArray(иОКОФкол1, xx, r_KOL); InsertInArray(иОКОФбал1, xx, r_SUM); InsertInArray(иОКОФамт1, xx, r_AMT); InsertInArray(иОКОФост1, xx, r_OST);
   |  vКОДИСТ="2": InsertInArray(иОКОФкол2, xx, r_KOL); InsertInArray(иОКОФбал2, xx, r_SUM); InsertInArray(иОКОФамт2, xx, r_AMT); InsertInArray(иОКОФост2, xx, r_OST);
   |  vКОДИСТ="4": InsertInArray(иОКОФкол4, xx, r_KOL); InsertInArray(иОКОФбал4, xx, r_SUM); InsertInArray(иОКОФамт4, xx, r_AMT); InsertInArray(иОКОФост4, xx, r_OST);
   |  vКОДИСТ="5": InsertInArray(иОКОФкол5, xx, r_KOL); InsertInArray(иОКОФбал5, xx, r_SUM); InsertInArray(иОКОФамт5, xx, r_AMT); InsertInArray(иОКОФост5, xx, r_OST);
   |  vКОДИСТ="7": InsertInArray(иОКОФкол7, xx, r_KOL); InsertInArray(иОКОФбал7, xx, r_SUM); InsertInArray(иОКОФамт7, xx, r_AMT); InsertInArray(иОКОФост7, xx, r_OST);
   else 	   InsertInArray(иОКОФколП, xx, r_KOL); InsertInArray(иОКОФбалП, xx, r_SUM); InsertInArray(иОКОФамтП, xx, r_AMT); InsertInArray(иОКОФостП, xx, r_OST);
   fi;
 fi;
 -- KEY2
 jj=SearchInArray(иОКОФ_key, KEY2, True, 1);
 if jj>0: -- накапливаем результат итогов
   xx=jj;
   if vКОДИСТ="З": иОКОФколЗ[xx]=иОКОФколЗ[xx]+r_KOL; иОКОФбалЗ[xx]=иОКОФбалЗ[xx]+r_SUM; иОКОФамтЗ[xx]=иОКОФамтЗ[xx]+r_AMT; иОКОФостЗ[xx]=иОКОФостЗ[xx]+r_OST;
   |  vКОДИСТ="1": иОКОФкол1[xx]=иОКОФкол1[xx]+r_KOL; иОКОФбал1[xx]=иОКОФбал1[xx]+r_SUM; иОКОФамт1[xx]=иОКОФамт1[xx]+r_AMT; иОКОФост1[xx]=иОКОФост1[xx]+r_OST;
   |  vКОДИСТ="2": иОКОФкол2[xx]=иОКОФкол2[xx]+r_KOL; иОКОФбал2[xx]=иОКОФбал2[xx]+r_SUM; иОКОФамт2[xx]=иОКОФамт2[xx]+r_AMT; иОКОФост2[xx]=иОКОФост2[xx]+r_OST;
   |  vКОДИСТ="4": иОКОФкол4[xx]=иОКОФкол4[xx]+r_KOL; иОКОФбал4[xx]=иОКОФбал4[xx]+r_SUM; иОКОФамт4[xx]=иОКОФамт4[xx]+r_AMT; иОКОФост4[xx]=иОКОФост4[xx]+r_OST;
   |  vКОДИСТ="5": иОКОФкол5[xx]=иОКОФкол5[xx]+r_KOL; иОКОФбал5[xx]=иОКОФбал5[xx]+r_SUM; иОКОФамт5[xx]=иОКОФамт5[xx]+r_AMT; иОКОФост5[xx]=иОКОФост5[xx]+r_OST;
   |  vКОДИСТ="7": иОКОФкол7[xx]=иОКОФкол7[xx]+r_KOL; иОКОФбал7[xx]=иОКОФбал7[xx]+r_SUM; иОКОФамт7[xx]=иОКОФамт7[xx]+r_AMT; иОКОФост7[xx]=иОКОФост7[xx]+r_OST;
   else 	   иОКОФколП[xx]=иОКОФколП[xx]+r_KOL; иОКОФбалП[xx]=иОКОФбалП[xx]+r_SUM; иОКОФамтП[xx]=иОКОФамтП[xx]+r_AMT; иОКОФостП[xx]=иОКОФостП[xx]+r_OST;
   fi;
 else
   xx=InsertInArraySort(иОКОФ_key, KEY2);
   InsertInArray(иОКОФ_грп, xx, "");
   InsertInArray(иОКОФ_элм, xx, элм);
   InsertInArray(иОКОФ_нмн, xx, vНМНОКФ);
   if vКОДИСТ="З": InsertInArray(иОКОФколЗ, xx, r_KOL); InsertInArray(иОКОФбалЗ, xx, r_SUM); InsertInArray(иОКОФамтЗ, xx, r_AMT); InsertInArray(иОКОФостЗ, xx, r_OST);
   |  vКОДИСТ="1": InsertInArray(иОКОФкол1, xx, r_KOL); InsertInArray(иОКОФбал1, xx, r_SUM); InsertInArray(иОКОФамт1, xx, r_AMT); InsertInArray(иОКОФост1, xx, r_OST);
   |  vКОДИСТ="2": InsertInArray(иОКОФкол2, xx, r_KOL); InsertInArray(иОКОФбал2, xx, r_SUM); InsertInArray(иОКОФамт2, xx, r_AMT); InsertInArray(иОКОФост2, xx, r_OST);
   |  vКОДИСТ="4": InsertInArray(иОКОФкол4, xx, r_KOL); InsertInArray(иОКОФбал4, xx, r_SUM); InsertInArray(иОКОФамт4, xx, r_AMT); InsertInArray(иОКОФост4, xx, r_OST);
   |  vКОДИСТ="5": InsertInArray(иОКОФкол5, xx, r_KOL); InsertInArray(иОКОФбал5, xx, r_SUM); InsertInArray(иОКОФамт5, xx, r_AMT); InsertInArray(иОКОФост5, xx, r_OST);
   |  vКОДИСТ="7": InsertInArray(иОКОФкол7, xx, r_KOL); InsertInArray(иОКОФбал7, xx, r_SUM); InsertInArray(иОКОФамт7, xx, r_AMT); InsertInArray(иОКОФост7, xx, r_OST);
   else 	   InsertInArray(иОКОФколП, xx, r_KOL); InsertInArray(иОКОФбалП, xx, r_SUM); InsertInArray(иОКОФамтП, xx, r_AMT); InsertInArray(иОКОФостП, xx, r_OST);
   fi;
 fi;
end;

Proc ПостроениеОтчета;
var SUMKOL, SUMBAL, SUMAMT, SUMOST :Numeric;
var КОДКБК, КОДИСТ, КОДСЧТ :String;
var RO, len, ii :Integer;
var Режим :Logical;

 len=LengthOfArray(тSRTFLD);
 if len>0:
   Позиции=len;
   ShowProgress(len, "Сортировка данных...");
   Try
     SortSection("СекцWorkTabl", "тSRTFLD", True, False);
   Finally
     CloseProgress;
   end;
   Режим=AutoRefresh;
   ToggleAutoRefresh(False);
   ShowProgress(len, "Формирование ведомости ОКОФ...");
   RO=OpenWorkArea("РПО_ОКОФ", "КОД_ОКОФ", "Match(КОД_ОКОФ, '??.0000000')");
   Try
     ValidateВедомостьSection(True);
     ValidateИтогиSection(True);
     for ii=1 to len do
       ProgressPos(ii);
       SUMKOL=тКОЛНФА[ii];
       SUMBAL=тСУМБАЛ[ii];
       SUMAMT=тСУМАМТ[ii];
       SUMOST=тСУМОСТ[ii];
       КОДКБК=тНФАКБК[ii]; -- ???.????.???????.???  len=20
       КОДИСТ=тНФАИСТ[ii]; -- ? 		    len=01 - 1, 2, З
       КОДСЧТ=тНФАСЧ6[ii]; -- ???.??		    len=06
       -- Заключительные итоги - таблица N1
       ЗаключительныеИтогиТаблицаN1(SUMBAL, SUMAMT, SUMOST, КОДСЧТ, КОДИСТ);
       -- Заключительные итоги - таблица N2
       ЗаключительныеИтогиТаблицаN2(SUMBAL, SUMAMT, SUMOST, КОДСЧТ, КОДИСТ, КОДКБК);
       -- Заключительные итоги - таблица N3
       ЗаключительныеИтогиТаблицаN3(SUMBAL, SUMAMT, SUMOST, КОДИСТ, КОДКБК);
       -- Заключительные итоги - таблица N4
       ЗаключительныеИтогиТаблицаN4(SUMBAL, SUMAMT, SUMOST, SUMKOL, КОДИСТ, тНФАОКФ[ii], тОКФНМН[ii], RO);
       --
       if КОДИСТ="З": вОКОФколЗ=вОКОФколЗ+SUMKOL; вОКОФбалЗ=вОКОФбалЗ+SUMBAL; вОКОФамтЗ=вОКОФамтЗ+SUMAMT; вОКОФостЗ=вОКОФостЗ+SUMOST;
       |  КОДИСТ="1": вОКОФкол1=вОКОФкол1+SUMKOL; вОКОФбал1=вОКОФбал1+SUMBAL; вОКОФамт1=вОКОФамт1+SUMAMT; вОКОФост1=вОКОФост1+SUMOST;
       |  КОДИСТ="2": вОКОФкол2=вОКОФкол2+SUMKOL; вОКОФбал2=вОКОФбал2+SUMBAL; вОКОФамт2=вОКОФамт2+SUMAMT; вОКОФост2=вОКОФост2+SUMOST;
       |  КОДИСТ="4": вОКОФкол4=вОКОФкол4+SUMKOL; вОКОФбал4=вОКОФбал4+SUMBAL; вОКОФамт4=вОКОФамт4+SUMAMT; вОКОФост4=вОКОФост4+SUMOST;
       |  КОДИСТ="5": вОКОФкол5=вОКОФкол5+SUMKOL; вОКОФбал5=вОКОФбал5+SUMBAL; вОКОФамт5=вОКОФамт5+SUMAMT; вОКОФост5=вОКОФост5+SUMOST;
       |  КОДИСТ="7": вОКОФкол7=вОКОФкол7+SUMKOL; вОКОФбал7=вОКОФбал7+SUMBAL; вОКОФамт7=вОКОФамт7+SUMAMT; вОКОФост7=вОКОФост7+SUMOST;
       else	      вОКОФколП=вОКОФколП+SUMKOL; вОКОФбалП=вОКОФбалП+SUMBAL; вОКОФамтП=вОКОФамтП+SUMAMT; вОКОФостП=вОКОФостП+SUMOST;
       fi;
     od;
     -- Итоги по колонкам в 'итоговых таблицах'
     СтрокиТ1 = LengthOfArray(иСЧТСкод);
     СтрокиТ2 = LengthOfArray(иСЧТБкод);
     СтрокиТ3 = LengthOfArray(иФКРБкод);
     СтрокиТ4 = LengthOfArray(иОКОФ_key);
     -- таблица N1
     вСЧТСбалБ=SumOfArray(иСЧТСбалБ, СтрокиТ1); вСЧТСбалВ=SumOfArray(иСЧТСбалВ, СтрокиТ1); вСЧТСбалИ=SumOfArray(иСЧТСбалИ, СтрокиТ1); вСЧТСзаб=SumOfArray(иСЧТСзаб, СтрокиТ1);
     вСЧТСамтБ=SumOfArray(иСЧТСамтБ, СтрокиТ1); вСЧТСамтВ=SumOfArray(иСЧТСамтВ, СтрокиТ1); вСЧТСамтИ=SumOfArray(иСЧТСамтИ, СтрокиТ1); вСЧТСвсг=SumOfArray(иСЧТСвсг, СтрокиТ1);
     вСЧТСостБ=SumOfArray(иСЧТСостБ, СтрокиТ1); вСЧТСостВ=SumOfArray(иСЧТСостВ, СтрокиТ1); вСЧТСостИ=SumOfArray(иСЧТСостИ, СтрокиТ1);
     -- таблица N2
     вСЧТБбалБ=SumOfArray(иСЧТБбалБ, СтрокиТ2); вСЧТБбалВ=SumOfArray(иСЧТБбалВ, СтрокиТ2); вСЧТБбалИ=SumOfArray(иСЧТБбалИ, СтрокиТ2);
     вСЧТБамтБ=SumOfArray(иСЧТБамтБ, СтрокиТ2); вСЧТБамтВ=SumOfArray(иСЧТБамтВ, СтрокиТ2); вСЧТБамтИ=SumOfArray(иСЧТБамтИ, СтрокиТ2);
     вСЧТБостБ=SumOfArray(иСЧТБостБ, СтрокиТ2); вСЧТБостВ=SumOfArray(иСЧТБостВ, СтрокиТ2); вСЧТБостИ=SumOfArray(иСЧТБостИ, СтрокиТ2);
     -- таблица N3
     вСЧТФбалБ=SumOfArray(иСЧТФбалБ, СтрокиТ3); вСЧТФбалВ=SumOfArray(иСЧТФбалВ, СтрокиТ3); вСЧТФбалИ=SumOfArray(иСЧТФбалИ, СтрокиТ3);
     вСЧТФамтБ=SumOfArray(иСЧТФамтБ, СтрокиТ3); вСЧТФамтВ=SumOfArray(иСЧТФамтВ, СтрокиТ3); вСЧТФамтИ=SumOfArray(иСЧТФамтИ, СтрокиТ3);
     вСЧТФостБ=SumOfArray(иСЧТФостБ, СтрокиТ3); вСЧТФостВ=SumOfArray(иСЧТФостВ, СтрокиТ3); вСЧТФостИ=SumOfArray(иСЧТФостИ, СтрокиТ3);
   Finally
     CloseWorkArea(RO);
     CloseProgress;
     ToggleAutoRefresh(Режим);
   end;
   Позиции=len;
 fi;
 --
 currКнопка=2;
 ValidateОтчетSection;
end;

Proc РасчетСпискаНФА;
var Work, ftrАНА101, ftrДОП101, ftrМОЛ101, ftrМХЭ101, ftrНФА101 :Logical;
var MaskAcc101, MaskAna101 :String;
var chislo, WorkConstНФА100П, WorkConstНФА_ИНВ :Numeric;
var начало, num :Integer;
 начало=Time;
 -- Проверка заполнения
 if not ПроверкаЗаполнения: Exit; fi;
 отчАНА=Trim(отчАНА);
 отчНФА=Trim(отчНФА);
 отчДОП=Trim(отчДОП);
 отчМОЛ=Trim(отчМОЛ);
 отчМХЭ=Trim(отчМХЭ);
 отчГРП=Trim(отчГРП);
 --
 MaskAcc101=""; MaskAna101=""; ftrАНА101=False; ftrДОП101=False; ftrМОЛ101=False; ftrМХЭ101=False; ftrНФА101=False;
 -- Константы НФА
 Try chislo=Com_Var("ОС_100"  , ДатОпер); Except chislo=0.00; end;
 if not chislo>0: if ДатОпер>=1.1.2011: chislo=40000; else chislo=20000; fi; fi;
 WorkConstНФА100П=chislo;
 Try chislo=Com_Var("ОС_РАСХ" , ДатОпер); Except chislo=0.00; end;
 if not chislo>0: if ДатОпер>=1.1.2009: chislo=3000;  else chislo=1000;  fi; fi;
 WorkConstНФА_ИНВ=chislo;
 --
 MaskAcc101=ИтоговаяМаскаСчета(currИст, отчСЧТ, отчКБК, if(currAcc=1 or currAcc=2, True, False), if(currAcc=1 or currAcc=3, True, False));
 Work=False;
 if Abs(Turn("+("+MaskAcc101+"){~НФА.*}", 1.1.100, ДатОпер+1))>0 or Abs(Turn("-("+MaskAcc101+"){~НФА.*}", 1.1.100, ДатОпер+1))>0:
    num=Enquiry("Выберите действие...", "Обнаружены проводки^Mна "+отчСЧТ+" счетах^Mнепомеченные справочником НФА!", "Проводки в отчет;Отмена;Игнорировать", mtError);
    if num=1:
      Report(PlanVar("НФА")+"\ОТЧЕТЫ\НФАОТЧ2007.lst"+"|Непомеченные_НФА", 1.1.100, ДатОпер+1, MaskAcc101, "~НФА.*");
      Exit;
    |  num=3: Work=True;
    else Exit;
    fi;
 fi;
 -- Анализ фильтров по аналитике для 101 счетов
 MaskAna101=АнализФильтраАналитики(MaskAcc101, Work);
 if MaskAna101=" ": Exit; fi;
 -- задаем маску аналитического отбора для свертки проводок;
 -- если условие не уместилось в строку, то для тех условий что не уместились, задаем флаги для последующего анализа
 ftrНФА101 = BufFlag[1];
 ftrМОЛ101 = BufFlag[2];
 ftrМХЭ101 = BufFlag[3];
 ftrДОП101 = BufFlag[4];
 ftrАНА101 = BufFlag[5];
 -- *****************
 -- * ОСНОВНОЙ БЛОК *
 -- *****************
 Work=False;
 -- Поиск данных
 Work=ПоискДанных_ИщемДанные(ДатОпер+1, if(currAcc=1 or currAcc=2, True, False), if(currAcc=1 or currAcc=3, True, False), MaskAcc101, MaskAna101, ftrНФА101, ftrМОЛ101, ftrМХЭ101, ftrДОП101, ftrАНА101, WorkConstНФА100П, WorkConstНФА_ИНВ);
 -- Построение отчета
 if Work:
   ПостроениеОтчета;
   if Позиции>0: Message("Расчет завершен!^MВремя работы - "+TimeToHMSstring_adv(Time-начало, ":"), mtInformation); fi;
 fi;
end;

--Proc ПечатьИтоговыхТаблиц(ПечИтгТаб1:Logical; ПечИтгТаб2:Logical; ПечИтгТаб3:Logical; ПечИтгТаб4:Logical; ПечИтгТаб5:Logical; ОтделТабл:Logical; сНовСтр:Logical);

--СекцТ1З.CanPrint = ПечИтгТаб1;
--СекцТ1Д.CanPrint = ПечИтгТаб1;
--СекцТ1И.CanPrint = ПечИтгТаб1;
--СекцТ1З.Row(1, RowNewPage, if(ОтделТабл or сНовСтр, True, False));

--СекцТ2З.CanPrint = ПечИтгТаб2;
--СекцТ2Д.CanPrint = ПечИтгТаб2;
--СекцТ2И.CanPrint = ПечИтгТаб2;
--СекцТ2З.Row(1, RowNewPage, сНовСтр);

--СекцТ3З.CanPrint = ПечИтгТаб3;
--СекцТ3Д.CanPrint = ПечИтгТаб3;
--СекцТ3И.CanPrint = ПечИтгТаб3;
--СекцТ3З.Row(1, RowNewPage, сНовСтр);

--СекцТ4З.CanPrint = ПечИтгТаб4;
--СекцТ4Д.CanPrint = ПечИтгТаб4;
--СекцТ4И.CanPrint = ПечИтгТаб4;
--СекцТ4З.Row(1, RowNewPage, сНовСтр);

--СекцТ5З.CanPrint = ПечИтгТаб5;
--СекцТ5Д.CanPrint = ПечИтгТаб5;
--СекцТ5И.CanPrint = ПечИтгТаб5;
--СекцТ5З.Row(1, RowNewPage, сНовСтр);

--end;

Proc ТаблицаНовойСтраницы(сНовСтр:Logical);
 СекцТ1З.Row(1, RowNewPage, сНовСтр);
 СекцТ2З.Row(1, RowNewPage, сНовСтр);
 СекцТ3З.Row(1, RowNewPage, сНовСтр);
end;

Proc ЗапомнитьЗначения;
 oldsИст   = currИст;
 oldsAcc   = currAcc;
 oldDate   = ДатОпер;
 oldЦена   = БМЦеныЕЦ;
 OldОтчАНА = ОтчАНА;
end;

Proc ВнешнийВид_ФтрПоСумме_ЦенЕдн(Разрешено:Logical);
 if not Разрешено: БМЦеныЕЦ=0; OldЦена=0; flgSgnЕЦ=0; fi;
 Секц_ЦенБМ.Row(2, RowVisible, Разрешено);
end;

Func ВыбратьФлагСравненияЦен(ТекущийФлаг:Integer) :Integer;
var num:Integer;
 ClearVariable(Buf);
 Buf[01]= "<"  ;
 Buf[02]= "<=" ;
 Buf[03]= ">"  ;
 Buf[04]= ">=" ;
 Buf[05]= "="  ;
 Buf[06]= "<>" ;
 num=Alternate("Выберите знак сравнения цен", Buf, -1, ТекущийФлаг, 12);
 if not num>0: ^ТекущийФлаг; else ^num; fi;
end;

Proc ЗнакСравненияЦен(FieldREF:String);
var OldValue, NewValue :Integer;
var SaveValue :Logical;
var FieldFLG :String;
 SaveValue=False; FieldFLG=SubStr(FieldREF, 1, Length(FieldREF)-1);
 OldValue=GetVariableI(FieldFLG);
 NewValue=ВыбратьФлагСравненияЦен(OldValue);
 if NewValue<>OldValue: if not ОтменитьИзмененияУсловийОтчета: SaveValue=True; fi; fi;
 if SaveValue:
   PutVariableI(FieldFLG, NewValue);
 fi;
end;

Proc ПрименяемФильтрЦен(FieldREF:String; onExit:Logical);
var OldValue, NewValue, SaveValue :Logical;
var FieldFLG :String;
 SaveValue=False;
 FieldFLG=SubStr(FieldREF, 1, Length(FieldREF)-1);
 Try OldValue=GetVariableL(FieldFLG); Except end;
 if onExit: NewValue=False; else NewValue = not OldValue; fi;
 if NewValue<>OldValue: if not ОтменитьИзмененияУсловийОтчета: SaveValue=True; fi; fi;
 if SaveValue:
   PutVariableL(FieldFLG, NewValue);
   ВнешнийВид_ФтрПоСумме_ЦенЕдн(NewValue);
 fi;
end;

Proc Инициализация;

 lblVersion.Caption=infoVersion;
 if not Позиции>0:
   if Trim(Иерархия)="":
     Иерархия="<МОЛ> <ГРП> <СЧТ>";
     отчСЧТ="101.?? 102.?0"; флагиACC="1111111110000000";
     отчКБК="";
     valКБК="";
     отчМОЛ=""; nmsМОЛ="";
     отчМХЭ=""; nmsМХЭ="";
     отчДОП=""; nmsДОП="";
     отчНФА=""; nmsНФА="";
     keyГРП=""; отчГРП=""; nmsГРП=""; LastGRP_key="{0}"; LastGRP_num=0;
     ОчиститьГРПНФА;
     ОтчАНА=""; OldОтчАНА="";
     intРежимСохр   = 1;
     intСхемаЦветов = 1;
     useЦеныЕЦ	    = False;
   fi;
   flgПечСлужИнф  = True;
   flgСлужИнф	  = True;
--   flgПечИтгТаб1  = True;
--   flgПечИтгТаб2  = True;
--   flgПечИтгТаб3  = True;
--   flgПечИтгТаб4  = True;
--   flgПечИтгТаб5  = True;
--   flgОтделТабл   = True;
   flgПечНовСтр   = False;
   flgТолькоИнв   = False;
   flgЧиститьАна  = True;
   flgСложнДаты   = False;
   flgВдБезОКОФ   = True;
 fi;
 --
 Счета_ВнешнийВид;
 ВнешнийВид_Забаланс(if(currAcc<>2, True, False));
 ВнешнийВид_ФильтрДопСпр; -- перечитывается также и порядок групп
 ВнешнийВид_ФтрПоСумме_ЦенЕдн(useЦеныЕЦ);
 --
 ЗапомнитьЗначения;
 --ПечатьИтоговыхТаблиц(flgПечИтгТаб1, flgПечИтгТаб2, flgПечИтгТаб3, flgПечИтгТаб4, flgПечИтгТаб5, flgОтделТабл, flgПечНовСтр);
 ТаблицаНовойСтраницы(flgПечНовСтр);
 ValidateSection(False, False);
 --
 ВзятьРеквизиты(УЧР_REC, True);
end;

Func Template_OnClear :Logical;
 if Trim(flgClear)="":
   Message("Ошибка!^MВероятно была произведена 'очистка полей'.^MБудет произведена инициализация значений по умолчанию.^MПосле этого бланк будет готов к работе!", mtError);
   ОчисткаОтчета;
   Инициализация;
   flgClear=GetGuid;
   Message("Бланк проинициализирован!", mtInformation);
   Template.Field="Фокус";
   ^True;
 fi;
 ^False;
end;

Proc ФиксироватьШапку(даФикс:Logical);
var xx, yy :Integer;
var OK :Logical;
 OK=False;
 if даФикс and Позиции>0:
   xx=asInteger(СекцWorkЗТ.Column(2, ColLeft, ""));
   yy=asInteger(СекцWorkЗТ.Row(4, RowTop, ""));
   if xx>0 and yy>0: OK=True; fi;
 fi;
 if OK: Template.Freeze(xx, yy); else Template.Freeze(0, 0); if даФикс: flgФиксТабл=False; fi; fi;
end;

Proc Экспорт_Excel;
 Message("В разработке!");
end;

2-- События клеток
Func Field_onEnter(Field:String; Iter:Integer): Logical; -- на входе в клетку
var Flag :Logical;
 if Template_OnClear: ^False; fi;
 Flag_onEnter=False;
 if Field="ДатОпер"	   : oldDate=ДатОпер;  Flag_onEnter=True; ^True;
 |  Field="ОтчАна"	   : OldОтчАНА=ОтчАНА; Flag_onEnter=True; ^True;
 |  Field="VOCКОД_"	   : ВыборДопСправочника(False); ^False;
 |  Field="отчСЧТ_"	   : Счета_ВыборВидаНФАonEnter(2); ^False; -- Применяются только ОС
 |  Field="отчКБК_"	   : КБК_ВыбратьФильтрКБК(False); ^False;
 |  Field="отчГРП_"	   : ГруппыНФА_ВыбратьФильтрГруппыНФА(False); ^False;
 |  Field="отчМОЛ_"	   : Аналитика_ВыбратьФильтрАналитики(Field, False); ^False;
 |  Field="отчМХЭ_"	   : Аналитика_ВыбратьФильтрАналитики(Field, False); ^False;
 |  Field="отчДОП_"	   : Аналитика_ВыбратьФильтрАналитики(Field, False); ^False;
 |  Field="отчНФА_"	   : Аналитика_ВыбратьФильтрАналитики(Field, False); ^False;
 |  Field="УЧР_ИМЯ"	   : ВзятьРеквизиты(УЧР_REC, False); ^False;
 |  Field="УЧР_ОКПО"	   : ВзятьРеквизиты(УЧР_REC, False); ^False;
 |  Field="ПОД_ИМЯ"	   : ПО_Выбор(ПОД_КОД); ^False;
 |  Field="ПОД_КОД"	   : ПО_Выбор(ПОД_КОД); ^False;
 |  Field="useЦеныЕЦ_"	   : ПрименяемФильтрЦен(Field, False); ^False;
 |  Field="flgSgnЕЦ_"	   : ЗнакСравненияЦен(Field); ^False;
 |  Field="БМЦеныЕЦ"	   : OldЦена=БМЦеныЕЦ; Flag_onEnter=True; ^True;
-- |  Field="flgПечИтгТаб1"  : flgПечИтгТаб1  = not flgПечИтгТаб1; ПечатьИтоговыхТаблиц(flgПечИтгТаб1, flgПечИтгТаб2, flgПечИтгТаб3, flgПечИтгТаб4, flgПечИтгТаб5, flgОтделТабл, flgПечНовСтр); ^False;
-- |  Field="flgПечИтгТаб2"  : flgПечИтгТаб2  = not flgПечИтгТаб2; ПечатьИтоговыхТаблиц(flgПечИтгТаб1, flgПечИтгТаб2, flgПечИтгТаб3, flgПечИтгТаб4, flgПечИтгТаб5, flgОтделТабл, flgПечНовСтр); ^False;
-- |  Field="flgПечИтгТаб3"  : flgПечИтгТаб3  = not flgПечИтгТаб3; ПечатьИтоговыхТаблиц(flgПечИтгТаб1, flgПечИтгТаб2, flgПечИтгТаб3, flgПечИтгТаб4, flgПечИтгТаб5, flgОтделТабл, flgПечНовСтр); ^False;
-- |  Field="flgПечИтгТаб4"  : flgПечИтгТаб4  = not flgПечИтгТаб4; ПечатьИтоговыхТаблиц(flgПечИтгТаб1, flgПечИтгТаб2, flgПечИтгТаб3, flgПечИтгТаб4, flgПечИтгТаб5, flgОтделТабл, flgПечНовСтр); ^False;
-- |  Field="flgПечИтгТаб5"  : flgПечИтгТаб5  = not flgПечИтгТаб5; ПечатьИтоговыхТаблиц(flgПечИтгТаб1, flgПечИтгТаб2, flgПечИтгТаб3, flgПечИтгТаб4, flgПечИтгТаб5, flgОтделТабл, flgПечНовСтр); ^False;
-- |  Field="flgОтделТабл"   : flgОтделТабл   = not flgОтделТабл ; ПечатьИтоговыхТаблиц(flgПечИтгТаб1, flgПечИтгТаб2, flgПечИтгТаб3, flgПечИтгТаб4, flgПечИтгТаб5, flgОтделТабл, flgПечНовСтр); ^False;
-- |  Field="flgПечНовСтр"   : flgПечНовСтр   = not flgПечНовСтр ; ПечатьИтоговыхТаблиц(flgПечИтгТаб1, flgПечИтгТаб2, flgПечИтгТаб3, flgПечИтгТаб4, flgПечИтгТаб5, flgОтделТабл, flgПечНовСтр); ^False;
 |  Field="flgПечНовСтр"   : ТаблицаНовойСтраницы(flgПечНовСтр);
 |  Field="flgПечСлужИнф"  : flgПечСлужИнф  = not flgПечСлужИнф; SetFLGСлужИнф; ^False;
 |  Field="flgЧиститьАна"  : flgЧиститьАна  = not flgЧиститьАна; ^False;
 |  Field="intРежимСохр_"  : intРежимСохр   = ВыбратьРежимСохранения(intРежимСохр); ^False;
 |  Field="flgСложнДаты"   : flgСложнДаты   = not flgСложнДаты ; ^False;
 |  Field="flgВдБезОКОФ_"  : Flag=flgВдБезОКОФ; flgВдБезОКОФ = not flgВдБезОКОФ; if ОтменитьИзмененияУсловийОтчета: flgВдБезОКОФ=Flag;	fi; ^False;
 |  Field="flgНмГрпОКОФ_"  : Flag=flgНмГрпОКОФ; flgНмГрпОКОФ = not flgНмГрпОКОФ; if ОтменитьИзмененияУсловийОтчета: flgНмГрпОКОФ=Flag;	fi; ^False;
 |  Field="flgФиксТабл_"   : flgФиксТабл = not flgФиксТабл; ФиксироватьШапку(flgФиксТабл); ^False;
 |  Field="Кнопка1"	   : ВидимостьОтчетныхТаблиц_Work(True , False, False, False, False); currКнопка=1; ^False;
 |  Field="Кнопка2"	   : ВидимостьОтчетныхТаблиц_Work(False, True , False, False, False); currКнопка=2; ^False;
 |  Field="Кнопка3"	   : ВидимостьОтчетныхТаблиц_Work(False, False, True , False, False); currКнопка=3; ^False;
 |  Field="Кнопка4"	   : ВидимостьОтчетныхТаблиц_Work(False, False, False, True , False); currКнопка=4; ^False;
 fi;
 ^True;
end;

Proc Field_onExit(Field:String; Iter:Integer); -- на выходе из клетки
 if Template_OnClear: Exit; fi;
 if Field="ДатОпер"	   : if ДатОпер<>oldDate:  if ОтменитьИзмененияУсловийОтчета: ДатОпер=oldDate;	fi; fi;
 |  Field="ОтчАНА"	   : if     Flag_onEnter and ОтчАНА<>OldОтчАНА: if ОтменитьИзмененияУсловийОтчета: ОтчАНА=OldОтчАНА; fi; fi;
			     if not Flag_onEnter and ОтчАНА="": 	if ОтменитьИзмененияУсловийОтчета: ОтчАНА=OldОтчАНА; fi; fi;
 |  Field="VOCКОД_"	   : ВыборДопСправочника(True);
 |  Field="отчСЧТ_"	   : Счета_ВыборВидаНФАonEnter(2); -- Применяются только ОС
 |  Field="отчКБК_"	   : КБК_ВыбратьФильтрКБК(True);
 |  Field="отчГРП_"	   : ГруппыНФА_ВыбратьФильтрГруппыНФА(True);
 |  Field="отчМОЛ_"	   : Аналитика_ВыбратьФильтрАналитики(Field, True);
 |  Field="отчМХЭ_"	   : Аналитика_ВыбратьФильтрАналитики(Field, True);
 |  Field="отчДОП_"	   : Аналитика_ВыбратьФильтрАналитики(Field, True);
 |  Field="отчНФА_"	   : Аналитика_ВыбратьФильтрАналитики(Field, True);
 |  Field="ИспФИО"	   : if ИспФИО="": ИспДол=""; ИспREC=NIL; fi;
 |  Field="УЧР_ИМЯ"	   : if УЧР_ИМЯ=""  :  УЧР_ОКПО=""; fi;
 |  Field="УЧР_ОКПО"	   : if УЧР_ОКПО="" :  УЧР_ИМЯ="";  fi;
 |  Field="ПОД_ИМЯ"	   : if ПОД_ИМЯ=""  :  ПОД_КОД="";  fi;
 |  Field="ПОД_КОД"	   : if ПОД_КОД=""  :  ПОД_ИМЯ="";  fi;
 |  Field="useЦеныЕЦ_"	   : ПрименяемФильтрЦен(Field, True);
 |  Field="БМЦеныЕЦ"	   : if (Flag_onEnter and БМЦеныЕЦ<>OldЦена) or (not Flag_onEnter and БМЦеныЕЦ=0 and OldЦена<>0): if ОтменитьИзмененияУсловийОтчета: БМЦеныЕЦ=OldЦена; fi; fi;
-- |  Field="flgПечИтгТаб1"  : ПечатьИтоговыхТаблиц(flgПечИтгТаб1, flgПечИтгТаб2, flgПечИтгТаб3, flgПечИтгТаб4, flgПечИтгТаб5, flgОтделТабл, flgПечНовСтр);
-- |  Field="flgПечИтгТаб2"  : ПечатьИтоговыхТаблиц(flgПечИтгТаб1, flgПечИтгТаб2, flgПечИтгТаб3, flgПечИтгТаб4, flgПечИтгТаб5, flgОтделТабл, flgПечНовСтр);
-- |  Field="flgПечИтгТаб3"  : ПечатьИтоговыхТаблиц(flgПечИтгТаб1, flgПечИтгТаб2, flgПечИтгТаб3, flgПечИтгТаб4, flgПечИтгТаб5, flgОтделТабл, flgПечНовСтр);
-- |  Field="flgПечИтгТаб4"  : ПечатьИтоговыхТаблиц(flgПечИтгТаб1, flgПечИтгТаб2, flgПечИтгТаб3, flgПечИтгТаб4, flgПечИтгТаб5, flgОтделТабл, flgПечНовСтр);
-- |  Field="flgПечИтгТаб5"  : ПечатьИтоговыхТаблиц(flgПечИтгТаб1, flgПечИтгТаб2, flgПечИтгТаб3, flgПечИтгТаб4, flgПечИтгТаб5, flgОтделТабл, flgПечНовСтр);
-- |  Field="flgОтделТабл"   : ПечатьИтоговыхТаблиц(flgПечИтгТаб1, flgПечИтгТаб2, flgПечИтгТаб3, flgПечИтгТаб4, flgПечИтгТаб5, flgОтделТабл, flgПечНовСтр);
-- |  Field="flgПечНовСтр"   : ПечатьИтоговыхТаблиц(flgПечИтгТаб1, flgПечИтгТаб2, flgПечИтгТаб3, flgПечИтгТаб4, flgПечИтгТаб5, flgОтделТабл, flgПечНовСтр);
 |  Field="flgПечНовСтр"   : ТаблицаНовойСтраницы(flgПечНовСтр);
 fi;
 Flag_onEnter=False;
 ValidateОтчетSection;
end;

Func Дата_onLookup(Sect:String; Row:Integer; Col:Integer; Cur:String) :String;
var dd, ddSave : Date;
var nameField :String;
 Template.HideEditor(False);
 nameField=AsString(Template.Field);
 if Template_OnClear: ^Cur; fi;
 ddSave=GetDate;
 dd=ВыборДаты(ddSave);
 if dd<>ddSave and nameField<>"ДатИсп":
   if ОтменитьИзмененияУсловийОтчета: dd=ddSave; fi;
   ValidateОтчетSection;
 fi;
 SetDate(dd);
 ^"";
end;

Func Сотрудники_onLookup(Sect:String; Row:Integer; Col:Integer; Cur:String): String;
var REC :Record;
var FieldName, СТРФИО, СТРДОЛ, tmp1, tmp2 :String;
 Template.HideEditor(False);
 if not AutoRefresh: RefreshAna; fi;
 FieldName=asString(Template.Field);
 REC=OpenCardFile("СОТРУДНИКИ", "", ИспREC, crdRecordOnly);
 if REC=NIL: ^Cur; fi;
 tmp1=GetCardFieldS("СОТРУДНИКИ", REC, "ИНИЦИАЛЫ");
 tmp2=GetCardFieldS("СОТРУДНИКИ", REC, "ФАМИЛИЯ");
 СТРФИО=if(tmp2="", GetCardFieldS("СОТРУДНИКИ", REC, "ФИОТ"), tmp2+" "+if(tmp1<>"..", tmp1, ""));
 Try СТРДОЛ=GetCardFieldS("СОТРУДНИКИ", REC, "ДОЛЖНОСТЬ.ДОЛЖ"); Except СТРДОЛ=""; end;
 if FieldName="ИСПФИО": ИСПФИО=СТРФИО; ИСПДОЛ=СТРДОЛ;
 |  FieldName="ИСПДОЛ": ИСПФИО=СТРФИО; ИСПДОЛ=СТРДОЛ;
 fi;
 ^"";
end;

Func ДопАналитика_OnLookup(Sect:String; Row:Integer; Col:Integer; Cur:String): String;
var StoreANA, Value :String;
 Template.HideEditor(False);
 if Template_OnClear: ^Cur; fi;
 StoreANA=отчАНА;
 Value=Up(AnaElection("*", False, False, StoreANA));
 if Value="": ^Cur; fi;
 if отчАНА="": 
   отчАНА=Value;
 else 
   if Pos(Value, Up(отчАНА))=0:
     отчАНА=Объединить(отчАНА, Value, Оператор);
     if Length(отчАНА)>253:
       Message("Строка доп. аналитики не может быть больше 253 символов.^MВыбор отменен!", mtWarning);
       отчАНА=StoreANA;
       OldОтчАНА=отчАНА;
       ^Cur;
     fi;
   fi;
 fi;
 if отчАНА<>StoreANA: if ОтменитьИзмененияУсловийОтчета: отчАНА=StoreANA; fi; ValidateОтчетSection; fi;
 OldОтчАНА=отчАНА;
 ^Cur;
end;

Func Field_OnValidateS(Field:String; Iter:Integer; Value:String) :Logical;
var Res :Numeric;
 if Field="отчАНА":
   if Length(Value)>253: Message("Строка доп. аналитики не может быть больше 253 символов!", mtWarning); ^False; fi;
   Try Res=Saldo("{"+Value+"}", 1.1.100); Except Raise; ^False; end;
 fi;
 ^True;
end;

Func Field_OnValidateI(Field:String; Iter:Integer; Value:Integer) :Logical;
 if Value<0.00: Message('Нельзя вводить отрицательное число!', mtError); ^False; fi;
 ^True;
end;

2-- События объектов
Proc btnOnClick(Sender:String); -- объекты при нажатии
 if Sender="btnClose"  : Close;
 |  Sender="btnРасчет" : РасчетСпискаНФА;
 |  Sender="btnExcel"  : Экспорт_Excel;
 fi;
end;

Proc Флаги_onChange(Sender:String);
var Flag, Old, Work :Logical;
var nameVar :String;
var ОбъектИмя :Object;
 if Template_OnClear: Exit; fi;
 Work=False;
 if FindObject(Sender, ОбъектИмя): Work=True; fi;
 if Work:
   nameVar="flg"+SubStr(Sender, 4, Length(Sender)-3); -- вычисляем имя переменной - 3=cb_
   Flag=GetVariableL(nameVar); -- текущий статус;
   Old = not Flag; -- предыдущий статус
   if ОтменитьИзмененияУсловийОтчета: Flag=Old; fi;
   PutVariableL(nameVar, Flag);
   ОбъектИмя.State=Flag;
   if Flag<>Old:
--     if Sender="cb_Забаланс" :
--	  ВнешнийВид_Забаланс(if(currAcc<>2, True, False));
--	  Счета_ВнешнийВид;
--	  ОчиститьУсловияОтбора(True, False, flgЧиститьАна);
--     fi;
   fi;
   ValidateОтчетSection;
 fi;
end;

Proc ФлагиСчетов_onChange(Sender:String);
var curFlag, oldFlag :Integer;
 if Template_OnClear: Exit; fi;
 curFlag=currAcc; -- текущий статус
 oldFlag=oldsAcc; -- предыдущий статус
 if ОтменитьИзмененияУсловийОтчета: curFlag=oldFlag; fi;
 currAcc=curFlag;
 if curFlag<>oldFlag:
--   if curFlag=2: флагиACC="1111111110000000";
--   |	curFlag=3: флагиACC="0000000001111111";
--   else	   флагиACC="1111111111111111";
--   fi;
   флагиACC="1111111110000000";
   Счета_ВнешнийВид;
   ВнешнийВид_Забаланс(if(currAcc<>2, True, False));
   ОчиститьУсловияОтбора(True, True, flgЧиститьАна);
   oldsAcc=curFlag;
   ValidateОтчетSection;
 fi;
end;

Proc ФлагиИСТ_onChange(Sender:String);
var curFlag, oldFlag :Integer;
 if Template_OnClear: Exit; fi;
 curFlag=currИст; -- текущий статус
 oldFlag=oldsИст; -- предыдущий статус
 if ОтменитьИзмененияУсловийОтчета: curFlag=oldFlag; fi;
 currИст=curFlag;
 if curFlag<>oldFlag: 
   ОчиститьУсловияОтбора(True, False, flgЧиститьАна);
   oldsИст=curFlag;
   ValidateОтчетSection;
 fi;
end;  

Proc СвернутьПараметры_onChange(Sender:String);
 if Template_OnClear: Exit; fi;
 ValidateSection(flgСкрытьПарОтч, False);
end;

Proc cb_НстрВнВидОтч_OnChange(Sender:String);
 ValidateSection(False, flgНстрВнВидОтч);
end;

2-- События шаблона
Proc Template_OnOpen(Create:Logical); -- при открытии шаблона
 РАБ.НАСТР_ПЕЧАТЬ.Cfg(PlanVar("НФА")+"\Настройки\", "ТББ_STD_Album10_num_000.cfg"); -- стандартная настройка !(возможно надо будет заменить)
end;

Proc Template_AfterOpen(Create:Logical); -- после открытия шаблона
var num :Integer;
 Очистить;
 if Позиции>0:
    num=EnqOkCancel("Обнаружены данные предыдущего расчета!^MСформировать ведомость?", mtConfirmation);
    if num<>cmOk: ОчисткаОтчета; fi;
 else
    ОчисткаОтчета;
 fi;
 Инициализация;
 flgСкрытьПарОтч=False;
 flgНстрВнВидОтч=False;
 flgClear=GetGuid;
 flgФиксТабл=False;
 Template.Field="Фокус";
end;

Proc Template_OnClose(Destroy:Logical); -- при закрытии шаблона
var num :Integer;
 Template.Freeze(0, 0);
 Очистить;
 flgClear="";
 if intРежимСохр=1:
   if Позиции>0:
      num=Enquiry("Выберите действие...", "Очистить ведомость (быстрее будет открываться бланк)^Mили сохранить данные для дальнейшего просмотра?", "Очистить;Сохранить", mtConfirmation);
      if num=1: ОчисткаОтчета; fi;
   fi;
 |  intРежимСохр>1: ОчисткаОтчета;
 fi;
 flgФиксТабл=False;
 Template.Freeze(0, 0);
end;

КОНЕЦ -- конец бланк