БЛАНКСШАБЛОНОМ[20.04.2006] "Внутреннее перемещение всех НФА с МОЛ", РЕДАКТОР РПО_ВНУТР_ПЕРЕМ_МОЛ;
-- Редакция ЗАО "Агентство 'Русспромоценка'"
var MaskUserVoc  :String="ВД.*|ВКЛ.*|П.*|ПГР.*|РБС.*";
2-- Переменные
btnClose:Object; btnCalc:Object; btnError:Object; btnRep:Object; cbПроводить:Object; cbEditState:Object; cbФиксШапка:Object;
СЕКЦДОК:Object; СЕКЦШАПКА0:Object; СЕКЦШАПКА1:Object; СЕКЦШАПКА2:Object; СЕКЦШАПКА3:Object; СЕКЦШАПКА4:Object; СекцТАБЗ:Object; СекцТАБТМ:Object; СекцТАБТУ:Object; СекцТАБП:Object;
СекцВспомМассив1:Object; СекцВспомМассив2:Object;
ВспомМассив1 :Integer; ВспомМассив2 :Integer;
BTNNAME_MENU       :String="Внутреннее перемещение всех НФА с МОЛ";
Var SQLver:l;    -- расчитывается при открытии бланка (шаблонпослеоткрытия)
ФлCopyClosedModFob:object;
var CopyClosedModFob:l=ClosedModFob;
2func UpdateTimeSecCurrent:i;^UpdateTimeSec;end;-- функция обязательная для работы с SQL запросами
var ИМЯКРТ   :s='РПО_ВНУТР_ПЕРЕМ_МОЛ';-- Картотека которую редактирует данный бланк

var список []      :String=if(ДОК[$].UKEYCRD=0,'+','=>');
var ВидДОК_[]      :String=Name_A(ДОК[$].ВидДОК);

var SelfCRD        :String="РПО_ВНУТР_ПЕРЕМ_МОЛ";
var Пользов        :String;
var Фокус          :String;
var NewREC         :Logical=(CurrentState=crdusInserted);
var First          :Logical;
var EditState      :Logical;
var ФиксШапка      :Logical;
var USEВД_B        :Logical;
var USEПГРB        :Logical;
var USEВД_V        :Logical;
var USEПГРV        :Logical;
var USEВД_Z        :Logical;
var USEПГРZ        :Logical;
var VOCИНВ         :String=if(if(Name_A("УЧН.")<>" ",2007, 2006)>2006, "УЧН", "ИНВ");
var VOC_ОБЯЗАТ     :String="М.*|МОЛ.*|НФА.*|"+VOCИНВ+".*";
var VisibleDO      :Integer=13;
var OldDate        :Date;
var StoreANA       :String;
var VOC_CALC_ОСТ_  :String=VOC_CALC_ОСТ;
var МОЛ_ОТККОД_    :String=МОЛ_ОТККОД;
var NN[]           :Integer=$;
var МОЛ_ОТКИМЯ_    :String=if(Name_A(МОЛ_ОТККОД)<>"" and Name_A(МОЛ_ОТККОД)<>" ", Name_A(МОЛ_ОТККОД), МОЛ_ОТККОД);
var МХЭ_ОТККОД_ОБЩ_:s=МХЭ_ОТККОД_ОБЩ;
var МХЭ_ОТКИМЯ_ОБЩ_:s=if(Name_A(МХЭ_ОТККОД_ОБЩ)<>"" and Name_A(МХЭ_ОТККОД_ОБЩ)<>" ", Name_A(МХЭ_ОТККОД_ОБЩ), МХЭ_ОТККОД_ОБЩ);

var ДОП_VOCКОД_    :String=ДОП_VOCКОД;
var ДОП_АНАКОД_    :String=ДОП_АНАКОД;

var КОЛВОИТОГ      :Numeric=SumOfArray(Позиции[].КОЛВО);
var СУММАИТОГ      :Numeric=SumOfArray(Позиции[].СУММАП);
var constНФА100П   :Numeric;
var constНФА_ИНВ   :Numeric;
--
var Buf[]          :String;
var BufMsk[]       :String;
var BufStr[]       :String;
var Txt[]          :String;
var ДОПИМЯ01[]     :String=Trim(Name_A(Позиции[$].ДОПАНА01));
var ДОПИМЯ02[]     :String=Trim(Name_A(Позиции[$].ДОПАНА02));
var ДОПИМЯ03[]     :String=Trim(Name_A(Позиции[$].ДОПАНА03));
var ДОПИМЯ04[]     :String=Trim(Name_A(Позиции[$].ДОПАНА04));
var ДОПИМЯ05[]     :String=Trim(Name_A(Позиции[$].ДОПАНА05));
var ДОПИМЯ06[]     :String=Trim(Name_A(Позиции[$].ДОПАНА06));
var ДОПИМЯ07[]     :String=Trim(Name_A(Позиции[$].ДОПАНА07));
var ДОПИМЯ08[]     :String=Trim(Name_A(Позиции[$].ДОПАНА08));
var ДОПИМЯ09[]     :String=Trim(Name_A(Позиции[$].ДОПАНА09));
var ДОПИМЯ10[]     :String=Trim(Name_A(Позиции[$].ДОПАНА10));
var Призн_[]       :String=Позиции[$].Призн;
--
var УслАНА[]       :String;
var aAna[]         :String;
var bindVOC[]      :String;  -- Привязанный справочник
var bindINT[]      :Integer; -- Количество привязок

var REFНФА[]       :String;
var LSTНФА[]       :String;
var REFАНА[]       :String;
var LSTАНА[]       :String;

var BLDFLD[]       :String;

var SRTFLD[]       :String;
var SRTСУМ[]       :Numeric;
var SRTКОЛ[]       :Numeric;
--
var ИменаСекций[]  :String;
var BufField[]     :String;
var BufColorBg[]   :Integer;
var BufColorFo[]   :Integer;

2-- Общие процедуры и функции
Proc Очистить;
 ClearVariable(NN); ClearVariable(Txt); ClearVariable(BLDFLD); ClearVariable(BufMsk); ClearVariable(bindVOC);
                    ClearVariable(Buf); ClearVariable(aAna);   ClearVariable(BufStr); ClearVariable(bindINT);
end;

Proc ОчиститьТаблицу;
  ClearVariable(SRTFLD); ClearVariable(REFНФА); ClearVariable(REFАНА); ClearVariable(ВспомМассив1);
  ClearVariable(SRTСУМ); ClearVariable(LSTНФА); ClearVariable(LSTАНА); ClearVariable(ВспомМассив2);
  ClearVariable(SRTКОЛ);
end;

Proc УдалитьПустые;
var nn :Integer;
 nn=1;
 while nn<=Позиции do if Позиции[nn].НФА_КОД="": Try DeleteFrame(Позиции, nn); Except end; else nn=nn+1; fi; od;
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=AsString(Template.Field);
 if name="ДАТАОПЕР": ^ДАТАОПЕР; fi;
end;

Proc SetDate(Value:Date); -- устанавливаем в заданном поле дату; Value - значение даты, которое необходимо присвоить
var name :String;
 name=AsString(Template.Field);
 if 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 УдалитьСловоИзНабора_Диалог(Set:String; SepSet:String) :String;
var num, i, nn :Integer;
 ClearVariable(Buf);
 num=WordsCount(Set, SepSet);
 if num<2: ^""; fi;
 for i=1 to num do Buf[i+1]=ExtractWord(i, 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 i=2 to num do if not i=nn: Set=Set+SepSet+Buf[i]; fi; od;
 Set=SubStr(Set, Length(SepSet)+1, 255);
 ^Set;
end;

Func СортироватьНаборСлов(Set:String; SepSet:String; Flag:Logical) :String; --Сортирует набор по словам
-- Set набор слов; SepSet разделитель; Flag направление сортировки
var num, i, k :Integer;
var tmp :String;
 ClearVariable(Buf);
 num=WordsCount(Set, SepSet);
 k=0;
 for i=1 to num do
   tmp=ExtractWord(i, Set, SepSet);
   if tmp<>"": k=k+1; Buf[k]=tmp; fi;
 od;
 SortArray(Buf, Flag);
 tmp="";
 for i=1 to k do tmp=tmp+SepSet+Buf[i]; od;
 tmp=SubStr(tmp, Length(SepSet)+1, 255);
 ^tmp;
end;

Func УдалитьСловаИзНабораПоМаске(Set:String; SetSep:String; Mask:String; MaskSep:String) :String;
var nn1, nn2, i, j :Integer;
var Res, tmp1, tmp2 :String;
 if Set="" or Mask="": ^Set; fi;
 Res="";
 nn1=WordsCount(Set,   SetSep);
 nn2=WordsCount(Mask, MaskSep);
 for i=1 to nn1 do
   tmp1=ExtractWord(i, Set, SetSep);
   for j=1 to nn2 do
     tmp2=ExtractWord(j, Mask, MaskSep);
     if Match(tmp1, tmp2): tmp1=""; Break; fi;
   od;
   if not tmp1="": Res=Res+SetSep+tmp1; fi;
 od;
 Res=SubStr(Res, Length(SetSep)+1, 255);
 ^Res;
end;

Func ДобавитьСловоВНаборСЗаменой(Set:String; SetSep:String; Value:String; Mask:String; MaskSep:String) :String;
var Res :String;
 if Set="": ^Value; fi;
 Res=УдалитьСловаИзНабораПоМаске(Set, SetSep, Mask, MaskSep);
 Res=Объединить(Res, Value, SetSep);
 ^Res;
end;

Func ДобавитьПризнак(Set:String; NewSign:String) :String;
var Voc :String;
 Voc=GetAnaGlossary(NewSign);
 if Voc<>"": Voc=Voc+".*"; else Voc="*"; fi;
 ^ДобавитьСловоВНаборСЗаменой(Set, " ", NewSign, Voc, "");
end;

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

Func ЗаменитьРазделительНабораСлов(Set:String; SepOld:String; SepNew:String) :String;
--Set - набор слов; SepOld - старый разделитель; SepNew - новый разделитель
var num, i :Integer;
var OUT :String;
 OUT="";
 num=WordsCount(Set, SepOld);
 for i=1 to num do OUT=OUT+SepNew+ExtractWord(i, Set, SepOld); od;
 OUT=SubStr(OUT, Length(SepNew)+1, 255);
 ^OUT;
end;

Func ПроверитьНаборСлов(Set:String; SepSet:String; Mask:String; SepMask:String; Msg:String) :Logical;
--Проверяет набор слов "Set" на соотвествие маске "Mask"; SepSet, SepMask - разделители; если Msg не пустое то выдаеться сообщение
var nn1,nn2, i, j :Integer;
var tmp1, tmp2 :String;
var Flag :Logical;
 nn1=WordsCount(Mask, SepMask);
 nn2=WordsCount(Set,   SepSet);
 if not nn1=0 and nn2=0: if not Msg="": Message(Msg+ExtractWord(1, Mask, SepMask), mtError); fi; ^False; fi;
 for i=1 to nn1 do
   tmp1=ExtractWord(i, Mask, SepMask);
   Flag=False;
   for j=1 to nn2 do
     tmp2=ExtractWord(j, Set, SepSet);
     if Match(tmp2, tmp1): Flag=True; Break; fi;
   od;
   if not Flag: if not Msg="": Message(Msg+tmp1, mtError); fi; ^False; fi;
 od;
 ^True;
end;

Func НаборСлов_Маску(Set:String; SetSep:String; MaskSep:String; Множество:Logical) :String;
--Возвращает маску набора слов "Set"
var num, ii :Integer;
var Res, voc :String;
 Res="";
 num=WordsCount(Set, SetSep);
 if num>0:
    for ii=1 to num do
      voc=Trim(GetAnaGlossary(ExtractWord(ii, Set, SetSep)));
      if voc<>"": Res=Res+MaskSep+voc+if(Множество, ".*", ""); fi;
    od;
    if Res<>"": Res=Trim(SubStr(Res, Length(MaskSep)+1, 255)); fi;
 fi;
 ^Res;
end;

Func TemplateSaveOK :Logical; -- проверка правильности ввода данных при сохранении
 if НОМЕРБУМ="":      Message("Не задан номер операции!", mtWarning); Template.Field="НОМЕРБУМ"; ^False; fi;
 if ДАТАОПЕР=1.1.100: Message("Не задана дата операции!", mtWarning); Template.Field="ДАТАОПЕР"; ^False; fi;
 ^True;
end;

Func ПроверкаСчетов(СЧ:String) :String;
var Acc :String;
  if Match(СЧ, "???.????.???????.???.?.101.??.???")   : Acc=SubStr(СЧ, 1, 30)+"310";
  |  Match(СЧ, "???.????.???????.???.?.105.??.???")   : Acc=SubStr(СЧ, 1, 30)+"340";
  |  Match(СЧ, "???.????.???????.???.?.108.?6.???")   : Acc=SubStr(СЧ, 1, 30)+"340";
  |  Match(СЧ, "???.????.???????.???.?.102.??.???")   : Acc=SubStr(СЧ, 1, 30)+"320";
  |  Match(СЧ, "???.????.???????.???.?.103.??.???")   : Acc=SubStr(СЧ, 1, 30)+"330";
  |  Match(СЧ, "ЗАБ.??.10?.??")                       : Acc=СЧ;


  else Acc="";
  fi;
  if Acc="" or Name_S(Acc)=" ": ^" "; fi;
  ^Acc;
end;

Func МаскаОбязательныхСправочников(Acc:String; ДопПризн:String) :String;
var SetVoc, mask :String;
var ii, len :Integer;
  ClearVariable(Txt);
  SetVoc=SignsMask(Acc, True);
  if SetVoc<>"":
     len=WordsCount(SetVoc, "|");
     for ii=1 to len do
       mask=ExtractWord(ii, SetVoc, "|");
       if not MatchMask(mask, Объединить(VOC_ОБЯЗАТ, НаборСлов_Маску(ДопПризн, " ", "|", True), "|"), "|"):
          if SearchInArray(Txt, mask, True)<0: InsertInArraySort(Txt, mask); fi;
       fi;
     od;
  fi;
  mask="";
  len=LengthOfArray(Txt);
  if len>0: for ii=1 to len do mask=mask+"|"+Txt[ii]; od; else mask=""; fi;
  if mask<>"": mask=SubStr(mask, 2, 255); fi;
  ^mask;
end;

Func ПредупрежденияПроверки(Iter:Integer) :Logical;
var Acc, mask :String;
  Acc=ПроверкаСчетов(Позиции[Iter].ДСЧЕТ);
  if Acc=" ": 
     Message("Счет '"+Acc+"'^M отсутствует в структуре учета!", mtWarning);
     Template.Field="ДСЧЕТ";
     Template.Frame=Iter;
     ^False;
  fi;
  mask=МаскаОбязательныхСправочников(Acc, Позиции[Iter].ДОПАНАИТОГО);
  if not ПроверитьНаборСлов(Позиции[Iter].ПРИЗН, " ", mask, "|", ""):
     Message("Отсутствуют обязательные аналитические признаки!^M[признак из набора "+mask+"]", mtError);
     Template.Field="ПРИЗН_";
     Template.Frame=Iter;
     ^False;
  fi;
  ^True;
end;

Func ПроводитьOK :Logical; -- проверка правильности ввода данных проведении проводки по учету
var num, jj :Integer;
 if НОМЕРБУМ="":      Message("Не задан номер операции!", mtWarning); Template.Field="НОМЕРБУМ"; ^False; fi;
 if ДАТАОПЕР=1.1.100: Message("Не задана дата операции!", mtWarning); Template.Field="ДАТАОПЕР"; ^False; fi;
 if Name_A(МОЛ_ОТККОД)=" ": Message("Не выбрано или выбрано несуществующее^Mматериально ответственное лицо [ОТКУДА]!", mtWarning); Template.Field="МОЛ_ОТККОД_"; ^False; fi;
 УдалитьПустые;
 if not Позиции>0: Message("Таблица пустая!^MНе сделан расчет либо по выбранному условию отбора нет данных!", mtWarning); Template.Object="btnCalc"; ^False; fi;
 num=Позиции;
 for jj=1 to num do
   if not Позиции[jj].ИСКЛ:
      if Name_A(Позиции[jj].МОЛ_КУДАКОД)=" ": Message("Не выбрано или выбрано несуществующее^Mматериально ответственное лицо [КУДА]!", mtWarning); Template.Field="МОЛ_КУДАКОД"; Template.Frame=jj; ^False; fi;
      if Name_A(Позиции[jj].МХЭ_КУДАКОД)=" ": Message("Не выбрано или выбрано несуществующее^Mместо хранения [КУДА]!", mtWarning);                 Template.Field="МХЭ_КУДАКОД"; Template.Frame=jj; ^False; fi;
      if not ПредупрежденияПроверки(jj): ^False; fi;
   fi;
 od;
 ^True;
end;

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

Proc ЦветаПолей;
var nn, len :Integer;
 ClearVariable(BufField); ClearVariable(BufColorBg); ClearVariable(BufColorFo);
 nn=InsertInArraySort(BufField,"СПИСОК");          InsertInArray(BufColorBg, nn, coTeal);
 nn=InsertInArraySort(BufField,"НОМЕРБУМ");        InsertInArray(BufColorBg, nn, coAqua);
 nn=InsertInArraySort(BufField,"ДАТАОПЕР");        InsertInArray(BufColorBg, nn, coAqua);
 nn=InsertInArraySort(BufField,"VOC_CALC_ОСТ_");   InsertInArray(BufColorBg, nn, coTeal);
 nn=InsertInArraySort(BufField,"МХЭ_ОТККОД_ОБЩ_"); InsertInArray(BufColorBg, nn, coTeal);
 nn=InsertInArraySort(BufField,"МОЛ_ОТККОД_");     InsertInArray(BufColorBg, nn, coTeal);
 nn=InsertInArraySort(BufField,"ДОП_VOCКОД_");     InsertInArray(BufColorBg, nn, coTeal);
 nn=InsertInArraySort(BufField,"ДОП_АНАКОД_");     InsertInArray(BufColorBg, nn, coTeal);
 nn=InsertInArraySort(BufField,"МОЛ_КУДАКОД");     InsertInArray(BufColorBg, nn, coTeal);
 nn=InsertInArraySort(BufField,"МХЭ_КУДАКОД");     InsertInArray(BufColorBg, nn, coTeal);
 nn=InsertInArraySort(BufField,"ИСКЛ");            InsertInArray(BufColorBg, nn, coTeal);
 nn=InsertInArraySort(BufField,"ПРИЗН_");          InsertInArray(BufColorBg, nn, coTeal);
 nn=InsertInArraySort(BufField,"КМНТ");            InsertInArray(BufColorBg, nn, coAqua);
 nn=InsertInArraySort(BufField,"КНМОЛ");           InsertInArray(BufColorBg, nn, coTransparent);
 nn=InsertInArraySort(BufField,"КНМ");             InsertInArray(BufColorBg, nn, coTransparent);
 nn=InsertInArraySort(BufField,"КНМОЛК");          InsertInArray(BufColorBg, nn, coTransparent);
 nn=InsertInArraySort(BufField,"КНМК");            InsertInArray(BufColorBg, nn, coTransparent);
 len=LengthOfArray(BufField);
 for nn=1 to len do
   if BufColorBg[nn]=coTeal: BufColorFo[nn]=coWhite;
   |  True: BufColorFo[nn]=coBlack;
   fi;
 od;
end;

Proc СопроводительныеДокументы(УжеПроведено:Logical);
 if not УжеПроведено:
   if ДОК=0:
     InsertFrame(ДОК, 1);
     ДОК[1].ВИДДОК='ВИДДОК.НФА.ДОКУМЕНТЫ.НАКЛАДНЫЕ.ОКУД_0306032';
   fi;
   if ДОК=1:
     if ДОК[1].ВИДДОК='ВИДДОК.НФА.ДОКУМЕНТЫ.НАКЛАДНЫЕ.ОКУД_0306032':
       InsertFrame(ДОК,2);
       ДОК[2].ВИДДОК='ВИДДОК.НФА.ДОКУМЕНТЫ.НАКЛАДНЫЕ.ОКУД_0504234';
     fi;
   fi;
   if SearchInArray(ДОК[].ВИДДОК, 'ВИДДОК.НФА.ДОКУМЕНТЫ.НАКЛАДНЫЕ.ОКУД_0315006')<1:
     InsertFrame(ДОК, ДОК+1);
     ДОК[ДОК].ВИДДОК='ВИДДОК.НФА.ДОКУМЕНТЫ.НАКЛАДНЫЕ.ОКУД_0315006';
   fi;
 fi;
end;

Proc ТолькоЧтение(Flag:Logical);
var len, k, i, j, ik, jk, n, цвFont, цвBack :Integer;
var ТЧ :Logical;
var tmp :String;
var СекцИмя : Object;
 --Exit;
 ClearVariable(ИменаСекций);
 ИменаСекций[1] ="СЕКЦШАПКА0";
 ИменаСекций[2] ="СЕКЦШАПКА1";
 ИменаСекций[3] ="СЕКЦШАПКА2";
 ИменаСекций[4] ="СЕКЦШАПКА3";
 ИменаСекций[5] ="СЕКЦШАПКА4";
 ИменаСекций[6] ="СЕКЦТАБТМ";
 ИменаСекций[7] ="СЕКЦТАБТУ";
 ИменаСекций[8] ="СекцТАБЗ";
 len=LengthOfArray(ИменаСекций);
 ShowProgress(len, "Обработка данных...");
 Try
   for k=1..len do
     ProgressPos(k);
     if FindObject(ИменаСекций[k], СекцИмя):
       ik=asInteger(СекцИмя.RowsCount); jk=asInteger(СекцИмя.ColsCount);
       for i=1 .. ik do
         for j=1 .. jk do
           tmp=Up(asString(СекцИмя.Cell(i, j, CellContents, ""))); n=SearchInArray(BufField, tmp, True);
           if n<>-1:
             if Flag: цвFont=coBlack; цвBack=coTransparent; ТЧ=True; else цвFont=BufColorFo[n]; цвBack=BufColorBg[n]; ТЧ=False; fi;
             СекцИмя.Cell(i, j, CellFontColor, цвFont); СекцИмя.Cell(i, j, CellBgColor, цвBack); СекцИмя.Cell(i, j, CellReadOnly, ТЧ);
           fi;
         od;
       od;
     fi;
   od;
 Finally
   CloseProgress;
 end;
 btnCalc.Enabled=not(Flag);
 btnRep.Enabled=Flag;
 ClearVariable(ИменаСекций);
 СопроводительныеДокументы(Flag);
end;

Func ВыборМОЛ(PrevValue:String) :String;
var res :String;
 res=AnaElection("МОЛ.*", False, False, PrevValue);
 if res="": ^PrevValue; fi;
 ^res;
end;
Func ВыборМ(PrevValue:String) :String;
var res :String;
 res=AnaElection("М.*", False, False, PrevValue);
 if res="": ^PrevValue; fi;
 ^res;
end;

Func AddVocUSER(PrevValue:String) :String;
var res, tmp, искл :String;
var i, num, k :Integer;
 res="";
 ClearVariable(Buf);
 num=WordsCount(PrevValue, "|");
 if num>0:
   for i=1 to num do
     tmp=Up(ExtractWord(i, PrevValue, "|"));
     if SearchInArray(Buf, tmp, True, 1)=-1: k=InsertInArraySort(Buf, tmp); fi;
   od;
 fi;
 искл="ВИДДОК.*|ВЫПЛ.*|ГНФА.*|ГРОС.*|ДВИЖ_НФА.*|ДЕНДОК.*|ДНФА.*|ДНФАID.*|ЖО.*|ИНВВЕД.*|КИФД.*|КОМИССИЯ.*|КРЕДИТ.*|НБ.*|П_ЛИМ.*|ПБЮДЖ.*|СЧ107Н.*|ТМЦ.*|УДЕРЖ.*";
 tmp=AnaElection("*.*&~(НФА.*|МОЛ.*|М.*|"+VOCИНВ+".*"+"|"+искл+")", True, False, PrevValue);
 if tmp="": ^PrevValue; fi;
 tmp=Up(tmp);
 num=LengthOfArray(Buf);
 if not num>0: -- предыдущих значений нет
   res=tmp;
 else
   if SearchInArray(Buf, tmp, True, 1)=-1: k=InsertInArraySort(Buf, tmp); fi;
   num=LengthOfArray(Buf);
   res="";
   if num>10: -- ограничиваемся 10 дополнительными справочниками
      if EnqOkCancel("Ограничение!^MНе более 10 дополнительных справочников!^MВзять первые 10 (по алфавиту)?", mtWarning)=cmOk:
         num=10;
      else
         ^PrevValue;
      fi;
   fi;
   for i=1 to num do res=Объединить(res, Buf[i], "|"); od;
 fi;
 ^res;
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:
    REC=SignToRecord("ДНФА.РАСХ.106_304", False);
 fi;
 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, VOCИНВ+".*") 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 ДобавитьСправочникОстатков(PrevValue:String) :String;
var qq :Integer;
 ClearVariable(Buf);
 Buf[1]="Добавить пользовательский справочник к уже имеющимся.";
 Buf[2]="Считать справочники настроенные в операции 'ВНПР.ЭЭ'.";
 qq=Alternate("Выберите действие...", Buf, -1, 1, 12);
 if qq=1: ^AddVocUSER(PrevValue);
 |  qq=2: ^AddVocOPER(PrevValue, False);
 else ^PrevValue;
 fi;
end;

Proc СформироватьСтолбцыАналитики(STRVOC:String);
var ii, num, k :Integer;
var tmp :String;
 -- скрываем
 ii=10;
 while ii>0 do
   СекцТАБЗ.Column(VisibleDO+2+ii, ColVisible, False);
   СекцТАБТМ.Column(VisibleDO+ii, ColVisible, False);
   СекцТАБТУ.Column(VisibleDO+ii, ColVisible, False);
   ii=ii-1;
 od;
 -- считываем
 ClearVariable(Buf);
 num=WordsCount(STRVOC, "|");
 if num>0:
   for ii=1 to num do
     tmp=Up(ExtractWord(ii, STRVOC, "|"));
     if SearchInArray(Buf, tmp, True, 1)=-1: k=InsertInArraySort(Buf, tmp); fi;
   od;
 fi;
 -- отображаем
 num=LengthOfArray(Buf);
 if num>0:
   if num>10: num=10; fi;
   for ii=1 to num do
     tmp="СПРАВОЧНИК"+Chr(13)+Lo(Name_A(Buf[ii]+"."));
     СекцТАБЗ.Column(VisibleDO+2+ii, ColVisible, True);
     СекцТАБЗ.Cell(1, VisibleDO+2+ii, CellContents, tmp);
     СекцТАБТМ.Column(VisibleDO+ii, ColVisible, True);
     СекцТАБТМ.Cell(2, VisibleDO+ii, CellContents, "ДОПАНА"+Format("%.2d", ii));
     СекцТАБТУ.Column(VisibleDO+ii, ColVisible, True);
     СекцТАБТУ.Cell(2, VisibleDO+ii, CellContents, "ДОПАНА"+Format("%.2d", ii));
   od;
 fi;
end;

--Func USE_ИНВЕНТАРНЫЙ_НОМЕР(ACC:String; SUM:Numeric; QUA:Numeric) :Logical;
-- if Match(ACC, "*.?.101.0?.???"):
--    if Match(ACC, "*.101.07.???") or Match(ACC, "*.101.08.???"):^false;
--     | true:^true;
--    fi;
----    if not Match(ACC, "*.101.07.???") and not Match(ACC, "*.101.08.???") and QUA<>0:
----       if SUM<0.00: SUM=-SUM; fi; if QUA<0.00: QUA=-QUA; fi;
----       if SUM/QUA>1000: ^True; fi;
----     | not Match(ACC, "*.101.07.???") and not Match(ACC, "*.101.08.???") and QUA=0:^True;
----    fi;
-- |  Match(ACC, "*.?.102.01.???"): ^True;
-- |  Match(ACC, "*.?.103.0?.???"): ^True;
-- fi;
-- ^False;
--end;

Proc СчитатьКонстантыНФА(ddОТЧ:Date);
var chislo :Numeric;
 Try chislo=Com_Var("ОС_100" , ddОТЧ); Except chislo=0.00; end;
 if not chislo>0: if ddОТЧ>=1.1.2011: chislo=40000; else chislo=20000; fi; fi;
 constНФА100П=chislo;
 Try chislo=Com_Var("ОС_РАСХ" , ddОТЧ); Except chislo=0.00; end;
 if not chislo>0: if ddОТЧ>=1.1.2009: chislo=3000; else chislo=1000; fi; fi;
 constНФА_ИНВ=chislo;
end;

Func USE_ИНВЕНТАРНЫЙ_НОМЕР(ACC:String; SUM:Numeric; QUA:Numeric; ddОТЧ:Date; FindУЧН:String; ctНФА100П:Numeric; ctНФА_ИНВ:Numeric) :Logical;
var Цена :Numeric;
 if Match(ACC, "*.?.101.??.???"):
    if Match(ACC, "*.?.101.37.???"):
--       ^False;
--    |  Match(ACC, "*.?.101.07.???"):
       if ddОТЧ>=1.1.2009 and ctНФА100П>0.00:
         if SUM<>0.00 and QUA<>0.00:
           SUM=Abs(SUM);
           QUA=Abs(QUA);
           Цена=SUM/QUA;
           if Цена>ctНФА100П: ^True; fi;
         |  SUM=0 or QUA=0:
           if Match(FindУЧН, "УЧН.*"): ^True; fi;
         fi;
       fi;
    else
       if ctНФА_ИНВ>0.00:
         if SUM<>0.00 and QUA<>0:
           SUM=Abs(SUM);
           QUA=Abs(QUA);
           Цена=SUM/QUA;
           if Цена>ctНФА_ИНВ:
             ^True;
           else
             -- рассматриваем вариант конвертации
             --if Match(FindУЧН, "УЧН.*"): if FindУЧН="УЧН.ДО3000" or (ddОТЧ>=1.1.2009 and Цена>1000 and Цена<=3000): ^False; else ^True; fi; fi;
             if Match(FindУЧН, "УЧН.*"): ^True; fi;
           fi;
         | SUM=0 or QUA=0:
           if Match(FindУЧН, "УЧН.*"): ^True; fi;
         fi;
       fi;
    fi;
 |  Match(ACC, "*.?.102.??.???"): ^True;
 |  Match(ACC, "*.?.103.??.???"): ^True;
 fi;
 ^False;
end;

Proc РежимБыстрогоВвода(flg:Logical);
 if Позиции>0:
   СекцТАБТУ.Visible = flg;
   СекцТАБТМ.Visible = not flg;
 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, "ЗАБ.??.???.??"):
         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;

Proc ПривязкаСправочников_ВД_ПГР(ddBP:Date; ddEP:Date);
var xx, ii, num, jj, kk :Integer;
var Voc :String;
 ClearVariable(bindVOC); ClearVariable(bindINT);
 xx=0;
 xx=СчетаНФА_вУчете("*.1.101.??.???|*.1.102.??.???|*.1.103.??.???|*.1.105.??.???", ddBP, ddEP);
 if not xx>0: xx=СчетаНФА_поСтруктуре("*.1.101.??.???|*.1.102.??.???|*.1.103.??.???|*.1.105.??.???"); fi;
 if xx>0:
   for ii=1 to xx do
     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:
     jj=num; -- удаляем с конца
     for ii=1 to num do
       -- xx - количество рабочих счетов
       if bindINT[jj]<>xx: DeleteFromArray(bindVOC, jj); fi;
       jj=jj-1;
     od;
   fi;
 fi; -- xx>0
 if SearchInArray(bindVOC,  "ВД.*", True, 1)>0: USEВД_B=True; fi;
 if SearchInArray(bindVOC, "ПГР.*", True, 1)>0: USEПГРB=True; fi;
 --
 ClearVariable(bindVOC); ClearVariable(bindINT);
 xx=0;
 xx=СчетаНФА_вУчете("*.2.101.??.???|*.2.102.??.???|*.2.103.??.???|*.2.105.??.???", ddBP, ddEP);
 if not xx>0: xx=СчетаНФА_поСтруктуре("*.2.101.??.???|*.2.102.??.???|*.2.103.??.???|*.2.105.??.???"); fi;
 if xx>0:
   for ii=1 to xx do
     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:
     jj=num; -- удаляем с конца
     for ii=1 to num do
       -- xx - количество рабочих счетов
       if bindINT[jj]<>xx: DeleteFromArray(bindVOC, jj); fi;
       jj=jj-1;
     od;
   fi;
 fi; -- xx>0
 if SearchInArray(bindVOC,  "ВД.*", True, 1)>0: USEВД_V=True; fi;
 if SearchInArray(bindVOC, "ПГР.*", True, 1)>0: USEПГРV=True; fi;
 --
 ClearVariable(bindVOC); ClearVariable(bindINT);
 xx=0;
 xx=СчетаНФА_вУчете("ЗАБ.??.10?.??", ddBP, ddEP);
 if not xx>0: xx=СчетаНФА_поСтруктуре("ЗАБ.??.10?.??"); fi;
 if xx>0:
   for ii=1 to xx do
     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:
     jj=num; -- удаляем с конца
     for ii=1 to num do
       -- xx - количество рабочих счетов
       if bindINT[jj]<>xx: DeleteFromArray(bindVOC, jj); fi;
       jj=jj-1;
     od;
   fi;
 fi; -- xx>0
 if SearchInArray(bindVOC,  "ВД.*", True, 1)>0: USEВД_Z=True; fi;
 if SearchInArray(bindVOC, "ПГР.*", True, 1)>0: USEПГРZ=True; fi;
end;

Func РасчетОстатковМОЛ(ОТКМОЛ:String; ДVOC:String; ДатаРасч:Date) :Integer; -- если меньше 0 - ошибка
var res, xx, len, ii, voc, voc2, pp, jj, yy, num, мм1, мм2 :Integer;
var Режим, СЧДЕБ, БЕЗУЧН, Work, OK, uПГР, uСВД, uДОП :Logical;
var ВременныйФайл, aVal1, aVal2, aDeb, aCre, aComment: String;
var svrANA, MascAcc, MascAna, tmp, REFtxt, BindANA :String;
var КОДСЧТ, КОДНФА, КОДУЧН, КОДМХЭ :String;
var aSum1, aSum2, SUM, KOL, QUA :Numeric;
var aDate, dd :Date;
 res=0;
 if Trim(ДVOC)="":
    tmp="Не выбраны дополнительные справочники для расчета остатков!^M  Продолжить - Расчет без дополнительные справочников^M  Из операции - Расчет по условиям операции ВНПР.ЭЭ^M  Отмена - Ввести свой набор справоников";
    num=Enquiry("Выберите действие", tmp, "Продолжить;Из операции;Отмена", mtWarning);
    if num=2: ДVOC=AddVocOPER("", True); VOC_CALC_ОСТ=ДVOC;
    |  num=3: ^-1;
    fi;
 fi;
 if ОТКМОЛ="": Message("Не задано материально ответственное лицо!", mtWarning); ^-1; fi;
 if not ValidSign(ОТКМОЛ): Message("Некорректный аналитический признак ["+ОТКМОЛ+"]!", mtError); ^-1; fi;
 MascAcc="*.101.??.???|*.102.??.???|*.103.??.???|*.105.??.???|ЗАБ.??.10?.??";
 Try SUM=Saldo(MascAcc, 1.1.100); Except Raise; ^-1; end;
 --Try SUM=Saldo("{"+ОТКМОЛ+"}", 1.1.100); Except Raise; ^-1; end;
 uДОП=False;
 uСВД=False;
 uПГР=False;
 if ДVOC<>"": 
   if Pos(Up(ДОП_VOCКОД), Up(ДVOC))>0: uДОП=True; fi;
   voc=WordsCount(ДVOC, "|");
   for ii=1 to voc do
     tmp=Up(ExtractWord(ii, ДVOC, "|"))+".*";
     if tmp="ВД.*" : uСВД=True;
     |  tmp="ПГР.*": uПГР=True;
     fi;
   od;
 fi;
 USEВД_B=False;
 USEПГРB=False;
 USEВД_V=False;
 USEПГРV=False;
 USEВД_Z=False;
 USEПГРZ=False;
 ClearVariable(BindVOC);
 ClearVariable(BindINT);
 if uСВД or uПГР: ПривязкаСправочников_ВД_ПГР(1.1.100, ДатаРасч+1); fi;
 --
 ClearVariable(BindVOC);
 ClearVariable(BindINT);
 BindANA=СправочникиСтруктурыПоМаскеСчетовПрогресс(MascAcc, 1.1.100, ДатаРасч+1, True, True);
 if BindANA=" ": ^-1; fi; -- если был Except
 if SearchInArray(bindVOC, "НФА.*", True, 1)<1: Message("Справочник 'НФА' не привязан к счетам учета НФА!", mtError); ^-1; fi;
 if SearchInArray(bindVOC, "МОЛ.*", True, 1)<1: Message("Справочник 'МОЛ' не привязан к счетам учета НФА!", mtError); ^-1; fi;
 if SearchInArray(bindVOC, "М.*",   True, 1)<1: Message("Справочник 'М' не привязан к счетам учета НФА!",   mtError); ^-1; fi;
 if ДVOC<>"": 
   voc=WordsCount(ДVOC, "|");
   for ii=1 to voc do
     tmp=ExtractWord(ii, ДVOC, "|")+".*";
     if tmp<>"ВД.*" and tmp<>"ПГР.*":
       if SearchInArray(bindVOC, tmp, True, 1)<1:
         Message("Справочник '"+tmp+"' не привязан к счетам учета НФА!", mtError);
         ^-1;
       fi;
     fi;
   od;
 fi;
 if uСВД and not USEВД_B and not USEВД_V and not USEВД_Z: Message("Справочник 'ВД' не привязан к счетам учета НФА!",  mtError); ^-1; fi;
 if uПГР and not USEПГРB and not USEПГРV and not USEПГРZ: Message("Справочник 'ПГР' не привязан к счетам учета НФА!", mtError); ^-1; fi;
 MascAna="";
 MascAna=Объединить(MascAna, ДОП_АНАКОД, "&");
 MascAna=Объединить(MascAna, ОТКМОЛ, "&");
 MascAna=Объединить(MascAna, МХЭ_ОТККОД_ОБЩ, "&");
 if Length(MascAna)>184: Message("Слишком большое условие отбора по аналитике!", mtWarning); ^-1; fi;
 -- 184=255-4-67 - -4['*{}] -67[условие по счетам]
 Try SUM=Saldo("{"+MascAna+"}", 1.1.100); Except Raise; ^-1; end;
 dd=ДатаРасч+1;
 СчитатьКонстантыНФА(ДатаРасч);
 Refresh(False);
 Режим=AutoRefresh;
 ToggleAutoRefresh(False);
 ShowProgress(0, "Подготовка данных...");
 Try
   ВременныйФайл=PlanVar('CACHE')+"\"+GetGUID;
   xx=TujRepBalAccount+TujRepNoNullBal+TujRepZabalance+TujRepCombinedAna;
   len=TujReport(ВременныйФайл, 1.1.100, dd, MascAcc, MascAna, "ДНФА", "", "", xx, False);
   if len>0:
     -- Подготовка
     ClearVariable(УслАНА);
     Очистить;
     ОчиститьТаблицу;
     -- Условия по аналитике
     УслАНА[01]="НФА.*";
     УслАНА[02]="М.*";
     voc=WordsCount(ДVOC, "|"); -- voc - искусственное ограничение на количество доп.справочников - не более 10
     if voc>0: for ii=1 to voc do УслАНА[ii+2]=Up(ExtractWord(ii, ДVOC, "|"))+".*"; od; fi;
     voc2=voc+2;
     -- РАБОТА...
     OpenTextJur(ВременныйФайл);
     Try
       ShowProgress(len, "Обработка информации...");
       ii=1;
       мм1=0; мм2=0;
       while not GetTransFromTextJur(aDate, aSum1, aVal1, aSum2, aVal2, aDeb, aCre, aAna, aComment) do
         ProgressPos(ii);
         ii=ii+1;
         xx=LengthOfArray(aAna);
         if xx>0:
           КОДСЧТ="";
           -- отбор по фильтру аналитике
           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;
           |  Match(КОДСЧТ, "???.????.???????.???.?.105.??.???")   : КОДСЧТ=SubStr(КОДСЧТ, 1, 30)+"???"; БЕЗУЧН=True;
           |  Match(КОДСЧТ, "???.????.???????.???.?.102.??.???")   : КОДСЧТ=SubStr(КОДСЧТ, 1, 30)+"???"; БЕЗУЧН=False;
           |  Match(КОДСЧТ, "???.????.???????.???.?.103.??.???")   : КОДСЧТ=SubStr(КОДСЧТ, 1, 30)+"???"; БЕЗУЧН=False;
           |  Match(КОДСЧТ, "ЗАБ.??.10?.??")                       : КОДСЧТ=КОДСЧТ;                      БЕЗУЧН=True;


           else КОДСЧТ="";
           fi;
           if КОДСЧТ<>"":
              svrANA=""; SUM=0.00; QUA=0.00; KOL=0.00;
              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;
              Work=True; OK=False;
              for yy=1 to voc2 do -- цикл дополнительных условий
                for jj=1 to xx do -- цикл по аналитике проводки
                  tmp=SubStr(aAna[jj], 1, 1);
                  if tmp="+" or tmp="-": aAna[jj]=SubStr(aAna[jj], 2, 255); fi;
                  if yy>2:OK=true; --
                   | true:
                     OK=Match(aAna[jj], УслАНА[yy]);
                  fi;
                  if not OK:
                    if УслАНА[yy]="ВД.*":
                      if Match(КОДСЧТ, "*.1.???.??.???"): if not USEВД_B: OK=True; fi;
                      |  Match(КОДСЧТ, "*.2.???.??.???"): if not USEВД_V: OK=True; fi;
                      |  Match(КОДСЧТ, "ЗАБ.??.10?.??") : if not USEВД_Z: OK=True; fi;
                      fi;
                    |  УслАНА[yy]="ПГР.*":
                      if Match(КОДСЧТ, "*.1.???.??.???"): if not USEПГРB: OK=True; fi;
                      |  Match(КОДСЧТ, "*.2.???.??.???"): if not USEПГРV: OK=True; fi;
                      |  Match(КОДСЧТ, "ЗАБ.??.10?.??") : if not USEПГРZ: OK=True; fi;
                      fi;
                    fi;
                  fi;
                  if OK: Break; fi;
                od;
                Work=(Work and OK);
                if not Work: Break; fi; -- проводка не соответствует условию отбора
              od;
              if Work:   -- считываем информацию если проводка соответствует условию отбора
                 КОДНФА=""; КОДУЧН=""; КОДМХЭ="";
                 ClearVariable(BLDFLD);
                 -- BLDFLD - массив для построения сортировки объектов учета - применяется при использовании дополнительных справочников
                 -- max 14 (4 обязательных рабочих поля + 10 доп.справочников )
                 -- (СЧЕТ|МХЭ|НФА|УЧН| +10 доп.справочников)
                 --    1   2   3   4   5 ... 14
                 if voc>0: BLDFLD[4+voc]=""; else BLDFLD[4]=""; fi;
                 BLDFLD[1]=КОДСЧТ;
                 -- разбор аналитики
                 for jj=1 to xx do
                   Work=True; -- для поиска дополнительных признаков
                   -- подготовка
                   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;
                   tmp=SubStr(svrANA, 1, 1);
                   if tmp="+" or tmp="-": svrANA=SubStr(svrANA, 2, 255); fi;
                   -- ищем ОБЯЗАТЕЛЬНЫЕ признаки (Work=False - признак нашли, работу в цикле завершаем)
                   if Match(svrANA, "М.*"):
                      Work=False;
                      КОДМХЭ=svrANA;
                      BLDFLD[2]=КОДМХЭ;
                   |  Match(svrANA, "НФА.*"):
                      Work=False;
                      КОДНФА=svrANA;
                      KOL=if(СЧДЕБ, QUA, -QUA);
                      if voc>0:
                         pp=SearchInArray(LSTНФА, svrANA, True, 1);
                         if pp=-1:
                            мм1=мм1+1;
                            num=InsertInArraySort(LSTНФА, svrANA);
                            BLDFLD[3]=Format("%.10d", мм1);
                            InsertInArray(REFНФА, num, BLDFLD[3]);
                         else
                            BLDFLD[3]=REFНФА[pp];
                         fi;
                      else
                         BLDFLD[3]=КОДНФА;
                      fi;
                   |  Match(svrANA, VOCИНВ+".*"):
                      Work=False;
                      КОДУЧН=svrANA;
                      BLDFLD[4]=КОДУЧН;
                   fi;
                   -- ищем ДОПОЛНИТЕЛЬНЫЕ признаки
                   if Work and voc>0:
                      for yy=1 to voc do
                        OK=Match(svrANA, УслАНА[yy+2]);
                        if OK:
                           pp=SearchInArray(LSTАНА, svrANA, True, 1);
                           if pp=-1:
                              мм2=мм2+1;
                              num=InsertInArraySort(LSTАНА, svrANA);
                              BLDFLD[4+yy]=Format("%.10d", мм2);
                              InsertInArray(REFАНА, num, BLDFLD[4+yy]);
                           else
                              BLDFLD[4+yy]=REFАНА[pp];
                           fi;
                        else
                          if УслАНА[yy+2]="ВД.*":
                            if Match(КОДСЧТ, "*.1.???.??.???"): if not USEВД_B: BLDFLD[4+yy]=""; fi;
                            |  Match(КОДСЧТ, "*.2.???.??.???"): if not USEВД_V: BLDFLD[4+yy]=""; fi;
                            |  Match(КОДСЧТ, "ЗАБ.??.10?.??") : if not USEВД_Z: BLDFLD[4+yy]=""; fi;
                            fi;
                          |  УслАНА[yy+2]="ПГР.*":
                            if Match(КОДСЧТ, "*.1.???.??.???"): if not USEПГРB: BLDFLD[4+yy]=""; fi;
                            |  Match(КОДСЧТ, "*.2.???.??.???"): if not USEПГРV: BLDFLD[4+yy]=""; fi;
                            |  Match(КОДСЧТ, "ЗАБ.??.10?.??") : if not USEПГРZ: BLDFLD[4+yy]=""; fi;
                            fi;
                          fi;
                        fi;
                      od;
                   fi;
                 od; -- Цикл по аналитике свертки
                 OK=False;
                 --
--                 OK=USE_ИНВЕНТАРНЫЙ_НОМЕР(КОДСЧТ, SUM, KOL); -- инвентарный номер необходим
                 OK=USE_ИНВЕНТАРНЫЙ_НОМЕР(КОДСЧТ, SUM, KOL, ДатаРасч, КОДУЧН, constНФА100П, constНФА_ИНВ);
                 if not OK: КОДУЧН=""; BLDFLD[4]=КОДУЧН; fi;
                 -- Формируем рабочие массивы
                 if КОДНФА<>"":
                    REFtxt="";
                    num=LengthOfArray(BLDFLD);
                    if num>0:
                       if voc<1: num=4; fi; -- нет дополнительных справочников
                       for jj=1 to num do REFtxt=REFtxt+"#"+if(BLDFLD[jj]<>"", BLDFLD[jj], " "); od;
                    fi;
                    if Length(REFtxt)>1:
                       if Pos("|", REFtxt)=1: REFtxt=SubStr(REFtxt, 2, Length(REFtxt)-1); fi;
                       num=SearchInArray(SRTFLD, REFtxt, True, 1);
                       if num=-1:
                          pp=InsertInArraySort(SRTFLD, REFtxt);
                          InsertInArray(SRTСУМ, pp, SUM);
                          InsertInArray(SRTКОЛ, pp, KOL);
                       else
                          SRTСУМ[num]=SRTСУМ[num]+SUM;
                          SRTКОЛ[num]=SRTКОЛ[num]+KOL;
                       fi;
                    fi;
                 fi; -- КОДНФА<>""
              fi; -- если проводка соответствует условию отбора (Work=True)
           fi; -- КОДСЧТ<>""
         fi; -- xx>0 [x=LengthOfArray(aAna)]
       od; -- while GetTransFromTextJur
     Finally
       CloseTextJur;
       if ExistFile(ВременныйФайл): DeleteFile(ВременныйФайл); fi;
     end; -- Try OpenTextJur
   fi; -- len>0
   --  *** ОБРАБОТКА ПОЛУЧЕННОЙ ИНФОРМАЦИИ ***
   len=LengthOfArray(SRTFLD);
   if len>0:
      num=мм1+мм2;
      if num>0:
         ВспомМассив1=мм1;
         ВспомМассив2=мм2;
         CloseProgress;
         ShowProgress(3, "Сортировка...");
         ProgressPos(1);
         SortSection(ВспомМассив1, 2, True);
         ProgressPos(2);
         SortSection(ВспомМассив2, 2, True);
         ProgressPos(3);
      fi;
      ShowProgress(len, "Расчет остатков...");
      ClearVariable(Позиции);
      for ii=1 to len do
        ProgressPos(ii);
        SUM=SRTСУМ[ii];
        KOL=SRTКОЛ[ii];
        if SUM<>0.00 or KOL<>0.00:
           ClearVariable(BLDFLD); -- BLDFLD - массив для построения сортировки объектов учета - применяется при использовании дополнительных справочников
           if voc<1:
              num=WordsCount(SRTFLD[ii],"#");
              if num>=4:
                 -- СЧЕТ|МХЭ|НФА|УЧН| +10 доп.справочников
                 --        1   2   3   4   5 ... 14
                 КОДСЧТ=Trim(ExtractWord(1, SRTFLD[ii], "#"));
                 КОДМХЭ=Trim(ExtractWord(2, SRTFLD[ii], "#"));
                 КОДНФА=Trim(ExtractWord(3, SRTFLD[ii], "#"));
                 КОДУЧН=Trim(ExtractWord(4, SRTFLD[ii], "#"));
              fi;
           else
              num=WordsCount(SRTFLD[ii],"#");
              BLDFLD[14]=""; -- max 14 (4 обязательных рабочих поля + 10 доп.справочников )
                              -- (СЧЕТ|МХЭ|НФА|УЧН| +10 доп.справочников)
                              --    1   2   3   4   5 ... 14
              if num>0:
                 BLDFLD[1]=Trim(ExtractWord(1, SRTFLD[ii], "#")); -- признак
                 BLDFLD[2]=Trim(ExtractWord(2, SRTFLD[ii], "#")); -- признак
                 Try tmp=Trim(ExtractWord(3, SRTFLD[ii], "#")); Except tmp=""; end; -- индекс массива - ссылка
                 pp=SearchInArray(REFНФА, tmp, True, 1);
                 if pp>0: BLDFLD[3]=LSTНФА[pp]; else BLDFLD[3]=""; fi;
                 BLDFLD[4]=Trim(ExtractWord(4, SRTFLD[ii], "#")); -- признак
                 if num>4: 
                    for jj=5 to num do
                      Try tmp=Trim(ExtractWord(jj, SRTFLD[ii], "#")); Except tmp=""; end; -- индекс массива - ссылка
                      pp=SearchInArray(REFАНА, tmp, True, 1);
                      if pp>0: BLDFLD[jj]=LSTАНА[pp]; else BLDFLD[jj]=""; fi;
                    od;
                 fi;
                 КОДСЧТ=BLDFLD[1];
                 КОДМХЭ=BLDFLD[2];
                 КОДНФА=BLDFLD[3];
                 КОДУЧН=BLDFLD[4];
              fi;
           fi;
           -- *** Заполнение ТАБЛИЦЫ ***
           yy=InsertFrame(Позиции, Позиции+1);
           Позиции[yy].НФА_КОД    = КОДНФА;
           Позиции[yy].НФА_ИМЯ    = Trim(Name_A(КОДНФА));
           Позиции[yy].ЕДИЗМ      = Unit(КОДНФА);
           --tmp="";
           if Match(КОДСЧТ, "???.????.???????.???.?.101.??.???")   : tmp=SubStr(КОДСЧТ, 1, 30)+"310";
           |  Match(КОДСЧТ, "???.????.???????.???.?.105.??.???")   : tmp=SubStr(КОДСЧТ, 1, 30)+"340";
           |  Match(КОДСЧТ, "???.????.???????.???.?.102.??.???")   : tmp=SubStr(КОДСЧТ, 1, 30)+"320";
           |  Match(КОДСЧТ, "???.????.???????.???.?.103.??.???")   : tmp=SubStr(КОДСЧТ, 1, 30)+"330";
           |  Match(КОДСЧТ, "ЗАБ.??.10?.??")                       : tmp=КОДСЧТ;


           else tmp="";
           fi;
           Позиции[yy].ДСЧЕТ      = tmp;
           Позиции[yy].МХЭ_ОТККОД = КОДМХЭ;
           Позиции[yy].МХЭ_ОТКИМЯ = Trim(Name_A(КОДМХЭ));
           Позиции[yy].УЧН_КОД    = Trim(КОДУЧН);
           Позиции[yy].ИНВ_КОД    = Trim(Name_A("ИНВВЕД."+КОДНФА+"."+КОДУЧН));
           Позиции[yy].СУММАП     = SUM;
           Позиции[yy].КОЛВО      = KOL;
           if KOL=0: Позиции[yy].ЦЕНА = SUM; else  Позиции[yy].ЦЕНА = Round(SUM/KOL, 6); fi;
           Позиции[yy].ДОПАНА01   = BLDFLD[05];
           Позиции[yy].ДОПАНА02   = BLDFLD[06];
           Позиции[yy].ДОПАНА03   = BLDFLD[07];
           Позиции[yy].ДОПАНА04   = BLDFLD[08];
           Позиции[yy].ДОПАНА05   = BLDFLD[09];
           Позиции[yy].ДОПАНА06   = BLDFLD[10];
           Позиции[yy].ДОПАНА07   = BLDFLD[11];
           Позиции[yy].ДОПАНА08   = BLDFLD[12];
           Позиции[yy].ДОПАНА09   = BLDFLD[13];
           Позиции[yy].ДОПАНА10   = BLDFLD[14];
           --tmp = "";
           tmp = BLDFLD[05]+" "+BLDFLD[06]+" "+BLDFLD[07]+" "+BLDFLD[08]+" "+BLDFLD[09]+" "+BLDFLD[10]+" "+BLDFLD[11]+" "+BLDFLD[12]+" "+BLDFLD[13]+" "+BLDFLD[14];
           Позиции[yy].ДОПАНАИТОГО = Trim(tmp);
           if not uДОП and Trim(ДОП_АНАКОД)<>"": Позиции[yy].ДОПАНАИТОГО=Позиции[yy].ДОПАНАИТОГО+" "+ДОП_АНАКОД; fi;
           svrANA = "";
           svrANA = Объединить(svrANA, МОЛ_ОТККОД, "&");
           svrANA = Объединить(svrANA, КОДМХЭ, "&");
           svrANA = Объединить(svrANA, КОДНФА, "&");
           svrANA = Объединить(svrANA, КОДУЧН, "&");
           svrANA = Объединить(svrANA, if(Позиции[yy].ДОПАНАИТОГО<>"", ЗаменитьРазделительНабораСлов(Позиции[yy].ДОПАНАИТОГО, " ", "&"), ""), "&");
           --tmp = "";
           tmp = "("+КОДСЧТ+"){"+svrANA+"}";
           Позиции[yy].УСЛОСТНФА   = Trim(tmp);
        fi; -- SUM<>0.00 or KOL<>0.00:
      od;
   fi;
   -- КОНЕЦ   *** ОБРАБОТКА ПОЛУЧЕННОЙ ИНФОРМАЦИИ ***
 Finally
   ClearVariable(УслАНА);
   ToggleAutorefresh(Режим);
   CloseProgress;
 end;
 РежимБыстрогоВвода(EditState);
 ^res;
end;

Proc ВыборКУДА(Iter:Integer; PrevValue:String; фМОЛ:Logical);
var num, jj, ii, len :Integer;
var element, n_element :String;
 num=0;
 if фМОЛ:element=AnaElection("МОЛ.*", False, False, PrevValue);
  | true: 
    if pos('М.Х.',МХЭ_ОТККОД_ОБЩ)=1:element=AnaElection("М.Х.*", False, False, PrevValue);-- исключаем выдачу в эксплуатацию
     | true:element=AnaElection("М.*", False, False, PrevValue);
    fi;
 fi;
 if element="": num=-1; element=PrevValue; fi;
 n_element=Trim(Name_A(element));
 if num>=0:
    ClearVariable(Buf);
    Buf[1]=if(фМОЛ, "Выбранный МОЛ", "Выбранное место")+" - только в данную строку таблицы";
    Buf[2]=if(фМОЛ, "Выбранный МОЛ", "Выбранное место")+" - во все строки таблицы";
    Buf[3]=if(фМОЛ, "Выбранный МОЛ", "Выбранное место")+" - от данной строки и до конца таблицы";
    Buf[4]=if(фМОЛ, "Выбранный МОЛ", "Выбранное место")+" - от данной строки к началу таблицы";
    num=Alternate("Выберите действие...", Buf, -1, 1, 12);
 fi;
 if num=1: ii=Iter; len=Iter;
 |  num=2: ii=1;    len=Позиции;
 |  num=3: ii=Iter; len=Позиции;
 |  num=4: ii=1;    len=Iter;
 else ii=Iter; len=Iter;
 fi;
 if фМОЛ:
    for jj=ii to len do Позиции[jj].МОЛ_КУДАКОД=element; Позиции[jj].МОЛ_КУДАИМЯ=n_element; od;
 else
    for jj=ii to len do Позиции[jj].МХЭ_КУДАКОД=element; Позиции[jj].МХЭ_КУДАИМЯ=n_element; od;
 fi;
end;

Proc УдалитьКУДА(Iter:Integer; фМОЛ:Logical);
var num, jj, ii, len :Integer;
 ClearVariable(Buf);
 Buf[1]="Удалить "+if(фМОЛ, "МОЛ", "место")+" - только в текущей строке таблицы";
 Buf[2]="Удалить "+if(фМОЛ, "МОЛ", "место")+" - во всех строках таблицы";
 Buf[3]="Удалить "+if(фМОЛ, "МОЛ", "место")+" - от данной строки и до конца таблицы";
 Buf[4]="Удалить "+if(фМОЛ, "МОЛ", "место")+" - от данной строки к началу таблицы";
 num=Alternate("Выберите действие...", Buf, -1, 1, 12);
 if num=1: ii=Iter; len=Iter;
 |  num=2: ii=1;    len=Позиции;
 |  num=3: ii=Iter; len=Позиции;
 |  num=4: ii=1;    len=Iter;
 else ii=Iter; len=Iter;
 fi;
 if фМОЛ:
    for jj=ii to len do Позиции[jj].МОЛ_КУДАКОД=""; Позиции[jj].МОЛ_КУДАИМЯ=""; od;
 else
    for jj=ii to len do Позиции[jj].МХЭ_КУДАКОД=""; Позиции[jj].МХЭ_КУДАИМЯ=""; od;
 fi;
end;

Proc ПроверитьСторно;
var sum :Numeric;
var Режим :Logical;
 if Проводить:
    Режим=AutoRefresh;
    ToggleAutoRefresh(False);
    Refresh(False, ДАТАОПЕР+1);
    sum=Turn("ЗАБ.НФА.ОШИБКИ{"+"ДНФАId2.0"+Str16(RecordToInteger(Current))+"}", ДАТАОПЕР, ДАТАОПЕР+1);
    if sum>0.00: btnError.Visible=True; else btnError.Visible=False; fi;
    ToggleAutoRefresh(Режим);
 else
    btnError.Visible=False;
 fi;
end;

Proc ПоказатьСтрокиСошибкамиСторно;
var Режим :Logical;
var sum :Numeric;
var Iter, jj, num :Integer;
  Режим=AutoRefresh;
  ToggleAutoRefresh(False);
  Refresh(False, ДАТАОПЕР+1);
  sum=Turn("ЗАБ.НФА.ОШИБКИ{"+"ДНФАId2.0"+Str16(RecordToInteger(Current))+"}", ДАТАОПЕР, ДАТАОПЕР+1);
  jj=0;
  if sum>0.00:
    ClearVariable(Buf);
    ClearVariable(Txt);
    for Transaction Iter="ЗАБ.НФА.ОШИБКИ{"+"ДНФАId2.0"+Str16(RecordToInteger(Current))+"}", ДАТАОПЕР, ДАТАОПЕР+1 do
      if TransDeb(Iter)="ЗАБ.НФА.ОШИБКИ":
        jj=jj+1;
        Buf[jj]="Строка N' "+Str(jj)+". "+TransComment(Iter);
        Txt[jj]=Str(jj);
      fi;
    od;
    num=AlternateTree("Сторнированные по ошибке проводки...", Buf, -1, 1, 12, "|", "", "");
    if num>0:
       Template.Field="NN";
       Template.Frame=Int(Txt[num]);
    fi;
  else
    Message("Ошибки не найдены!^MВозможно ошибка обновления данных.^MПеречитайте данную запись!", mtInformation);
    btnError.Visible=False;
  fi;
  ToggleAutoRefresh(Режим);
end;


Proc ФиксироватьШапку(flg:Logical);
   Template.Field="Фокус";
   if flg:
      Template.Freeze(asInteger(СекцТАБЗ.Column(2, ColLeft, "")), asInteger(СекцТАБЗ.Row(2, RowTop, "")));
   else
      Template.Freeze(0, 0);
   fi;
   Template.Field="Фокус";
end;

Proc ВыбратьДопПризнак(Iter:Integer);
var tmp, mask :String;
var num, jj, ii, len :Integer;
  tmp=ПроверкаСчетов(Позиции[Iter].ДСЧЕТ);
  if tmp=" ":
     Message("Счет '"+tmp+"'^M отсутствует в структуре учета!", mtWarning);
     Template.Field="ДСЧЕТ";
     Template.Frame=Iter;
     Exit;
  fi;
  mask=МаскаОбязательныхСправочников(tmp, Позиции[Iter].ДОПАНАИТОГО);
  if mask="": Message("Аналитические признаки не требуются!", mtInformation); Exit; fi;
  tmp=AnaElection(mask);
  if tmp="": Exit; fi;
  -- ***
  ClearVariable(Buf);
  Buf[1]="Добавить значение в текущую ячейку";
  Buf[2]="Добавить значение во все ячейки таблицы";
  num=Alternate("Выберите действие...", Buf, -1, 1, 12);
  if num=1: ii=Iter; len=Iter;
  |  num=2: ii=1;    len=Позиции;
  else Exit;
  fi;
  for jj=ii to len do 
    Позиции[jj].Призн=ДобавитьПризнак(Позиции[jj].Призн, tmp);
    Позиции[jj].Призн=СортироватьНаборСлов(Позиции[jj].Призн, " ", True);
  od;
end;

Proc СформироватьНакладную;
var ii, num, len :Integer;
var NoNill, Work :Logical;
var tmp, МОЛref :String;
  num=Позиции;
  NoNill=False; Work=False;
  МОЛref="";
  ClearVariable(Buf);
  if num>0:
     for ii=1 to num do
       if not (Позиции[ii].ИСКЛ):
         tmp=Позиции[ii].МОЛ_КУДАКОД+"--"+Name_A(Позиции[ii].МОЛ_КУДАКОД);
         if SearchInArray(Buf, tmp, True, 1)=-1:
            InsertInArraySort(Buf, tmp);
         fi;
       fi;
     od;
     num=0;
     len=LengthOfArray(Buf);
     if len=1:
        NoNill=True;
        Work=True;
        МОЛref=SubStr(Buf[1], 1, Pos("--", Buf[1])-1);
     |  len>1:
        NoNill=True;
        num=AlternateTree("Формирование накладной. Выберите МОЛ [куда]...", Buf, -1, 1, 12, "--", "КОД" , "Ф.И.О.", 20, False);
        if num>0: Work=True; МОЛref=SubStr(Buf[num], 1, Pos("--", Buf[num])-1); fi;
     fi;
  fi;
  if Work:
     РАБ.УПП.LIB.ИмяБланка="НФА.ЖУР.ВНУТР_ПЕРЕМЕЩЕН";
     ClearVariable(РАБ.УПП.LIB.TempSTR);
     ClearVariable(РАБ.УПП.LIB.TempREC);
     РАБ.УПП.LIB.TempSTR[1]=МОЛref;
     РАБ.УПП.LIB.TempREC[1]=Current;
     OpenBlank("РАБ.ВСПОМ.ОКУД_0306032", True);
     ClearVariable(РАБ.УПП.LIB.TempSTR);
     ClearVariable(РАБ.УПП.LIB.TempREC);
     ClearVariable(РАБ.УПП.LIB.ИмяБланка);
  fi;
  if not NoNill and not Work:
    Message("Таблица пустая!^MНе сделан расчет либо по выбранному условию отбора нет данных!", mtWarning);
    Template.Object="btnCalc";
  fi;
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КОД+".");
   ДОП_АНАКОД="";
   ДОП_АНАИМЯ="";
 fi;
end;

Proc ВыборДопПризнака(VOCname:String; onExit:Logical);
var Путь, StoreANA, NewValue, tmp :String;
var SaveValue :Logical;
var num, kk :Integer;
var Отч1 :Report;
 if Trim(VOCname)="":
   Message("Не выбран доп. справочник для отбора!", mtConfirmation);
   Template.Field="ДОП_VOCКОД_";
   Exit;
 fi;
 if Name_A(VOCname+".")=" ":
   Message("Справочника '"+VOCname+"' не существует!", mtError);
   Template.Field="ДОП_VOCКОД_";
   Exit;
 fi;
 SaveValue=False;
 StoreANA=ДОП_АНАКОД;
 if onExit:
   NewValue="";
 else
   Refresh(False);
   Путь=PlanVar("НФА")+"\ОТЧЕТЫ\НФАОТЧ2007.lst";
   if not ExistFile(Путь): Message("Файл с отчетами отсутствует!", mtError); Exit; fi;
   ClearVariable(Buf);
   ClearVariable(BufMsk);
   ClearVariable(BufStr);
   Try
     Отч1=RepOpen(Путь+"|По_признакам_БАЛиЗАБ", "*.101*|*.102*|*.103*|*.105*|*.106*", "", 1.1.100, if(ДАТАОПЕР>1.1.2000, ДАТАОПЕР, ToDay), "", VOCname);
     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
     Message("Ошибка создания отчета!", mtError);
     Raise;
   end;
   InsertInArray(BufStr, 1, "");
   InsertInArray(BufMsk, 1, "");
   InsertInArray(Buf,    1, "*--Выбор признака из списка");
   num=LengthOfArray(BufMsk);
   if num>0:
     kk=SearchInArray(BufMsk, StoreANA, False, 1);
     num=AlternateTree("Выберите дополнительный признак...", Buf, -1, kk, 12, "#", "Код признака", "Расшифровка кода", -1, False);
     if num<1: Exit;
     |  num=1:
       RefreshAna;
       tmp=AnaElection(VOCname+".*", False, False, StoreANA);
       if tmp="": Exit; fi;
       NewValue=tmp;
     else
       NewValue=BufMsk[num];
     fi;
   fi;
 fi;
 if NewValue<>StoreANA: if not ОтменитьИзмененияУсловийОтчета: SaveValue=True; fi; fi;
 if SaveValue:
   ДОП_АНАКОД=NewValue;
   ДОП_АНАИМЯ=Trim(Name_A(ДОП_АНАКОД));
 fi;
end;

2-- События клеток
Func Field_onEnter(Field:String; Iter:Integer): Logical; -- на входе в клетку
 if Field="ДАТАОПЕР"      : OldDate=ДАТАОПЕР;
 |  Field="VOC_CALC_ОСТ_" : StoreANA=VOC_CALC_ОСТ;
                            VOC_CALC_ОСТ=ДобавитьСправочникОстатков(VOC_CALC_ОСТ);
                            if VOC_CALC_ОСТ<>StoreANA: if ОтменитьИзмененияУсловийОтчета: VOC_CALC_ОСТ=StoreANA; fi; fi;
                            СформироватьСтолбцыАналитики(VOC_CALC_ОСТ);
                            ^False;
 |  Field="МОЛ_ОТККОД_"   : StoreANA=МОЛ_ОТККОД;
                            МОЛ_ОТККОД=ВыборМОЛ(МОЛ_ОТККОД);
                            if МОЛ_ОТККОД<>StoreANA: if ОтменитьИзмененияУсловийОтчета: МОЛ_ОТККОД=StoreANA; fi; fi;
                            ^False;
 |  Field="МХЭ_ОТККОД_ОБЩ_": StoreANA=МХЭ_ОТККОД_ОБЩ;
                            МХЭ_ОТККОД_ОБЩ=ВыборМ(МХЭ_ОТККОД_ОБЩ);
                            if МХЭ_ОТККОД_ОБЩ<>StoreANA: if ОтменитьИзмененияУсловийОтчета: МХЭ_ОТККОД_ОБЩ=StoreANA; fi; fi;
                            ^False;
 |  Field="ИСКЛ"          : Позиции[Iter].ИСКЛ = not Позиции[Iter].ИСКЛ;
                            ^False;
 |  Field="МОЛ_КУДАКОД"   : ВыборКУДА(Iter, Позиции[Iter].МОЛ_КУДАКОД, True);
                            ^False;
 |  Field="МХЭ_КУДАКОД"   : ВыборКУДА(Iter, Позиции[Iter].МХЭ_КУДАКОД, False);
                            ^False;
 |  Field="ПРИЗН_"        : ВыбратьДопПризнак(Iter);
                            ^False;
 |  Field="ДОП_VOCКОД_"   : ВыборДопСправочника(False); ^False;
 |  Field="ДОП_АНАКОД_"   : ВыборДопПризнака(ДОП_VOCКОД, False); ^False;
 fi;
 ^True;
end;

Proc Field_onExit(Field:String; Iter:Integer); -- на выходе из клетки
 if Field="ДАТАОПЕР"      : if ДАТАОПЕР<>OldDate: if ОтменитьИзмененияУсловийОтчета: ДАТАОПЕР=OldDate; fi; fi;
 |  Field="VOC_CALC_ОСТ_" : StoreANA=VOC_CALC_ОСТ;
                            VOC_CALC_ОСТ=УдалитьСловоИзНабора_Диалог(VOC_CALC_ОСТ, "|");
                            if VOC_CALC_ОСТ<>StoreANA: if ОтменитьИзмененияУсловийОтчета: VOC_CALC_ОСТ=StoreANA; fi; fi;
                            СформироватьСтолбцыАналитики(VOC_CALC_ОСТ);
 |  Field="МОЛ_ОТККОД_"   : StoreANA=МОЛ_ОТККОД;
                            МОЛ_ОТККОД=УдалитьСловоИзНабора_Диалог(МОЛ_ОТККОД, "|");
                            if МОЛ_ОТККОД<>StoreANA: if ОтменитьИзмененияУсловийОтчета: МОЛ_ОТККОД=StoreANA; fi; fi;
 |  Field="МХЭ_ОТККОД_ОБЩ_": StoreANA=МХЭ_ОТККОД_ОБЩ;
                            МХЭ_ОТККОД_ОБЩ=УдалитьСловоИзНабора_Диалог(МХЭ_ОТККОД_ОБЩ, "|");
                            if МХЭ_ОТККОД_ОБЩ<>StoreANA: if ОтменитьИзмененияУсловийОтчета: МХЭ_ОТККОД_ОБЩ=StoreANA; fi; fi;
 |  Field="МОЛ_КУДАКОД"   : УдалитьКУДА(Iter, True);
 |  Field="МХЭ_КУДАКОД"   : УдалитьКУДА(Iter, False);
 |  Field="ПРИЗН_"        : Позиции[Iter].Призн=УдалитьСловоИзНабора_Диалог(Позиции[Iter].Призн, " ");
 |  Field="ДОП_VOCКОД_"   : ВыборДопСправочника(True);
 |  Field="ДОП_АНАКОД_"   : ВыборДопПризнака(ДОП_VOCКОД, True);
 fi;
end;

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

Func Номер_onLookup(Sect:String; Row:Integer; Col:Integer; Cur:String) :String;
 Template.HideEditor(False);
 Номер=РАБ.НФА.FUNC_LIB.NextNumToDateInF(SelfCRD, "НОМЕР", "ДАТАОПЕР", "Ukey<>"+RecordToString(Current), 1.1.100);
 НомерБум=Str(Номер);
 ^"";
end;

2-- События объектов
Proc cbПроводить_onChange(Sender:String);
var Flag, SaveOK :Logical;
var qq :Integer;
 if Проводить=False:
    SaveOK=True; -- если защита 'снимается' значит проверка данных уже производилась
    qq=EnqOkCancel("Вы действительно хотите исключить данный документ из обработки?", mtConfirmation);
    if qq=cmCancel: Flag=True; else Flag=False; fi;
 else
    SaveOK=ПроводитьOK;
    Flag=SaveOK;
 fi;
 Проводить=Flag; cbПроводить.State=Проводить;
 ТолькоЧтение(Flag);
 if not SaveOK: Exit; fi; -- Избегаем двойных сообщений
 EditorApply;
 ПроверитьСторно;
end;

Proc cbEditState_onChange(Sender:String);
 РежимБыстрогоВвода(EditState);
end;

Proc cbФиксШапка_onChange(Sender:String);
 ФиксироватьШапку(ФиксШапка);
end;

Proc btnOnClick(Sender:String); -- объекты при нажатии
var num :Integer;
 if Sender="btnClose": if not Проводить: EditorCancel; fi; Close;
 |  Sender="btnCalc" : num=РасчетОстатковМОЛ(МОЛ_ОТККОД, VOC_CALC_ОСТ, ДАТАОПЕР);
                       ТолькоЧтение(False);
                       Template.Field="Фокус";
                       if num=0 and Позиции=0: Message("Расчет завершен!^MДанных по текущему условию отбора не найдено!", mtInformation); fi;
 |  Sender="btnError": ПоказатьСтрокиСошибкамиСторно;
 |  Sender="btnRep"  : СформироватьНакладную;
 fi;
end;

2-- События шаблона
Proc Template_OnOpen(Create:Logical); -- при открытии шаблона
var tmp :String;
 EnableCommands(False, cmDublRec);
 tmp=UserName(AliasName("РПО_НФА"));
 Пользов=if(tmp<>"", "Пользователь - "+tmp, "Пользователь локальной версии");
 РАБ.НАСТР_ПЕЧАТЬ.Cfg(PlanVar('НФА')+'\Настройки\',"RPO_STD_000"); -- стандартная настройка
 ЦветаПолей;
 First=True;
end;

Proc Template_AfterOpen(Create:Logical); -- при открытии шаблона
 SQLver=SQLЗапросыРазрешены;
 if First:
   if NewREC:
     ДатаОпер=ToDay;
     Номер=РАБ.НФА.FUNC_LIB.NextNumToDateInF(SelfCRD, "НОМЕР", "ДАТАОПЕР", "Ukey<>"+RecordToString(Current), 1.1.100);
     НомерБум=Str(НОМЕР);
     Проводить=False;
   fi;
   СформироватьСтолбцыАналитики(VOC_CALC_ОСТ);
   ПроверитьСторно;
   РежимБыстрогоВвода(EditState);
   ТолькоЧтение(Проводить);
   ФиксироватьШапку(ФиксШапка);
   СчитатьКонстантыНФА(ДатаОпер);
   Template.Field="Фокус";
 fi;
 First=False;
end;

Proc Template_OnClose(Destroy:Logical); -- при закрытии шаблона
 ClearVariable(BufField); ClearVariable(BufColorBg); ClearVariable(BufColorFo);
 Очистить;
 if CurrentState=CrdusUndefined: Destroy=True; fi;
end;

Proc Template_onRead; -- при считывании шаблона
 Очистить;
 if First=False:
   if NewREC:
     ДатаОпер=ToDay;
     Номер=РАБ.НФА.FUNC_LIB.NextNumToDateInF(SelfCRD, "НОМЕР", "ДАТАОПЕР", "Ukey<>"+RecordToString(Current), 1.1.100);
     НомерБум=Str(НОМЕР);
     Проводить=False;
   fi;
   СформироватьСтолбцыАналитики(VOC_CALC_ОСТ);
   ПроверитьСторно;
   РежимБыстрогоВвода(EditState);
   ТолькоЧтение(Проводить);
   ФиксироватьШапку(ФиксШапка);
   СчитатьКонстантыНФА(ДатаОпер);
   Template.Field="Фокус";
 fi;
end;

Proc Template_onCancel; -- при отмене редактирования шаблона
 Очистить;
 if CurrentState=CrdusUndefined:
   Message("Была произведена отмена редактирования!^MВ картотеке нет записей, бланк будет закрыт.", mtInformation);
   Close;
 fi;
end;

Func Template_OnValidate: Logical; -- при проверке шаблона
var qq :Integer;
var SaveOK :Logical;
 if not NewREC: if not TemplateSaveOK: ^False; fi; fi;
 if NewREC and not Проводить:
   if not TemplateSaveOK: ^False; fi;
   qq=EnqOkCancel("Провести данный документ по учету?", mtConfirmation);
   if qq=cmOk:
     SaveOK=ПроводитьOK;
     Проводить=SaveOK;
     cbПроводить.State=Проводить;
     ТолькоЧтение(SaveOK);
   fi;
 fi;
 VOC_CALC_ОСТ=VOC_CALC_ОСТ_;
 МОЛ_ОТКИМЯ=МОЛ_ОТКИМЯ_;
 ^True;
end;

var КнМОЛ:s='';
var КнМ:s='';
var КнМОЛК:s='';
var КнМК:s='';
var ForSelect[]:s;
var ForSelectN[]:n;
var ForSelectN1[]:n;

2Func РасчетОстатков0(СПР:s;УслОстатков:s):s;-- вычисляет остатки по нескольким справочникам сразу
 var j,k,t :i;
 var ncol,nsum:n;
 var ss,услсч,Путь,Имяотчета:s;
 var r:report;
 var auto,rep:l;

 ClearVariable(ForSelect);
 ClearVariable(ForSelectN);
 ClearVariable(ForSelectN1);
   auto=автообработка;
   rep =ОбработкаРеп ;
   РАБ.НФА.B01.set_all_auto(auto,rep,false);
   РАБ.НФА.B01.Reset_all_auto(auto,rep,false);

     Путь     =PlanVar("НФА")+"\Отчеты\НФАОТЧ.lst";
     Имяотчета="Отчет (бланки, не менять!!!)";
     услсч="*.101.*|*.102.*|*.103.*|*.105.*";
       r=RepOpen(Путь+"|"+ИмяОтчета,услсч,СПР+'.*&'+УслОстатков, ДАТАОПЕР, ДАТАОПЕР+1,'',СПР);

        RepReset(r);
        while RepNext(r) do
          ss= trim(RepIdent(r));
              nsum=RepSalDof(r,отчСверн,"РУБ");
              ncol=RepSalDof(r,отчСверн,"КОЛ");
              if nsum<>0 or ncol<>0:
                 addinarray(ForSelect,true,false,ss);
--                 jj=ПоискВмассиве(ForSelect,ss,true);
--                 if jj<1:jj=ВставитьВмассивСорт(ForSelect,ss);
--                         ВставитьВмассив(ForSelectN,jj,ncol);
--                         ВставитьВмассив(ForSelectN1,jj,nsum);
--                         j=j+1;
--                  | true:ForSelectN[jj] =ForSelectN[jj] +ncol;
--                         ForSelectN1[jj]=ForSelectN1[jj]+nsum;
--                 fi;
              fi;
        od;
       r=RepClose(r);
   j=ДлинаМассива(ForSelect);
   for k=1..j do
     ForSelect[k]=ForSelect[k]+' '+Name_A(ForSelect[k]);
   od;
   if j=0:Message('Отсутствуют остатки для параметра'+chr(13)+СПР,mtWarning);^'';
    | j=1:
     ^ВыделитьСлово(1,ForSelect[1],' ');
    | j>1: t=Альтернатива(Name_A(СПР+'.'),ForSelect,-1,0,12);
           if t>0:^ВыделитьСлово(1,ForSelect[t],' ');
           fi;
           Message('Отказ от выбора для параметра'+chr(13)+СПР,mtWarning);^'';
   fi;
^'';
2end0;

Proc ВыборКУДА_ШАПКА(фМОЛ:Logical);
var num,jj:Integer;
 num=0;
 if num>=0:
    ClearVariable(Buf);
    Buf[1]="Выход без изменений";
    Buf[2]=if(фМОЛ, "Оставить МОЛ", "Оставить место")+"  без изменений (проставить во всей таблице одинаково)";
    num=Alternate("Выберите действие...", Buf, -1, 1, 12);
 fi;
 if num<2: Exit;fi;
 if фМОЛ:
    for jj=1 to Позиции do Позиции[jj].МОЛ_КУДАКОД=МОЛ_ОТККОД; Позиции[jj].МОЛ_КУДАИМЯ=МОЛ_ОТКИМЯ_; od;
 else
    for jj=1 to Позиции do Позиции[jj].МХЭ_КУДАКОД=Позиции[jj].МХЭ_ОТККОД; Позиции[jj].МХЭ_КУДАИМЯ=Позиции[jj].МХЭ_ОТКИМЯ; od;
 fi;
end;

Функ кн_ПриВходе(Поле: Строка; Итер: Целое): Логич;
 var УслОстатков:s;
 var УслМОЛ,УслМ,ss:s;
  УслМ  =МХЭ_ОТККОД_ОБЩ;
  УслМОЛ=МОЛ_ОТККОД;
 if Поле='кнМОЛ':
     УслМОЛ='МОЛ.*';
     УслОстатков=Раб.НФА.B01.ab(УслМ,'&',УслМОЛ);
     ss=2РасчетОстатков0('МОЛ',УслОстатков);
  | Поле='кнМ':
     УслМ='М.*';
     УслОстатков=Раб.НФА.B01.ab(УслМ,'&',УслМОЛ);
     ss=2РасчетОстатков0('М',УслОстатков);
 fi;
 if Поле='кнМОЛ':МОЛ_ОТККОД=ss;
  | Поле='кнМ'  :МХЭ_ОТККОД_ОБЩ=ss;
 fi;
 if Поле='кнМОЛк':ВыборКУДА_ШАПКА(True);
  | Поле='кнМк'  :ВыборКУДА_ШАПКА(False);
 fi;
 ^false  ;
end;
--  RECCRD       :INTEGER; --ссылка на картотеку CRD
--  CRD          :STRING; --ссылка на картотеку по ее имени
--  BLNCRD       :STRING; --Бланк редактор картотеки родителя CRD


Функ список_ПриВходе(Поле: Строка; i: Целое): Логич;
 var tempS,tempS1,tempS2,ss0,sss:s;
 var wa,y,t,j:i;
     tempS =РАБ.НФА.B01.ПолеПоПризнакуС(ДОК[i].ВидДОК,'КАРТИМЯ');
     tempS1=РАБ.НФА.B01.ПолеПоПризнакуС(ДОК[i].ВидДОК,'КАРТУСЛ');
     if длина(tempS1)>0:tempS2='('+tempS1+') and ';fi;
     wa=OpenWorkArea(tempS,'',tempS2+'RECCRD='+str(ЗаписьКчислу(Текущая)));
     y=Записей(wa);
     if y=0:t=0;
      | y=1:t=1;
      | y>1:t=ВзятьНомерЗаписи(wa,ЧислоВЗапись(ДОК[i].UKEYCRD));
            if t=0:t=1;fi;
     fi;
--     t=ВзятьНомерЗаписи(wa,ЧислоВЗапись(ДОК[i].UKEYCRD));
     if t=0:
       BeginChanging(wa);
        t=ВставитьЗапись(wa);
 --       t=ЗаписатьПолеС(wa,t,'ДНФАID','ДНФАID.'+str16(ЗаписьКчислу(Текущая)));
        t=ЗаписатьПолеЦ(wa,t,'RECCRD',ЗаписьКчислу(Текущая));
        t=ЗаписатьПолеС(wa,t,'CRD',SelfCRD);
        t=ЗаписатьПолеС(wa,t,'BLNCRD','НФА.ЖУР.ВНУТР_ПЕРЕМЕЩЕН');

        if КоличествоСлов(tempS1,'=')>1:-- если фильтр вида поле="значение", то прописываем это значение по полю :)
             ss0=ВыделитьСлово(2,tempS1,'=');
             sss=ВыделитьСлово(1,ss0,'"');
             if длина(sss)=0:sss=ВыделитьСлово(1,ss0,"'");fi;
             t=ЗаписатьПолеС(wa,t,ВыделитьСлово(1,tempS1,'='),sss);
        fi;
        ДОК[i].UKEYCRD=ЗаписьКЧислу(ВзятьКлючЗаписи(wa,t));
       EndChanging(wa);
      | true:
        j=ЗаписьКЧислу(ВзятьКлючЗаписи(wa,t));
        if ДОК[i].UKEYCRD<>j:ДОК[i].UKEYCRD=j;fi;--проверка и восстановление ссылки на документ
     fi;
     CloseWorkArea(wa);
     if pos('НФА.ДОКУМЕНТЫ.АКТЫ.',up(ДОК[i].ВидДОК))=8:ЗаписатьПеременнуюС(SubStr(ДОК[i].ВидДОК,8,250)+'.NewRECbln',SubStr(ДОК[i].ВидДОК,8,250));fi;

     if y>1:
        sss=tempS2+'RECCRD='+str(ЗаписьКчислу(Текущая));
        tempS2=РАБ.НФА.B01.ПолеПоПризнакуС(ДОК[i].ВидДОК,'КАРТБРО');
        tempS2=РАБ.НФА.B01.ВзятьBROизКартотеки(tempS2);
        if tempS2<>'':ОткрытьКартотеку(tempS2,'--'+sss);
         | true:ОткрытьКартотеку(tempS,'--'+sss);
        fi;
      | true:OpenBlank(SubStr(ДОК[i].ВидДОК,8,250),false,ЧислоВЗапись(ДОК[i].UKEYCRD));
     fi;

  Возврат false ;
end;

proc ПриИзменении(s:s);
var ii:i;
var l:l;
2-- блок обработки до проверки разрешения на изменения
 if s='ФлCopyClosedModFob':
     if not ClosedModFob:ClosedModFob=true;--CurrentRecord=Current;--блокировка от удаления
      | true:-- надо снять флаг
        Раб.SQL.SetClosedModFobUpdateOnBlankEditor_false(ИМЯКРТ,current,5,SQLver,false);
     fi;
     РедакторПрименить;
     ФлCopyClosedModFob.State=CopyClosedModFob;
     exit;
 fi;
end;


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