************
*
* Назначение.:  Справочник запасов
*
******

// Copyright (c) 1993-2005 "Компания БЭСТ". Все права сохраняются.

#include "sc_all.ch"
#include "s_field.ch"
#include "inkey.ch"
#include "task.ch"
#include "sclad.ch"
#Include "my.ch"
#Include "my_new.ch"
#Include "real.ch"
#include "s_refer.ch"   // Вася 8 декабря 2004
#ifndef __HARBOUR__
#define         KS_F2                     CHR(0)   + CHR(60)
#else
#define         KS_F2                     -1
#endif

#IFDEF YES_REAL
 Static lReal := .T.
#ELSE
 Static lReal := .F.
#ENDIF

STATIC lIsNomer := .F.

#DEFINE __SCHET   SUBSTR(cNext,7,10)
#DEFINE __SCLAD   SUBSTR(cNext,1,6)
#DEFINE __CODE    SUBSTR(cNext,17,6)
#DEFINE __DATE    CTOD(SUBSTR(cNext,23,8))
#DEFINE __DATE_K  CTOD(SUBSTR(cNext,31,8))
#DEFINE __TIME    SUBSTR(cNext,39,8)
#DEFINE __STATUS  SUBSTR(cNext,47,1)

STATIC bPost:={||VpostLabel()}
STATIC bPostHelp:={||FIELDPUT(FIELDNUM('Grup'),aIn[1])}
STATIC sPrim:=.T.
STATIC cSaveScrDisp
STATIC aStSchet
STATIC cStPre := ""
STATIC aGlobalUchet := {},lRunLabel := .F., lRunShFact := .F.
STATIC lsClearPartner := .F.

//--------------------------------------------------------------------------//
FUNCTION Label(lMode,cPath)
//--------------------------------------------------------------------------//
//lMode:=.T.-режим номенклатурного справочника,.F.-архив
LOCAL aSetKey:=SaveSetKey()
LOCAL cScreen:=SAVESCREEN()
LOCAL cHead:=IF(lMode,'Номенклатурный справочник','Архив номенклатурных номеров')
LOCAL cHead1:='', nVib
LOCAL cColHead, bPreGet, _bPreGet, bPostGet, aKeyOper := {}
LOCAL aBlockCols:={{{|| IF(EMPTY(METKA_->CREC)," ",CHR(251)) },0},{{||Grup},2},{{||NNum},8},{{||LEFT(Name,34)},22},{{||Ed},57},;
{{||StrS(Norma,13,iMGRUP->Kol_)},63},{{|| IF(iMLABEL->(FIELDPOS('Wrk_Cl'))=0.OR. EMPTY(iMLABEL->Wrk_Cl)," ","C") },0}}  // victor спецодежда
LOCAL aHeads,aPict,aWhen,aValid,aPHeads, bScrPost
LOCAL bPostRead
LOCAL aSortSeek:={;
{'- номерам ТМЦ внутри групп      ',;
{'Код группы?:','Ном. номер?: '},{'Grup','NNum'},;
'TRIM(UPPER(pStatus+aIn[1]+aIn[2]))',{'@K','@K'},;
{'ToRight(1)',NIL},{'MGrup',NIL},2},;
{'- наименованиям внутри групп ',{'Код группы?: ','Наименование?:'},;
{'Grup','Space(10)'},;
 'TRIM(UPPER(pStatus+aIn[1]+aIn[2]))',{'@K','@K'},;
 {'ToRight(1)',NIL},{'MGrup',NIL},5},;
 {'- наименованиям              ','Наименование?:','LEFT(Name,10)',;
 'TRIM(pStatus+UPPER(aIn[1]))','@K',,,3}}
LOCAL bAddSort := {|cName,nOrd|;
   IF(&(GetPrefix(cName+'_'))[2],;
          AADD(aSortSeek,{PADR('- группам,полю '+&(GetPrefix(cName+"_"))[1],26),{'Группа?:        ',TRIM(&(GetPrefix(cName+"_"))[1])+'?:'},{'IF(VALTYPE(pLastGrup)#"C",Grup,pLastGrup)',cName},'TRIM(pStatus+UPPER(aIn[1]+aIn[2]))',{'@K','@K'},{,},{'MGrupLab',},nOrd}),;
       NIL;
     );
                     }

LOCAL nTop:=5
LOCAL nBottom:=16
LOCAL cCurProc:={||GrupOut()}
LOCAL aRef:={'MGrup'}, aGetBlock
LOCAL nUniMode:=2
LOCAL bDelInit:={|| EMPTY(iMLABEL->NNUM).OR.IsKart(2)}
LOCAL bDelPost:={|| ProtokLabel(-2)}
LOCAL bScrInit, _bScrInit, _bScrPost, _bPost
LOCAL cHelp_Code:=HELP_CODE
LOCAL cFindMacro:='cFind$UPPER(TRIM(Name))'
LOCAL nLeftBrd := 0,sAltA, aHotKey := {{},{},{}}
LOCAL aBase  :=;
  {;
    {"MEMDAT",GetPrefixPath()+"MEMDAT"},;
    {GetPrefix()+'MSCLAD',IF(cPath=NIL,cPath := GetPrefixPath(),cPath)+'MSclad'},;
    {GetPrefix()+'MLabel',cPath+'MLABEL'},;
    {GetPrefix()+'MKart',cPath+'MKART'},;
    {GetPrefix()+'MSchet',cPath+'MSCHET'},;
    {GetPrefix()+'MSTRU',cPath+'MSTRU'},;
    {GetPrefix()+'SPR_PART',cPath+'SPR_PART'};
    }

HOT_CTRL({|| IF(!EOF(),IF(lMode,"┘:Закрыть номенклатурный номер","┘:Открыть номенклатурный номер"),NIL) },K_CTRL_RET,{|| CloseKart(lMode) },1)

PRIVATE pStatus:=IF(lMode,' ','1'),pSclads:=' ', nCenaN, nNumAttr:=0
PRIVATE aYes:={{' ','Нет'},{'1','Да '}},aYesF:={{'2','Нет'},{'1','Да '}} // victor спецодежда



BEGIN SEQUENCE

dbOpenBases(aBase)
iSPR_PART->(ORDSETFOCUS("TAG_NUM"))
// Признак запуска из номеклатурного справочника
SetRunLabel(.T.)

RestPar('MLab')
RestPar('Sebe')
SETBLINK(.F.)
HELP_CODE:=IF(lMode,'3.2','3.7')
IF !iNorma[2]
   aDel(aBlockCols,LEN(aBlockCols)-1)// victor спецодежда
   ASIZE(aBlockCols,LEN(aBlockCols)-1)
ENDIF
nLeftBrd:=IF(iNorma[2],1,8)    // victor спецодежда 2str
aBlockCols[LEN(aBlockCols),2] :=IF(!iNorma[2],63,77)
iMGRUP->(MakeGrupRefer('MGrupLab','aIn[1]',1))
EVAL(bAddSort,"Marka","MLABELM")
EVAL(bAddSort,"Sort","MLABELS")
EVAL(bAddSort,"Profil","MLABELP")
EVAL(bAddSort,"Razmer","MLABELR")
If iTypeGen .AND.m->lYesBarCode
   aadd(aSortSeek,;
      {'- штрих-кодам                   ',;
      'Штрих-код?: ',GetFieldBCode(),;
      'pStatus+UPPER(aIn[1])','@K XXXXXXXXXXXXX',;
      NIL,,GetTagBCode()})
EndIF
cColHead:=;
' Группа  Н/номер             Наименование ТМЦ           Ед.из '+IF(iNorma[2],' Норма запаса','')+'   '     // victor спецодежда
*12345 1234567890123 1234567890123456789012345678901234 12345 1234567890123
*12345678901234567890123456789012345678901234567890123456789012345678901234567890
InitScreen(cHead,cHead1,cColHead,'AllScreen')  //Стандартная инициализация экрана (S_LIB)
IF iKoef[2].OR.iKoef1[2]
   @ 3,3 SAY 'Группа:' COLOR COL_BROWS0
   IF iKoef[2]
      @ 3,51 SAY TRIM(iKoef[1])+':'  COLOR COL_BROWS0
   ENDIF
   IF iKoef1[2]
      @ 4,51 SAY TRIM(iKoef1[1])+':'  COLOR COL_BROWS0
   ENDIF
ELSE
   @ 3,nLeftBrd SAY 'Группа:' COLOR COL_BROWS0
ENDIF
SETCOLOR(COL_BROWSE)
@ 17, 0 SAY '╟'+REPLICATE('─',78)+'╢'
@ 17,40 SAY '┬'
@ 18,40 SAY '│'
@ 19,40 SAY '│'
@ 20,40 SAY '│'
@ 21,40 SAY '│'
@ 22,40 SAY '╧'
SETCOLOR(COL_BROWS0)

AADD(aKeyOper,{;
               {|| Razm() },;
               " Дополнительные ед. измерения    F5     ",;
               K_F5,;
               .T.;
               })
IF lMode

   AADD(aKeyOper,{;
                 {|| DispOst() },;
                 " Остатки                         F10    ",;
                 K_F10,;
                 .T.;
                 })
ENDIF
IF iMarka[2]
   @ 18,02 SAY iMarka[1]+':'
ENDIF
IF iSort[2]
   @ 19,02 SAY iSort[1]+':'
ENDIF
IF iProfil[2]
   @ 20,02 SAY iProfil[1]+':'
ENDIF
IF iRazmer[2]
   @ 21,02 SAY iRazmer[1]+':'
ENDIF
@ 20,42 SAY 'Цена остатка....:'
@ 21,42 SAY 'Цена определена :'
GetHeads(@aHeads,@aPHeads,@aPict,@aWhen,@aValid,lMode,@aRef,@aGetBlock,@_bPreGet,@bPostGet,@_bScrInit,@_bScrPost,@_bPost,@bPostRead)
bScrInit:={|| IF(_bScrInit != NIL,EVAL(_bScrInit),),sPrim:=.T.,IF(LEN(aHeads)>9,4,1)}
bPreGet:={|| IF(_bPreGet != NIL,EVAL(_bPreGet),),;
             If (iTypeGen.OR.iLabelNum=1,QHelp(,,2,UPPER(aIn[1]),'NNum',,,bPostHelp,,,,'без генерации'),NIL);
            }
bScrPost := _bScrPost
SELECT iMGRUP
MakeGrupRefer('MGrup')

IF SELECT(cSelNameTre) != 0 .AND. iNAME_TRE->(dbGoTop(),!EOF())
  AADD(aKeyOper,{;
                 {|| DispLabelTree(7,5,iMLABEL->NNOPER,COL_BROWSE) },;
                 " Иерархия                        Alt-I  ",;
                 K_ALT_I,;
                 .T.;
                 })
  HOT_ALT("I:Иерархия",K_ALT_I,{|| DispLabelTree(7,5,iMLABEL->NNOPER,COL_BROWSE) },2)
ENDIF
IF GlobalTask$'09ZR'   // victor спецодежда if
   HOT_ALT({|| "Q:Отметка спецодежды" },K_ALT_Q,{|| PutWrkCl('Metka_')  },5) // victor спецодежда
ENDIF

HOT_ALT({|| IF(IsUhetPartia(iMLABEL->GRUP,.T.),"S:Справочник партий",NIL) },K_ALT_S,{|| SprPartion(cPath,iMLABEL->GRUP,iMLABEL->NNUM,IF(lMode,NIL,.T.))  },3)


AADD(aKeyOper,{;
               {|aKey| aKey := SaveSetKey(),nVib := IF(GlobalTask$'SRZR',1,BoxMenu('[ Варианты печати ]',7,20,{"    Номенклатурный справочник   ","    Иерахия номенклатурного спр.   "},,1,,COL_SHEADR,COL_SHEADR)),RestSetKey(aKey),IF(nVib = 1,QPrint(aPHeads),IF(nVib = 2,LabelPrint(),NIL)) },;
               " Печать                          F9     ",;
               K_F9,;
               .T.;
               })


SELECT iMLABEL
ORDSETFOCUS('MLabel_S')
SET RELATION TO UPPER(Grup) INTO iMGRUP, UPPER(GRUP+NNUM) INTO iSPR_PART
SetScope('UPPER(Status)',UPPER(pStatus)  )  //VIKTOR работа по штрихкоду 22.07.97 {}

IF FIELDNUM('SCLADS')>0

  AADD(aKeyOper,{;
                 {|lAdd|  lAdd := .F.,pSclads := IF("│││" $ iMLABEL->SCLADS,(lAdd := .T.,BEFORATNUM("│││",iMLABEL->Sclads)),iMLABEL->Sclads),Comment(),IF(RecLock(),(iMLABEL->SCLADS := pSclads+IF(lAdd,"│││"+AFTERATNUM("│││",iMLABEL->SCLADS,1),""),dbUnLock()),NIL),pSclads := "" },;
                 " Комментарий                     Alt-A  ",;
                 K_ALT_A,;
                 .T.;
                 })
  HOT_ALT({|| IF(!EOF(),"A:Комментарий",NIL) },K_ALT_A,{|lAdd|  lAdd := .F.,pSclads := IF("│││" $ iMLABEL->SCLADS,(lAdd := .T.,BEFORATNUM("│││",iMLABEL->Sclads)),iMLABEL->Sclads),Comment(),IF(RecLock(),(iMLABEL->SCLADS := pSclads+IF(lAdd,"│││"+AFTERATNUM("│││",iMLABEL->SCLADS,1),""),dbUnLock()),NIL),pSclads := "" },3)
  HOT_ALT({|| IF(iYesKons .AND. !EOF(),"B:Поставщики",NIL) },K_ALT_B,{|| IF(iYesKons,(pSclads := AFTERATNUM("│││",iMLABEL->Sclads),EditPart(@pSclads),IF(RecLock(),(iMLABEL->SCLADS := IF("│││" $ iMLABEL->SCLADS,BEFORATNUM("│││",iMLABEL->SCLADS),iMLABEL->SCLADS)+"│││"+pSclads,dbUnLock()),NIL),pSclads := ""),NIL) },4)
  HOT_ALT("O:Операции",0,NIL,5)

  AADD(aKeyOper,{;
                 {|| IF(iYesKons,(pSclads := AFTERATNUM("│││",iMLABEL->Sclads),EditPart(@pSclads),IF(RecLock(),(iMLABEL->SCLADS := IF("│││" $ iMLABEL->SCLADS,BEFORATNUM("│││",iMLABEL->SCLADS),iMLABEL->SCLADS)+"│││"+pSclads,dbUnLock()),NIL),pSclads := ""),NIL) },;
                 " Поставщики                      Alt-B  ",;
                 K_ALT_B,;
                 {|| iYesKons };
                 })

   IF lMode
      ScrTitul(23,'Alt-O:Операции F5:Доп.ед.изм F10:Остатки Ctrl┘:Закр.н/ном ')
   ELSE
      ScrTitul(23,'Alt-O:Операции F5:Доп.ед.изм. Ctrl┘:Открыть н/ном')
   ENDIF
ELSE

   IF lMode
      ScrTitul(23,'Alt-O:Операции F5:Доп.ед.измерений F10:Остатки '+NA_SAX+' Ctrl┘:Закрыть н/ном')
   ELSE
      ScrTitul(23,'Alt-O:Операции F5:Доп.ед.измерений Ctrl┘:Открыть н/ном')
   ENDIF
ENDIF
GO TOP

IF GlobalTask $ "03SR" .OR. GetPrefix() == "S"
  HOT_CTRL({|| IF(!EOF(),"P:Печать этикеток",NIL) },K_CTRL_P,{|| BlankPrint() },6)
  AADD(aKeyOper,{;
                 {|| BlankPrint() },;
                 " Печать этикеток                 Ctrl-P ",;
                 K_CTRL_P,;
                 .T.;
                 })
ENDIF   // victor спецодежда    перенесен ENDIF
  AADD(aKeyOper,{;
                 {|| SetIns(!EMPTY(METKA_->CREC),"METKA_"),__KEYBOARD(CHR(K_DOWN)),NIL },;
                 " Отметить/снять отметку          Ins    ",;
                 K_INS,;
                 .T.;
                 })
  AADD(aKeyOper,{;
                 {|| SetInsAll(.T.,"METKA_") },;
                 " Снять все ометки                '-'    ",;
                 45,;
                 .T.;
                 })
  AADD(aKeyOper,{;
                 {|| SetInsAll(.F.,"METKA_") },;
                 " Выставить все отметки           '+'    ",;
                 43,;
                 .T.;
                 })

  AADD(aKeyOper,{;
                 {|| F_Eval(GlobalTask+"NomNom",'METKA_') },;
                 " Специальные функции             Ctrl_F5",;
                 K_CTRL_F5,;
                 .T.;
                 })
//SETKEY( K_CTRL_F5, {|| F_Eval(GlobalTask+"NomNom",'METKA_') } )
HOT_CTRL({|| IF(!EOF(),"CTRL_F5:Специальные функции",NIL) },K_CTRL_F5,{|| F_Eval(GlobalTask+"NomNom",'METKA_') },6)
SETKEY(K_CTRL_I,{|| InfoKart() })
IF !lMode
     AADD(aKeyOper,{;
                   {|| UdalNNum()  },;
                  " Удаление неисполь-мых номеров  Alt-F8 ",;
                    K_ALT_F8,;
                    .T.;
                    })
   HOT_ALT({|| IF(!EOF(),"F8:Удаление неиспользуемой номенклатуры",NIL) },K_ALT_F8,{||UdalNNum() },10)
ENDIF

AllKeyOper(aKeyOper,.F.)


CreateMetka(cSelLabel)

IF !lMode.OR.!_REC_YES
   ScrTitul(24,'F3:Сортировка F6,Alt-F6:Фильтр F7,Alt-F7:Поиск F8:Удалить F9:Печать')
   SETKEY(K_RETURN,{||1})
   SETKEY(K_F4,{||1})
ENDIF

RestIndex("ZS_NOM",,aSortSeek)
IF TYPE(itWork_B_Code)='L'.AND. iWork_B_Code
   QuickBC(1,1,0,GetTagBCode(),'r/w*',,'pStatus')
ENDIF


/*********

// Вася 14 декабря 2004
#ifdef __HARBOUR__
IF GlobalTask $ "03SR".OR.GetPrefix()=="S"
   HOT_ALT({|| "H:Планирование закупок" },K_ALT_H,;
     {|| SayAndWait({"Ввод значений производится в режиме","редактирования номенклатурного номера"})},3)
ENDIF
#endif

****************************/


//IF GlobalTask != "TV"
IF iMLABEL->(FieldPos("CDATTR1")) > 0
      //HOT_ALT({|| "P:Дополнительные атрибуты" },K_ALT_P,{||SayAndWait({"Ввод значений производится в режиме","редактирования номенклатурного номера"}) },4)
       HOT_ALT({|| "P:Дополнительные атрибуты" },K_ALT_P,{|| ShowDopAttr()  },4)
ENDIF
//ENDIF


InitList(nTop,nBottom,cColHead,aBlockCols,cCurProc,aHeads,aRef,;
aPict,aWhen,aValid,nUniMode,bDelInit,bScrInit,aSortSeek,aPHeads,{|| EVAL(bPost),IF(_bPost != NIL,EVAL(_bPost),NIL) },;
bDelPost,aGetBlock,{|| COL_BROWSE },{|nPoz| IF(nPoz = 1,COL_BROWSE,COL_REFER) },nLeftBrd,bScrPost,cFindMacro,,,bPreGet,bPostGet,"MLABEL_S",,aHotKey,,bPostRead)

SaveIndex("ZS_NOM")

DeleteMetka()

END SEQUENCE

AllKeyOper()
aStSchet := {}
ClearRefer()
ClosePar('MLab')
ClosePar('Sebe')
dbCloseBases(aBase)
HELP_CODE:=cHelp_Code
RESTSCREEN(,,,,cScreen)
RestSetKey(aSetKey)
// Сбросим флаги работы в справочнике
SetRunLabel(.F.)

RETURN (NIL)
//--------------------------------------------------------------------------//
                          FUNCTION EditPart(cAll)
//--------------------------------------------------------------------------//
LOCAL cNameDbf,cNameCdx
LOCAL aSt :={;
                15,5,20,15,45;
             }
LOCAL cColHead :=;
         "  Склад "+PADC("Счет",_LEN_SCHET)+"  Шифр         Поставщик          Поставка  "
LOCAL bScrInit := {|| DispBegin(),2 }
LOCAL nLeftBrd := 11
LOCAL aBlockCols := ;
                 {;
                   { {|| AGENT->STATUS  }       , 0},;
                   { {|| AGENT->SCLAD  }        , 1},;
                   { {|| AGENT->SCHET }         , 8},;
                   { {|| AGENT->CODE }          , 9+_LEN_SCHET},;
                   { {|| PADR(ANALIT->NAME,25) }, 16+_LEN_SCHET},;
                   { {|| AGENT->DATE }          , 42+_LEN_SCHET};
                 }
LOCAL aSay := {;
{ 0,0,{|| FRAME(HeadRej(MemVar->nApp,"записи"),10,6,14,65+_LEN_SCHET,COL_INPUT,2,.T.,.T.),""}},;
{11,8,"Склад..................:",COL_INPUT},;
{12,8,"Поставщик..............:",COL_INPUT},;
{13,8,"Дата последней поставки:",COL_INPUT};
            }
LOCAL aHeads := {;
 {{11,33},"SCLAD",'1','2','1'},;
 {{12,33},"SCHET",'1','2','1'},;
 {{12,38},"CODE",'1','2','1'},;
 {{13,33},"DATE"};
                }
LOCAL cScr
LOCAL aScatter
LOCAL bPreGet := {||;
       cScr := SaveScreen(),;
       AOUT(aSay),;
       IF(MemVar->nApp = S_LIB_ADD,AEVAL(MemVar->aIn,{|x,y| MemVar->aIn[y] := BLANK(x,.T.) }),NIL),;
       MemVar->aLastIn := ACLONE(aIn),;
       DispEnd();
                 }
LOCAL bPost := {|| DispBegin() }
LOCAL bPostGet := {|lSave| IF(lSave,NIL,DispBegin()) }
LOCAL bScrPost := {|| DispEnd() }
LOCAL bDelPost
LOCAL aSet := {SaveSetKey(),SaveSet()}
LOCAL aWhen := {,,{|| SaveLoadType(aIn[2]),.T.},}, aValid, aPict := {"@K XXXXXX","@K "+_PIC_SCHET,"@K XXXXXX","@D"}
LOCAL aRef := {"S_SCLAD","S_SCHET","S_CODE",}
LOCAL aGetBlock := {{|x| IF(x != NIL,aIn[1] := x, x := aIn[1]),SetPos(11,40),iMSCLAD->(dbSeek(UPPER(aIn[1]))),DispOut(PADR(iMSCLAD->SHORTNAME,25),COL_INPUT),x },,{|x| IF(x != NIL,aIn[3] := x, x := aIn[3]),SetPos(12,45),ANALIT->(dbSeek(UPPER(aIn[2]+aIn[3]))),DispOut(PADR(ANALIT->NAME,20),COL_INPUT),x },}
LOCAL cCurProc
LOCAL aSortSeek
LOCAL nActiveGet := CurrentGet()
LOCAL bDelInit
LOCAL aBase := {"ANALIT",{"PLAN","PLAN_SCH"},{GetPrefix()+"MSCLAD",GetPrefixPath()+"MSCLAD"}}
LOCAL cAgentCode
LOCAL cBakAgent := cAgentCode := RestAgent(cAll)
LOCAL xIdent := "поставка"
LOCAL cMess := "", cNext

dbPush()
BEGIN SEQUENCE
  dbOpenBases(aBase)
  SELECT(0)
  DBCREATE((cNameDbf := TEMPFILE(MemVar->GlobalTmpPath, "DBF")),;
            {             ;
             { 'STATUS',  'C',  1, 0 }, ;
             { 'SCLAD',  'C',  6, 0 }, ;
             { 'SCHET',  'C',  10, 0 }, ;
             { 'CODE',   'C',  6, 0 }, ;
             { 'DATE',   'D',  8, 0 }, ;
             { 'DATE_K', 'D',  8, 0 }, ;
             { 'TIME',   'C',  8, 0 } ;
             };
           )
  cNameCdx := LEFT(cNameDbf,AT(".",cNameDbf))+"IDX"
  NetUseExcA("AGENT",cNameDbf )
  SELECT ANALIT
  ORDSETFOCUS("CODE")
  SELECT AGENT
  INDEX ON UPPER(DTOS(FIELD->DATE_K)+FIELD->TIME+FIELD->SCLAD+FIELD->SCHET+FIELD->CODE) TAG TAG_CODE TO (cNameCdx)
  INDEX ON FIELD->STATUS TAG TAG_STATUS TO (cNameCdx)
  SET INDEX TO (cNameCdx)
  RE_OPEN_DBF
  SET RELATION TO UPPER(SCHET+CODE) INTO ANALIT

  TokenInit( @cAgentCode, ",")
  WHILE !TokenEnd()
   IF !EMPTY((cNext := TokenNext(@cAgentCode)))
     APPEND BLANK
     AGENT->STATUS:= __STATUS
     AGENT->SCLAD := __SCLAD
     AGENT->SCHET := __SCHET
     AGENT->CODE  := __CODE
     AGENT->DATE  := __DATE
     AGENT->DATE_K:= __DATE_K
     AGENT->TIME  := __TIME
   ENDIF
  END
  cAgentCode := ""

  SetKey(K_F6,{|| NIL })
  SetKey(K_TAB,{|| 0 })
  SetKey(K_F10,{|| 0 })
  SetKey(K_INS,{|| IF(!EMPTY(AGENT->STATUS),AGENT->(IF(RecLock(),(AGENT->STATUS := " ",dbUnlock()),NIL)),AGENT->(IF((dbPush(),ORDSETFOCUS("TAG_STATUS"),IF(dbSeek(CHR(251)) .AND. RecLock(),(AGENT->STATUS := " ",dbUnlock()),NIL),dbPop(),.T.).AND.RecLock(),(AGENT->STATUS := CHR(251),dbUnlock()),NIL))),2 })
  ScrTitul(MaxRow()-1,"")
  ScrTitul(MaxRow(),"┘:Правка F8:Удалить ESC:Выход Ins:Основной поставщик")

  iMSCLAD->(;
           dbSetFilter({|| iMSCLAD->TYPE = " " },cSelSclad+"->TYPE = ' '"),;
           MakeScladRefer('S_SCLAD','aIn[1]',2);
           )

  PLAN->(ReferPlan( "S_SCHET", "aIn[2]","UPPER(aIn[2])",3,"F2:Справочник "+cMess ))
  ANALIT->(SAnalit( "S_CODE", "aIn[3]", 2,"F2:Спpавочник "+cMess))

  Frame("[ Поставщики ]", 9, 10, 17, 67, COL_BROWSE, 2, .T., .T.)

  SELECT AGENT
  GO TOP
  InitList(10,16,cColHead,aBlockCols,cCurProc,aHeads,aRef,aPict,aWhen,aValid,,bDelInit,bScrInit,aSortSeek,,bPost,bDelPost,aGetBlock,{|| COL_BROWSE },{|nPoz| IF(nPoz = 1 ,COL_BROWSE,COL_REFER) },nLeftBrd,bScrPost,"AllStringBases(cFind)",COL_BROWSE,,bPreGet,bPostGet)

  ORDSETFOCUS(0)
  DBEVAL({|| cAgentCode := SaveAgent(@cAgentCode,UPPER(AGENT->SCLAD),UPPER(AGENT->SCHET),UPPER(AGENT->CODE),AGENT->DATE,,,AGENT->STATUS) })
  cAll := BEFORATNUM("{"+xIdent+":",cAll,1)+AFTERATNUM("}",AFTERATNUM("{"+xIdent+":",cAll,1),1)+"{"+xIdent+":"+cAgentCode+"}"

  dbCloseArea()
  FERASE(cNameDbf)
  FERASE(cNameCdx)

END SEQUENCE
dbCloseBases(aBase)
dbPop()
RestSetKey(aSet[1])
RestSet(aSet[2])
RETURN NIL

STATIC FUNCTION GrupOut()
LOCAL cLastColor:=SETCOLOR(COL_BROWSE)
IF iKoef[2].OR.iKoef1[2]
   IF iKoef[2]
      @ 3,64 SAY STR(iMLABEL->Koef,13,3)
   ENDIF
   IF iKoef1[2]
      @ 4,64 SAY STR(iMLABEL->Koef1,13,3)
   ENDIF
   @ 3,10 SAY iMGRUP->Name
ELSE
   @ 3,IF(!iNorma[2],17,10) SAY iMGRUP->Name
ENDIF
IF iMarka[2]
   @ 18,11 SAY iMLABEL->Marka
ENDIF
IF iSort[2]
   @ 19,11 SAY iMLABEL->Sort
ENDIF
IF iProfil[2]
   @ 20,11 SAY iMLABEL->Profil
ENDIF
IF iRazmer[2]
   @ 21,11 SAY iMLABEL->Razmer
ENDIF
@ 20,59 SAY StrS(iMLABEL->Cena,15,3)
@ 20,75 SAY IF(!EMPTY(iMLABEL->Cena),GlobalValuta,SPACE(3))
@ 21,60 SAY StrS(iMLABEL->Date)
SETCOLOR(cLastColor)
RETURN (1)

//-------------------------1------2------3-----4------5---------6------7-------8----9//      10   11     12       13        14         15       16       17
FUNCTION MakeLabelLRefer(cRefer,lInput,lSclad,nGet,nTypeRefer,cDest1,cDest2,cMess,aSource,aDest,lPlus,lOnlyNNum,lAllSpr,lOnlyNoFact,lContXran,lNoFact,lNotRazvorot)
//--------------------------------------------------------------------------//
//Если lSklad, то картотека при соответств. SET RELATION и pSclad (PRIVATE)
//Если nGet указан,то в пpед.гpуппа
// cDest 1,2 употреблять только при lInput=NIL и lSclad=NIL
// lAllSpr при работе по штрихкоду при .T. выдается полный справочник,
//                                при .F. - если указана группа, выдается только группа
// lOnlyFact - только номенклатура по учетным ценам
// lContXran - проверять схему хранения? Д.б. определен pSclad
// lNoFact - исключить группы по факт ценам
// lNotRazvorot - не разворачивать справочник при входе (Для фильтра, карточки отчета)
LOCAL aHeads,aPict,aWhen,aValid,aRef,aGetBlock
LOCAL aSortSeek:={},aInput, cFilter
LOCAL bPreGet,_bPreGet,bPostGet, aBlockCol, bPostRead
LOCAL lOst:=!(GlobalTask = '05'.AND.TYPE(itRCena)='L'.AND.!iRCena) //показывать цену остатка?
LOCAL aSet
LOCAL bAddSort := {|cName,nOrd,cSodDest|;
   IF(&(GetPrefix(cName+'_'))[2],;
       IF(iTypeGen.AND.EMPTY(cSodDest),;
       AADD(aSortSeek,{PADR('- группам,полю '+&(GetPrefix(cName+"_"))[1],26),{'Группа?:        ',TRIM(&(GetPrefix(cName+"_"))[1])+'?:'},{'pLastGrup',cName},'TRIM(SPACE(1)+UPPER(aIn[1]+aIn[2]))',{'@K','@K'},{,},{'MGrupLab',},nOrd}),;
       AADD(aSortSeek,{PADR('- полю '+&(GetPrefix(cName+"_"))[1],26),TRIM(&(GetPrefix(cName+"_"))[1])+'?:',cName,'TRIM(SPACE(1)+UPPER(pLastGrup+aIn[1]))','@K',,,nOrd})),;
       NIL;
     );
                     }
LOCAL _bPost, bScrInit,bScrPost,cScrAttr,aPrimEnter, lScope
LOCAL cNameCdx := {NIL}, lSetFilter
LOCAL bDispSpr, bDispPost, aBakTag, lRunDisp, aTag, cKey, nSizeSortSeek
LOCAL cSBTag, cSBKey
LOCAL bDispFilter :=;
 {|cPref,nOrdBC |;
  aSet := {SaveSet(),SaveSetKey()},;
  lRunDisp := .T.,;
  dbPush(),;
  ASIZE(aSortSeek,nSizeSortSeek),;
  If (lSclad == NIL,UstTagBCode(cDest1,aSortSeek,lSclad,lAllSpr,lOnlyNNum,bAddSort,lOst,@cPref,@nOrdBC,@cSBTag,@cSBKey),NIL),;
  IF(EMPTY(pLastGrup) .AND. lOnlyNoFact .AND. !IsUhetSclad(IF(iLabelNum=4,"",pSclad)),;
     (;
      lSetFilter := .T.,;
      cNameCdx[1] := NIL,;
      aBakTag := {},;
      cKey := "LabelGetRec('"+IF(iLabelNum=4,"",FIELD->GRUP)+"','"+FIELD->NNUM+"')",;
      AEVAL(aSortSeek,{|aSort,nPoz|;
        IF((lScope := nPoz = 1 .OR. ScopeMacro(aSort[8]) != ScopeMacro(aSortSeek[nPoz-1,8])),ORDSETFOCUS(aSort[8]),NIL),;
        CreateFilter(;
            IF(lScope,cSelStru+"->(dbSeek(UPPER(pSclad+"+ALIAS()+"->GRUP))) .AND. "+cSelSchet+"->(dbSeek(UPPER("+cSelStru+"->SCHET))) .AND. "+cSelSchet+"->UCHET = '1' .AND. "+cKey,".T."),;
            NIL,;
            ORDKEY(aSort[8]),;
            "TAG_"+NTOC(nPoz),;
            cNameCdx;
           ),;
        AADD(aBakTag,aSort[8]),;
        aSort[8] := "TAG_"+NTOC(nPoz);
                       };
            ),;
      IF(LEN(aSortSeek) >= 1,ORDSETFOCUS(aSortSeek[1,8]),NIL),;
      dbGoTo(LabelGetRec()),;
      dbSkip(),;
      dbSkip(-1);
      ),;
     NIL;
     ),;
  EVAL(bDispSpr),;
  If (lSclad == NIL,;
   (AADD(aPrimEnter,nOrdBC),;
    AADD(aPrimEnter,cPref)),NIL);
   }

LOCAL bPreDisp := ;
 {||;
   dbPush(),;
   lRunDisp := lSetFilter := .F.;
  }
LOCAL bPostDisp := ;
 {|lEnd,nOrd|;
  IF(lRunDisp,;
     (;
      RestSet(aSet[1]),;
      RestSetKey(aSet[2]),;
      EVAL(bDispPost,lEnd,nOrd);
      ),;
     NIL;
     ),;
  IF(lSetFilter,;
     (;
      AEVAL(aBakTag,{|cTag,nPoz| aSortSeek[nPoz,8] := cTag }),;
      DeleteFilter();
      ),;
     NIL;
     ),;
  dbPop(.T.);
  }
LOCAL bSBTag:={|nPos|;
                If ((nPos:= ASCAN(aSortSeek,{|x|'- наименованиям' $ x[1]})) > 0,;
                    aSortSeek[nPos,8] ,NIL);
               }
LOCAL bSBKey:={|nPos,cTag|;
                cTag:=If ((nPos:= ASCAN(aSortSeek,{|x|'- наименованиям' $ x[1]})) > 0,;
                          aSortSeek[nPos,8] ,NIL),;
                iIF(UPPER(cTag)='MLABEL_T',;
                    ' ',;
                    iIF(UPPER(cTag)='MLAB_ST',' '+pLastGrup,NIL));
               }
LOCAL bPreSeek_

LOCAL lVV_YesDopHeads
REQUEST kbdemulate
PRIVATE pSBTag, pSBKey
IF(ValType(lOnlyNoFact) = "L",,lOnlyNoFact := .F.)

cSaveScrDisp := NIL
lOnlyNNum = !EMPTY(lOnlyNNum)
lAllSpr = !Empty(lAllSpr)
lContXran = !EMPTY(lContXran)
lNoFact = !EMPTY(lNoFact)
lNotRazvorot = !EMPTY(lNotRazvorot)

GetHeads(@aHeads,,@aPict,@aWhen,@aValid,,@aRef,@aGetBlock,@_bPreGet,@bPostGet,@bScrInit,@bScrPost,@_bPost,@bPostRead,lContXran,lNoFact,,cRefer)
bPreGet:={|| IF(_bPreGet != NIL,EVAL(_bPreGet),),;
             sPrim:= .T.,If (iTypeGen.OR.iLabelNum=1,QHelp(,,2,UPPER(aIn[1]),'NNum',,,bPostHelp,,,,'без генерации'),NIL);
            }
aInput:=IF(lInput==NIL,NIL,aHeads)

IF (nGet==NIL)
   If lOnlyNNum
      nGet:=1
   Else
      nGet:=2
   EndIF
ENDIF
IF (nTypeRefer==NIL)
   nTypeRefer:=1
ENDIF
IF (cDest1=NIL)
   If lOnlyNNum
      cDest1:='aIn['+STR(nGet)+']'
      cDest2:='aIn['+STR(nGet)+']'
   Else
      cDest1:='aIn['+STR(nGet-1)+']'
      cDest2:='aIn['+STR(nGet)+']'
   EndIF
ENDIF
IF(ValType(aSource) = "A",NIL,aSource := {})
IF(ValType(aDest) = "A",NIL,aDest := {})
If lOnlyNNum
   AADD(aDest,cDest1)
   AADD(aSource,"NNum")
else
   AADD(aDest,cDest1)
   AADD(aSource,"VozvrGrup()")
   AADD(aDest,cDest2)
   AADD(aSource,"NNum")
EndIF
If iTypeGen.AND.m->lYesBarCode .AND. !lOnlyNNum .AND. iLabelNum # 4 .AND. !lNotRazvorot
   If ValType(cMess)='C'
#ifndef __HARBOUR__
      cMess = {,,&('{||IF(Empty('+cDest1+').AND. (TYPE("NAPP") # "N" .OR. nApp > 0),KbdEmulate("'+KS_F2+'"),NIL),"'+cMess+'"}')}
   ELSEIF Empty(cMess)
      cMess = {,,&('{||IF(Empty('+cDest1+').AND. (TYPE("NAPP") # "N" .OR. nApp > 0),KbdEmulate("'+KS_F2+'"),NIL)," F2:Справочник "}')}
#else
      cMess = {,,&('{||IF(Empty('+cDest1+').AND. (TYPE("NAPP") # "N" .OR. nApp > 0),KEYSEND('+STR(KS_F2,4,0)+'),NIL),"'+cMess+'"}')}
   ELSEIF Empty(cMess)
      cMess = {,,&('{||IF(Empty('+cDest1+').AND. (TYPE("NAPP") # "N" .OR. nApp > 0),KEYSEND('+STR(KS_F2,4,0)+'),NIL)," F2:Справочник "}')}
#endif
   EndIF
EndIF
If iTypeGen
   iMGRUP->(MakeGrupRefer('MGrupLab','aIn[1]',IF(iLabelNum=4 .AND. m->lYesBarCode,3,1)))
EndIF
IF (lSclad==NIL)

   bDispSpr := {||;
          dbPush(),;
          cScrAttr := SAVESCREEN(19,6,24,78),;
          aPrimEnter := {.T.},;
          cSaveScrDisp := NIL,;
     IIF(iMLABEL->(FieldPos("CDATTR1"))>0,ScrTitul(24,"Alt-P:Дополн.атрибуты  "),ScrTitul(24,' ')),;//          ScrTitul(24,' '),;
          RestIndex("ZI_NOM",'Без начала',aSortSeek),;
          dbSkip(),;
          dbSkip(-1),;
          IF(lInput!=NIL .AND. GetPrefix() != "T",SETKEY(K_F5,{||Razm()}),NIL);
                }
   bDispPost := {|lEnd,nOrd|;
          SaveIndex("ZI_NOM",nOrd),;
          RESTSCREEN(19,6,24,78,cScrAttr),;
          dbPop(.T.),;
          dbPop(.T.);
                 }

   aBlockCol := {{||Grup},{||NNum},{|| LEFT(Name,34)+IF(lOst,"",SPACE(16)) }}
   IF lOst
     AADD(aBlockCol,IF(GetPrefix() == "T",{||StrS(RetSumEd(FIELD->OCENA1,lPlus),15,2)},{||StrS(RetSumEd(Cena,lPlus),15,2)}))
   ENDIF
   nSizeSortSeek := LEN(aSortSeek)
   MakeRefer(cRefer,GetPrefixLabel()[1],nTypeRefer,;
   {"Группа"," Н/номер", " Наименование",IF(lOst,IF(GetPrefix() == "T","    Цена    ","Цена остатка"),"            ")},;
   {2,6,11},COL_REFER,;
    aSource,aDest,IF(iLabelNum=4,"UPPER(SPACE(1)+"+cDest2+")","UPPER(SPACE(1)+"+cDest1+"+"+cDest2+")"),;
    aBlockCol,;
    aSortSeek,aInput,aPict,aWhen,aValid,;
    {|| EVAL(bPost),IF(_bPost != NIL,EVAL(_bPost),NIL) },bPreDisp,bPostDisp,,,aRef,cMess,{|| CoProc1(lInput,lPlus,cDest1,aPrimEnter,bPreSeek_)},,,aGetBlock,;
    'cFind$UPPER(NNum+Name)',IF(iLabelNum=4,'TAG_NNUM',2),bScrInit,bScrPost,bDispFilter,,,,{{K_RETURN,{||IF(lContXran,ValidStrNNum(,lNoFact),0)}}},bPreGet,bPostGet,bPostRead,,,,,,,,,bSBTag,bSBKey)

ELSE
   If iLabelNum = 4 .AND.m->lYesBarCode
     aSortSeek:={;
     {'- группам,н/номерам ТМЦ',{'Группа?:  ','Н/номер?: '},{'pLastGrup','NNum'},;
     'UPPER(SPACE(1)+pSclad+TRIM(aIn[1]+aIn[2]))',{'@K','@K'},{,},{'MGrupLab',},"MKART_SN"},;
     {'- группам,наименованиям',{'Группа?:      ','Наименование?:'},{'pLastGrup','Name'},;
     'UPPER(SPACE(1)+pSclad+TRIM(aIn[1]+aIn[2]))',{'@K','@K'},{,},{'MGrupLab',},"MKART_ST"};
                 }
      aadd(aSortSeek,;
           {'- наименованиям','Наименование?:','Name',;
           'UPPER(SPACE(1)+pSclad+TRIM(aIn[1]))','@K',,,'MKART_SA'})
           pSBTag:='MKART_SA'
           pSBKey:={||UPPER(SPACE(1)+pSclad)}
      aadd(aSortSeek,;
         {'- штрих-кодам                   ',;
         'Штрих-код: ','NNum',;
         'SPACE(1)+UPPER(pSclad+aIn[1])','@K',;
         NIL,,'MKART_BC'})
   Else
     aSortSeek:={;
     {'- н/номерам ТМЦ','Н/номер?:','NNum',;
     'UPPER(SPACE(1)+pSclad+TRIM(pLastGrup+aIn[1]))','@K',,,"MKART_SN"},;
     {'- наименованиям','Наименование?:','Name',;
     'UPPER(SPACE(1)+pSclad+TRIM(pLastGrup+aIn[1]))','@K',,,"MKART_ST"};
     }
      pSBTag:='MKART_ST'
      pSBKey:={||UPPER(SPACE(1)+pSclad+pLastGrup)}
   EndIF
   IF iTypeGen .AND. iLabelNum # 4 .AND.m->lYesBarCode
      IF ASCAN(aSortSeek,{|x| "- наименованиям" == x[1] }) = 0
        aadd(aSortSeek,;
             {'- наименованиям','Наименование?:','Name',;
             'UPPER(SPACE(1)+pSclad+TRIM(aIn[1]))','@K',,,'MKART_SA'})
           pSBTag:='MKART_SA'
           pSBKey:={||UPPER(SPACE(1)+pSclad)}
      ENDIF
      bPreSeek_:={|x|ORDSETFOCUS(2),SeekBCInKart(x)}
      aadd(aSortSeek,;
         {'- штрих-кодам                   ',;
         'Штрих-код?: ','SPACE(13)',;
         'SeekBCInKart(aIn[1])','@K XXXXXXXXXXXXX',;
         NIL,,2,,,,,.F.})
   EndIf

   bDispSpr := {|cPref,nOrdBC|;
     dbPush(),;
     cSaveScrDisp := NIL,;
     cScrAttr := SAVESCREEN(19,6,24,78),;
     IIF(iMLABEL->(FieldPos("CDATTR1"))>0,ScrTitul(24,"Alt-P:Дополн.атрибуты  "),ScrTitul(24,' ')),;//     //ScrTitul(24,' '),;
     ASIZE(aSortSeek,nSizeSortSeek),;
     IF(iTypeGen.AND.m->lYesBarCode,UstTagBCode(cDest1,aSortSeek,lSclad,lAllSpr,lOnlyNNum,,,@cPref,@nOrdBC),SetScope('UPPER(Status+Sclad+Grup)',SPACE(1)+UPPER(pSclad+m->pLastGrup))),;
     RestIndex("ZI_KART",'Без начала',aSortSeek),;
     dbSetFilter({|| EMPTY(PARTIA) },"EMPTY(PARTIA)"),;
     aPrimEnter := {.T.,nOrdBC,cPref};
               }

   bDispPost:= {|lEnd,nOrd|;
                SaveIndex("ZI_KART",nOrd),;
                RESTSCREEN(19,6,24,78,cScrAttr),;
                dbPop(.T.);
                 }

   nSizeSortSeek := LEN(aSortSeek)
   MakeRefer(cRefer,"Картотека ТМЦ "+NA_SCLADE+" "+ALLTRIM(pSclad)+" ",nTypeRefer,;
   {"Группа"," Н/номер", " Наименование","Остаток","Ед.изм"},{2,0,11},COL_REFER,;
   aSource,aDest,IF(iLabelNum=4 .AND. m->lYesBarCode,"SPACE(1)+'"+UPPER(pSclad)+"'+UPPER("+cDest2+")","SPACE(1)+'"+UPPER(pSclad)+"'+UPPER("+cDest1+"+"+cDest2+")"),;   //VIKTOR работа по штрихкоду 30.07.97 if()
   {{||Grup},{||NNum},{|| LEFT(iMLABEL->Name,34)},{||STR(RetKolEd(iMKART->KolTek,lPlus),14,iMGRUP->(FIELDGET(FIELDPOS('Kol'+IF(EMPTY(NumEdName(RetEd())),'','1')+'_'))))},{|| RetEd() }},aSortSeek,,,,,,;
   bPreDisp,bPostDisp,,,aRef,cMess,{|| CoProc2(lPlus,cDest1,aPrimEnter,bPreSeek_)},,,aGetBlock,;
   'cFind$UPPER('+cSelLabel+'->(NNum+Name))',IF(iLabelNum=4.AND.m->lYesBarCode,'MKART_BC',2),,,bDispFilter,,,,,,,,,,,,,,,,pSBTag,pSBKey)

ENDIF
RETURN (NIL)
//--------------------------------------------------------------------------//
STATIC FUNCTION CoProc1(lInput,lPlus,cDest1,aPrimEnter,bPreSeek)
//--------------------------------------------------------------------------//
LOCAL  nRet := 1
If aPrimEnter[1]
   aPrimEnter[1] = .F.
   FRAME('',19,6,23,78,COL_REFER,2,,.T.)
   SAYSCREEN(' Атрибуты ',19,40)
   IF TYPE(itWork_B_Code)='L'.AND. iWork_B_Code
      QuickBC(1,2,50,aPrimEnter[2],'r/w*',,aPrimEnter[3],bPreSeek)
   ENDIF
EndIF
DispBegin()
SAYSCREEN(IF("GRUP+NNUM" $ ORDKEY(),'*',' '),3,14)
SAYSCREEN(IF("GRUP+NAME" $ ORDKEY(),'*',' '),3,28)
SAYSCREEN('│Ед:'+PADR(ALLTRIM(RetEd(lPlus))+IF(lInput!=NIL .AND. GetPrefix() != "T",' F5:Дп.ед',''),26),17,48)
SAYSCREEN('┬',16,48)
SAYSCREEN('╧',18,48)
DispAttr()
DispTree()
DispEnd()

IF LastKey() = K_ALT_P
     ShowDopAttr()
ENDIF

RETURN nRet

//--------------------------------------------------------------------------//
                         FUNCTION VCenaU(nGet)
//--------------------------------------------------------------------------//
IF ROUND(aIn[nGet],2)>0
   RETURN(.T.)
ELSEIF aIn[nGet]<0
   RETURN(.F.)
ELSEIF YesOrNo('Действительно нулевая учетная цена?')
   RETURN (.T.)
ENDIF
RETURN(.F.)
//--------------------------------------------------------------------------//
       STATIC FUNCTION CoProc2(lPlus,cDest1,aPrimEnter,bPreSeek)
//--------------------------------------------------------------------------//
LOCAL nCena, nCodeCen := IF(TYPE("pCodeCen") = "N".AND.MemVar->pCodeCen > 0.AND.MemVar->pCodeCen <= 4,MemVar->pCodeCen,1)
LOCAL  nRet := 1
If aPrimEnter[1]
   aPrimEnter[1] = .F.
   FRAME('',19,6,23,77,COL_REFER,2,,.T.)
   SAYSCREEN(' Атрибуты ',19,40)
   IF TYPE(itWork_B_Code)='L'.AND. iWork_B_Code
      QuickBC(1,1,0,aPrimEnter[2],'r/w*',,aPrimEnter[3],bPreSeek)
   ENDIF
EndIF
DispBegin()
SAYSCREEN(IF(ORDNAME() = "MKART_SN",'*',' '),3,7)
SAYSCREEN(IF(ORDNAME() = "MKART_ST",'*',' '),3,20)
SAYSCREEN('┬─ Складская  цена ─'+;
IF((GlobalTask $ '03SR' .OR. GetPrefix() == "S").AND.(nCena := RetSumEd(iMLABEL->(FieldGet(FieldPos('OCena'+STR(nCodeCen,1,0)))),lPlus))>0,PADC(IF(TYPE('RCName'+STR(nCodeCen,1,0)+'_') = "C",ALLTRIM(&('RCName'+STR(nCodeCen,1,0)+'_')),"Прайс-цена"),15),'───────────────'),16,39)
SAYSCREEN('│   '+STR(RetSumEd(iMLABEL->CENA,lPLus),13,CURR_MAIN)+;
+'    '+IF((GlobalTask $ '03SR' .OR. GetPrefix() == "S") .AND. nCena > 0,StrS(nCena,13,CURR_MAIN),SPACE(13)),17,39)
SAYSCREEN('╧',18,39)
DispAttr()
DispTree()
DispEnd()

IF LastKey() = K_ALT_P
     ShowDopAttr()
ENDIF

RETURN nRet

FUNCTION LabWhen(lRefer,cVarName)  //В эти функции вход также из справочника
LOCAL lRet:=.T.
IF (nApp>0)
   SAYSCREEN(LEFT(iMGRUP->Name,25),M->GetList[1]:row,M->GetList[1]:col+6)
ENDIF
IF (nApp==0)
ELSEIF (((!EMPTY(aIn[1]).OR.lRefer!=NIL).AND.nApp==2).OR.(nApp==1.AND.(lRet:=IsKart(1))))
   IF lRefer==NIL
      lRet:=.T.
      IF nApp=2.AND.VALTYPE(aIn)=='A'.AND.LEN(aIn)>4.AND.VALTYPE(aIn[5])=='N'
         aIn[5]:=aLastIn[5]:=0
         MemVar->GetList[5]:display()
      ENDIF
   ELSE
      aIn[1]:=&(cVarName)
      IF iLabelNum = 1
         QHelp(,,2,UPPER(aIn[1]),'NNum',,,bPostHelp,,,,,'без добавления записи')
      ELSEIF iLabelNum = 2
         IF nApp==2
            //ALTD()
            aIn[2]:=WDoc('NNum',UPPER(aIn[1]),,'GR_'+UPPER(aIn[1]),13,.T.)
         ENDIF
      ELSEIF nApp==2
         aIn[2]:=SPACE(13)
      ENDIF
      IF(iTypeGen.AND.(EMPTY(aIn[1]).OR.!sPrim),lRet:=.T.,lRet:=.F.)
      sPrim = .F.
   ENDIF
   IF iLabelNum = 2
      M->GetList[2]:preBlock:={||SETKEY(K_ESC,{||ControlMem(UPPER(aIn[1]),,'GR_'+UPPER(aIn[1])),SETKEY(K_ESC,NIL),Keyb(K_ESC)}),.T.}
   ELSE
      M->GetList[2]:preBlock:={||(.T.)}
   ENDIF
   IsNomer(.T.)
   iMGRUP->(DBSEEK(UPPER(aIn[1])))
ELSEIF (nApp==1)
   QHelp('...','Справочник',2,UPPER(aIn[1]),'NNum',,,bPostHelp)
   M->GetList[2]:preBlock:={||(.F.)}
   lRet:=.F.
   IsNomer(.F.)
ENDIF
RETURN (lRet)

//--------------------------------------------------------------------------//
                       STATIC FUNCTION IsNomer(lRet)
//--------------------------------------------------------------------------//
LOCAL baklIsNomer := lIsNomer
IF (lIsNomer := lRet) != baklIsNomer
  AEVAL(MemVar->GetList,{|oGet| oGet:display() })
ENDIF
RETURN lRet

//--------------------------------------------------------------------------//
                   FUNCTION LabRight(lRefer)
//--------------------------------------------------------------------------//
LOCAL nRecNo:=iMGRUP->(RECNO())
IF nApp>0
   IF (lRefer==NIL.AND.(sPrim.OR.aIn[1]!=aLastIn[1]))
      sPrim:=.F.
      IF iLabelNum = 1
         QHelp('...',,2,UPPER(aIn[1]),'NNum',,,bPostHelp,,,,,'без добавления записи')
      ELSEIF nApp=2.AND. iLabelNum = 2
         aIn[2]:=WDoc('NNum',UPPER(aIn[1]),,'GR_'+UPPER(aIn[1]),13,.T.)
      ELSEIF nApp=2
         aIn[2]:=SPACE(13)
      ENDIF
   ENDIF
ENDIF
ToRight(1)
IF (nApp>0)
   iMGRUP->(DBSeek(UPPER(aIn[1])))        //VIKTOR работа по штрих-коду 06.08.97
   SAYSCREEN(LEFT(iMGRUP->Name,25),M->GetList[1]:row,M->GetList[1]:col+6)
ENDIF
RETURN (.T.)

FUNCTION VPostLabel()
LOCAL nArea:=SELECT(),lOpen:=.F., nRecL, nRecK
IF !(GetPrefix() == "T")
  IF nApp==2
     REPLACE Date WITH iSCL_BEG
     REPLACE DateN WITH iSCL_BEG
  ENDIF
  IF EMPTY(CodeVal)
     REPLACE CodeVal WITH GlobalValuta
  ENDIF
  IF IsUhet(aIn[1]) .AND. !IsUhetPartia(aIn[1])
     IF FieldPos("CENA") != 0
       REPLACE Cena0 WITH Cena,YesSebe WITH .T.
     ENDIF
     IF FieldPos("CENAN") != 0
       REPLACE Cena0N WITH FIELD->CenaN,YesSebeN WITH .T.
     ENDIF
     IF !(lOpen:=TYPE(itSCL_SEBER)=='L')
        RestPar('Sebe')
     ENDIF
     iSCL_SEBE  :=.T.
     iSCL_DSEBE := iSCL_BEG
     iSCL_SEBEN  :=.T.
     iSCL_DSEBEN := iSCL_BEG
     IF SELECT(cSelUStru) != 0
       SavePar('Sebe')
     ENDIF
     IF !lOpen
        ClosePar('Sebe')
     ENDIF
  ENDIF
  sPrim:=.T.
  IF !UPPER(aIn[3])==UPPER(aLastIn[3])
    SELECT iMKART
    // by z0ne ////////////////////////////////////////////////////////////////
    nRecL:=iMLABEL->(Recno())
    nRecK:=Recno()
//    dbPush(,,,,"",,)
    //
    DBSEEK(UPPER(aIn[1]+aIn[2]))
    WHILE UPPER(Grup+NNum)==UPPER(aIn[1]+aIn[2]).AND.!EOF()
      RecLock()
      REPLACE Name WITH aIn[3]
      UNLOCK
      SKIP
    ENDDO
    //
//    dbPop()
    dbGoto(nRecK)
    iMLABEL->(dbGoto(nRecL))
    //
    SELECT(nArea)
  ENDIF
ENDIF
RETURN (NIL)
//------------------------------------------------------------------------//
FUNCTION IsMdocM(cKey)
//------------------------------------------------------------------------//
// Поиск в документах склада
LOCAL aBase := {{GetPrefix()+"MDOCM",GetPrefixPath()+"MDOCM"}}
LOCAL lRet := .F., nRec
dbOpenBases(aBase,,,,.T.)
SELECT iMDOCM
ORDSETFOCUS("MDOCM_S")
lRet := dbSeek(UPPER(cKey)) .OR. MSeek(cSelDocM,"MDOCM_AM",cKey,{|| iMDOCM->SCHET_A })
dbCloseBases(aBase)
RETURN lRet
//------------------------------------------------------------------------//
FUNCTION IsS45M(cKey)
//------------------------------------------------------------------------//
// Поиск в товарах отгруженных
LOCAL aBase := {{"S45M",GetPrefixPath()+"S45M"}}
LOCAL lRet := .F., nRec
dbOpenBases(aBase,,,,.T.)
SELECT S45M
ORDSETFOCUS("S45M_GN")
lRet := dbSeek(UPPER(cKey))
dbCloseBases(aBase)
RETURN lRet
//------------------------------------------------------------------------//
FUNCTION IsSeekKart(cKey)
//------------------------------------------------------------------------//
// Поиск в картотеке
LOCAL aBase := {{GetPrefix()+"MKART",GetPrefixPath()+"MKART"}}
LOCAL lRet := .F.
dbOpenBases(aBase,,,,.T.)
SELECT iMKART
ORDSETFOCUS("MKART")
lRet := iMKART->(DBSEEK(UPPER(cKey)))
dbCloseBases(aBase)
RETURN lRet
//------------------------------------------------------------------------//
STATIC FUNCTION IsKart(nMode)
//------------------------------------------------------------------------//
LOCAL Ret:=iMKART->(DBSEEK(UPPER(iMLABEL->Grup+iMLABEL->NNum)))
LOCAL RetM := .F.,RetM45 := .F., cName
//altd()
IF !Ret
  Ret := iSPR_PART->(DBSEEK(UPPER(iMLABEL->Grup+iMLABEL->NNum)))
ENDIF
IF !Ret
  Ret := RetM := IsMdocM(iMLABEL->Grup+iMLABEL->NNum)
ENDIF
IF !Ret
  Ret := RetM45 := IsS45M(iMLABEL->Grup+iMLABEL->NNum)
ENDIF
IF !Ret
  Ret := IsSeekNom(GetPrefix(),iMLABEL->Grup,iMLABEL->NNum,,@cName)
ENDIF
IF (Ret)
   IF (nMode==1)
     @ M->GetList[2]:row,M->GetList[2]:col+14 SAY "[Задействован]" COLOR COL_INPUT
     lIsNomer := .F.
     AEVAL(MemVar->GetList,{|oGet| oGet:display() })
   ELSEIF cName != NIL
     SayError(" Номенклатура используется в "+cName)
   ELSE
     SayError(IF(RetM45,{'ЕСТЬ ДВИЖЕНИЕ ПО ДАННОЙ НОМЕНКЛАТУРЕ'},IF(RetM,'ТМЦ задействован в документах склада !','ТМЦ числится в картотеке!')))
   ENDIF
ELSEIF(nMode==1)
   @ M->GetList[2]:row,M->GetList[2]:col+14 SAY SPACE(15) COLOR COL_INPUT
   lIsNomer := .T.
   AEVAL(MemVar->GetList,{|oGet| oGet:display() })
ENDIF
RETURN !Ret
//--------------------------------------------------------------------------//
      FUNCTION GetPrefixStru(cName)
//--------------------------------------------------------------------------//
// Возвращает имя блока загружаемых переменных по имени и префиксу
IF cStPre == ""
  RETURN cName
ELSEIF cStPre == "Z"
  RETURN cName
ELSEIF cStPre == "T"
  RETURN "T"+RIGHT(cName,LEN(cName)-1)
ENDIF
RETURN cName
//--------------------------------------------------------------------------//
      FUNCTION GetPrefixLabel()
//--------------------------------------------------------------------------//
// Возвращает наименование номенкл.справочника по префиксу
IF cStPre == ""
  RETURN {"Номенклатурный справочник",' (закрытые н/номера)','Н/ном',"НОМЕНКЛАТУРНЫЙ СПРАВОЧНИК"}
ELSEIF cStPre == "Z"
  RETURN {"Номенклатурный справочник материалов",' (закрытые н/номера)','Н/ном',"НОМЕНКЛАТУРНЫЙ СПРАВОЧНИК"}
ELSEIF cStPre == "T"
  RETURN {"Номенклатурный справочник работ,услуг",' (закр.н/номера работ,услуг)','Н/ном',"СПРАВОЧНИК РАБОТ,УСЛУГ"}
ENDIF
RETURN {"Номенклатурный справочник ТМЦ",' (закрытые н/номера)','Н/ном',"НОМЕНКЛАТУРНЫЙ СПРАВОЧНИК"}

//--------------------------------------------------------------------------//
      FUNCTION GetPrefixGrup()
//--------------------------------------------------------------------------//
// Возвращает наименование справочника групп по префиксу
IF cStPre == ""
  RETURN "Группы запасов"
ELSEIF cStPre == "Z"
  RETURN "Группы материалов"
ELSEIF cStPre == "T"
  RETURN "Группы работ,услуг"
ENDIF
RETURN "Группы ТМЦ"
//--------------------------------------------------------------------------//
      FUNCTION GetPrefixPath()
//--------------------------------------------------------------------------//
// Возвращает путь по префиксу
IF cStPre == ""
  RETURN ""
ELSEIF cStPre == "Z"
  RETURN LoadPath()+"ZAPAS\"
ELSEIF cStPre == "T"
  RETURN LoadPath()+"TOVAR\"
ENDIF
RETURN LoadPath()+"SCLAD\"
//--------------------------------------------------------------------------//
      FUNCTION SetTypePrefix(cType)
//--------------------------------------------------------------------------//
// Устанавливает новый префикс по типу (возвращает истину)
IF cType == "1"
  cStPre := "S"
ELSEIF cType == "2"
  cStPre := "Z"
ELSEIF cType == "3"
  cStPre := "T"
ELSEIF cType == "4"
  cStPre := "T"
ENDIF
SetPrefix(cStPre)
RETURN .T.
//--------------------------------------------------------------------------//
      FUNCTION SetPrefix(cPre)
//--------------------------------------------------------------------------//
// Возвращает старый и устанавливает новый префикс
LOCAL cBakPre := cStPre

IF cPre != NIL
  cStPre := cPre
ENDIF

cSelSchet   := cStPre+"MSCHET"
cSelKart    := cStPre+"MKART"
cSelLabel   := cStPre+"MLABEL"
cSelGrup    := cStPre+"MGRUP"
cSelTAxGrp  := cStPre+"MTAXGRP"  // victor история НДС
cSelPartia  := cStPre+"SPR_PART"
cSelStru    := cStPre+"MSTRU"
cSelSclad   := cStPre+"MSCLAD"
cSelUStru   := cStPre+"STRU"
cSelUser    := cStPre+"USER"
cSelDoc     := cStPre+"MDOC"
cSelDocM    := cStPre+"MDOCM"
cSelTree    := cStPre+"TREE"
cSelNameTre := cStPre+"NAME_TRE"
cSelSprDop  := cStPre+"SPR_DOP"
cSelSprRcv  := cStPre+"SPR_RECV"       // справочник реквизитов партий
cSelMoves   := cStPre+"MOVES"
cSelVDoc    := cStPre+"MVDOC"
cSelCodOp   := cStPre+"CODOP"
cSelAgent   := cStPre+"AGENT"

RETURN cBakPre
//--------------------------------------------------------------------------//
      FUNCTION GetPrefix(cVal)
//--------------------------------------------------------------------------//
// Возвращает cVal с префиксом
RETURN cStPre+IF(cVal != NIL,cVal,"")
//--------------------------------------------------------------------------//
      FUNCTION GetsAtribut(aHeads,aPHeads,aPict,aWhen,aValid,aRef,aGetBlock,bPreGet,bPostGet,bScrInit,bScrPost,cNameRef,lLabel)
//--------------------------------------------------------------------------//
// Навешивание атрибутов
LOCAL nMarka,nSort,nProfil,nRazmer, nSpr
LOCAL bAddAtrib := {|cName,cScope,nScope|;
   IF(&(GetPrefix(cName+'_'))[2],;
       (;
        AADD(aHeads,{PADR(TRIM(&(GetPrefix(cName+'_'))[1]),30,'.')+' ',GetPrefix('MLABEL->'+cName)}),;
        IF(!EMPTY(lLabel),;
           (;
            IF(GetPrefix()=="S".OR.GetPrefix()=="Z".OR.GetPrefix()=="",;
            (AADD(aValid,&("{|oGet,nPoz| nPoz := oGet:name ,IF(nApp!=0.AND."+itTypeGen+".AND."+NTOC(nScope)+"="+itNameGen1+",ValidCodeLabel(aIn[nPoz[3]],"+NTOC(nScope)+"),.T.) }")),;
             IF(iTypeGen.AND.nScope==iNameGen1,m->nNumAttr:=LEN(aValid),NIL),;
             AADD(aPict,IF(iTypeGen.AND.nScope==iNameGen1,"9999999999999",NIL))),;
            (AADD(aValid,NIL),AADD(aPict,NIL))),;
            AADD(aRef,&("{|oGet| SetKeyLabel("+NTOC(nScope)+",oGet,.T.,aIn[1]),ReferGetReader(oGet,'"+cNameRef+GetPrefix()+cName+"'),SetKeyLabel("+NTOC(nScope)+",oGet,.F.,aIn[1]) }")),;
            AADD(aGetBlock,&("{|x,oGet,y,lDisplay,nPoz| nPoz := oGet:name,IF(lDisplay,AddKeyLabel("+NTOC(nScope)+",oGet,aIn[1]),NIL),IF(x != NIL,aIn[nPoz[3]] := x,aIn[nPoz[3]]) }"));
            ),;
           (;
            AADD(aValid,NIL),;
            AADD(aPict,NIL),;
            AADD(aRef,cNameRef+GetPrefix()+cName),;
            AADD(aGetBlock,NIL);
            );
           ),;
        AADD(aPHeads,{&(GetPrefix(cName+'_'))[1],cSelLabel+'->'+cName}),;
        (cSelSprDop)->(SprDop(cNameRef+GetPrefix()+cName,3,,"aIn["+NTOC(LEN(aHeads))+"]",cScope,&(GetPrefix(cName+'_'))[1]));
        ),;
       NIL;
     );
                     }
PUBLIC lViborTree := .F.,cVarName := ""

IF(ValType(cNameRef) = "C",,cNameRef := "")
IF(ValType(aHeads) = "A",,aHeads := {})
IF(ValType(aPHeads) = "A",,aPHeads := {})
IF(ValType(aPict) = "A",,aPict:= {})
IF(ValType(aRef) = "A",,aRef := {})
IF(ValType(aGetBlock) = "A",,aGetBlock := {})
IF(ValType(aValid) = "A",,aValid := {})

ASIZE(aPict,LEN(aHeads))
ASIZE(aRef,LEN(aHeads))
ASIZE(aGetBlock,LEN(aHeads))
ASIZE(aValid,LEN(aHeads))

EVAL(bAddAtrib,"Marka","1",1)
EVAL(bAddAtrib,"Sort","4",4)
EVAL(bAddAtrib,"Profil","3",3)
EVAL(bAddAtrib,"Razmer","2",2)

AddTreeSpr(@aHeads,@aPict,@aWhen,@aValid,@aRef,@aGetBlock,@aPHeads,@bPreGet,@bScrInit,@bScrPost,@cNameRef,'Иерархический справочник...... ','Иерархия...................... ',"@S25")

RETURN NIL


//------------------1------2-------3-----4------5------6----7----8----------9-------10-//   11       12        13   14         15        16        17      18
FUNCTION GetHeads(aHeads,aPHeads,aPict,aWhen,aValid,lMode,aRef,aGetBlock,bPreGet,bPostGet,bScrInit,bScrPost,bPost,bPostRead,lContXran,lNoFact,lDopaHeads,cRef)
//--------------------------------------------------------------------------//
LOCAL cNameRef := ""
LOCAL _bPreGet, _bScrPost,_bPostGet
LOCAL _bScrInit,  nPoz
LOCAL bAddKoef := {|cName|;
     IF(&(GetPrefix(cName+"_"))[2],;
       (;
        AADD(aHeads,{PADR(TRIM(&(GetPrefix(cName+"_"))[1]),30,'.')+' ',cName}),;
        AADD(aPict,'999999999.9999'),;
        AADD(aGetBlock,NIL),;
        AADD(aPHeads,{&(GetPrefix(cName+"_"))[1],cName,'999999999.9999'}),;
        AADD(aRef,NIL);
       ),;
       NIL;
       );
                   }
LOCAL lNoName
LOCAL lLabel := .F.
LOCAL lNoClearCena, bCenaN, bakCenaN
Local bVPreGet,bvClearRefs
LOCAL cPoz



// Вася - 5 декабря 2004
Local V_naHeadsLen := 0
// Вася - для параметров, которые вызываются по ALT_P
Local V_naHeadsLenBeforeAltP := 0
Local LDopaHeadsAltP := .T.
Local alDop
Local aDopRefCreateClear := {} // массив для дополнительных справочников
Local cStr
Local n



IF lDopaHeads = NIL.OR.ValType(lDopaHeads)!="L"
   IF ValType(lDopaHeads) = "A"
       aLDop := lDopaHeads
       lDopaHeads := alDop[1]
      LDopaHeadsAltP := alDop[2]
   ELSE
//     IF Type("lV_YesDopHeads") = "L"
//       lDopaHeads := lV_YesDopHeads
//     ELSE
//       LDopaHeads := .T.
         lDopaHeads := (GetPrefix()=="S".OR.(EMPTY(ALLTRIM(GetPrefix())).AND.GlobalTask $ "03SR05"))
//     ENDIF
   ENDIF
ENDIF



// Вася

//MEMVAR nCenaN
IF TYPE('nNumAttr') != 'N'
   PUBLIC nNumAttr:=0
ENDIF
IF TYPE('nCenaN') != 'N'
   PUBLIC nCenaN
ENDIF

IF TYPE("lDispAttr") != 'L'
  PUBLIC lDispAttr
  MemVar->lDispAttr := .F.
ENDIF

IF (lNoName := lMode != NIL .AND. ValType(lMode) = "C" .AND. lMode = "ФИЛЬТР В ПРАЙСЕ")
  cNameRef := "KART"
  aHeads:={;
      {'Группа........................ ','Grup','1','2','1'},;
      {'Н/номер....................... ','NNum','1','2','1'};
         }

  aPict:={'@K','@K'}
  aRef := {GetPrefix("PGrup")}
  AADD(aRef,GetPrefix("PLabel"))
  aWhen  :={,}
  aValid :={{||VGRight()},}

  IF ALIAS() != cSelLabel .AND. (GlobalTask#'05'.OR. iPricePart != 1)
    AADD(aHeads,{'Партия........................ ','Partia','1','2','1'})
    AADD(aRef,GetPrefix("PPartia"))
    AADD(aPict,"@K")
    AADD(aWhen,NIL)
    AADD(aValid,NIL)
  ENDIF
  IF TYPE('pNoNolKol') # 'C'
     PUBLIC pNoNolKol:=' ', aNoNolKol :={{'1','только ненулевое'}}
  ENDIF
  IF TYPE('pVid') ='C' .AND. pVid = '2'
     cPoz:=NTOC(LEN(aHeads)+1)
    AADD(aHeads,{'Количество.................... ','pNoNolKol','0','1','0','IF(aIn['+cPoz+']="1",FIELD->KolTek- IF(YesMatReal,IF(m->RLimit_,-FIELD->KolLim,0)+FIELD->KolRes,0)#0,.T.)'})
    IF VALTYPE(aGetBlock)= 'A'
      IF LEN(aGetBlock) < VAL(cPoz)
         aSIZE(aGetBlock,VAL(cPoz))
      ENDIF
    ELSE
      aGetBlock:=ARRAY(VAL(cPoz))
    ENDIF
    aGetBlock[VAL(cPoz)] := &("{|x| RotateBlock(x,m->aNoNolKol,'aIn["+cPoz+"]') }")
    AADD(aRef,{|x| RotateAndReader(x,m->aNoNolKol) })
    AADD(aPict,NIL)
    AADD(aWhen,NIL)
    AADD(aValid,NIL)
  ENDIF

  IF EMPTY(pSclad).AND. ALIAS() != cSelLabel
    AADD(aHeads,{'Склад......................... ','Sclad','1','1','1'})
    AADD(aRef,GetPrefix("PSclad"))
    AADD(aPict,"@K")
    AADD(aWhen,NIL)
    AADD(aValid,&("{||ToRight("+NTOC(LEN(aWhen))+")}"))
  ENDIF
  aPHeads:={""}
ELSE
  lLabel := .T.
  aHeads:={;
        {'Группа........................ ','Grup','1','2','1'},;
        {'Номенклатурный номер.......... ','NNum','1','2','1'},;
        {'Наименование.................. ','Name'},;
        {'Единица измерения............. ','Ed','1','1','1'};
          }
  IF(ValType(aRef) = "A",IF(LEN(aRef) < 2,ASIZE(aRef,2),NIL),aRef := {,})
  IF(ValType(aGetBlock) = "A",IF(LEN(aGetBlock) < 2,ASIZE(aGetBlock,2),NIL),aGetBlock := {,})
  IF iTypeGen
    iMGRUP->(MakeGrupRefer('MGrupLab1'))
    aRef[1]='MGrupLab1'
  ENDIF
  IF EMPTY(aRef[2])
    #ifdef __HARBOUR__
    aRef[2] := &("{|oGet| SetKeyLabel(5,oGet,.T.,aIn[1]),ReferGetReader(oGet),SetKeyLabel(5,oGet,.F.,aIn[1]) }")
    #else
    aRef[2] := &("{|oGet| SetKeyLabel(5,oGet,.T.,aIn[1]),GetReader(oGet),SetKeyLabel(5,oGet,.F.,aIn[1]) }")
    #endif
  ELSE
    aRef[2] := &("{|oGet| SetKeyLabel(5,oGet,.T.,aIn[1]),ReferGetReader(oGet,'"+aRef[2]+"'),SetKeyLabel(5,oGet,.F.,aIn[1]) }")
  ENDIF
  aGetBlock[1] := {|x,oGet,y,lDisplay| IF(x != NIL,aIn[HEAD_POZ] := x,x := aIn[HEAD_POZ]),IF(x != HEAD_BAK .AND. (UPPER(iMGRUP->CODE) = UPPER(x) .OR. iMGRUP->(dbSeek(UPPER(x)))).OR.(lDisplay .AND. MemVar->nApp = S_LIB_ADD),(SetPos(oGet:Row,oGet:Col+L_GRUP+1),DispOut(PADR(iMGRUP->NAME,25)),IF(MemVar->nApp = S_LIB_FILTER,NIL,(aIn[4] := iMGRUP->ED_,MemVar->GetList[4]:display()))),NIL),x }
  aGetBlock[2] := &("{|x,oGet,y,lDisplay,nPoz| nPoz := oGet:name,IF(lDisplay,AddKeyLabel(5,oGet,aIn[1]),NIL),IF(x != NIL,aIn[nPoz[3]] := x,aIn[nPoz[3]]) }")
  aPHeads:={GetPrefixLabel()[1]+IF(lMode!=NIL.AND.!lMode,GetPrefixLabel()[2],'' ),'Группа',GetPrefixLabel()[3],'Наименование','Ед.'}
  aPict:={'@K','@K','@KS34','@K'}
  aWhen  :={;
  IF(!lRunLabel .OR. GetPrefix() = "T".OR.lRunShFact,;
    {|| LabWhen(1,'pLastGrup')},;
    {|| LabWhen()}),,,;
    {|| .T. }}
  aValid :={{|| LabRight() },;
            {|oGet| LASTKEY() = K_UP.OR.;
                    nApp = S_LIB_FILTER.OR.;
                    IF(iLabelNum = 2,;
                       VDoc(nApp,2,'NNum',aIn[1],,'GR_'+UPPER(aIn[1])),;
                       NIL),;
                    LASTKEY() = K_UP.OR.;
                    nApp = S_LIB_FILTER.OR.;
                    ((!EMPTY(aIn[2]).AND.(iLabelNum #4 .OR.ValidCodeLabel(aIn[HEAD_POZ],5)).AND.(ValTYPE(lContXran)#'L'.OR.(!lContXran.OR.ValidStrNNum(aIn[1])=0)))) },;
            {|oGet| nApp = S_LIB_FILTER.OR.!EMPTY(aIn[HEAD_POZ]) .OR. LastKey() = K_UP },}
  IF (GlobalTask $ '09ZR'.AND. EMPTY(GetPrefix())) .OR. GetPrefix() = 'Z'                      // victor спецодежда весь if
    AADD(aHeads,{'Спецодежда.................... ','Wrk_Cl',"1","1","0","IF(aIn["+NTOC(LEN(aHeads)+1)+"]='1',Wrk_Cl=='1',IF(aIn["+NTOC(LEN(aHeads)+1)+"]=='2',Wrk_Cl==' '))"})
    AADD(aPict,'XXX')
    AADD(aWhen,NIL)
    AADD(aValid,NIL)
    ASIZE(aGetBlock,LEN(aHeads)-1)
    AADD(aGetBlock,&("{|x| RotateBlock(x,IF(nApp=0,{{'2','Нет'},{'1','Да '}},{{' ','Нет'},{'1','Да '}}),'aIn["+NTOC(LEN(aHeads))+"]') }"))
    iIF(LEN(aRef)<Len(aHeads),ASIZE(aRef,LEN(aHeads)),NIL)
    aRef[LEN(aHeads)]:= {|x| RotateAndReader(x,IF(nApp=0,{{'2','Нет'},{'1','Да '}},{{' ','Нет'},{'1','Да '}})) }
  ENDIF



  IF (lNoClearCena := iMLABEL->(FieldPos("CENA")) != 0 .AND.;
                      ((lRunLabel.AND.;
                        ((nPoz := ASCAN(aGlobalUchet,{|x| x[1] == GetPrefix() })) = 0.OR.;
                         aGlobalUchet[nPoz,2])).OR.;
                       (!lRunLabel.AND.;
                        !(GetPrefix() == "T").AND.;
                        (iMSCHET->(EOF()).OR.;
                        (iMSCHET->UCHET = "1".AND.;
                        !(iMSCHET->XRAN = "1" .AND.;
                          iMSCHET->METOD != "3"))))))
    AADD(aHeads,{'Цена '+NA_SCLADE+' за единицу,'+GlobalValuta+'  ','Cena'})
    AADD(aPict,GetPict(15,3))
    AADD(aWhen,{|| lNoClearCena := IsUhet(aIn[1]).AND.lIsNomer.AND.!IsUhetPartia(aIn[1]) })
    AADD(aValid,BlockStringToBlock("{||VCenaU("+NTOC(LEN(aValid)+1)+")}"))
    IF(ValType(aGetBlock) = "A",,aGetBlock := {})
    ASIZE(aGetBlock,LEN(aHeads))
    aGetBlock[LEN(aHeads)] := {|x,oGet,n,lDisplay| IF(lDisplay .AND. MemVar->nApp = S_LIB_ADD,aIn[oGet:name[3]] := 0,NIL),IF(EVAL(oGet:preBlock),(SayScreen('Цена '+NA_SCLADE+' за единицу,'+GlobalValuta+'  ',oGet:row,oGet:col-31),IF(x != NIL,aIn[oGet:name[3]] := x,aIn[oGet:name[3]])),(SayScreen(SPACE(47),oGet:row,oGet:col-31),"")) }
  ENDIF
  IF GetPrefix() == "T"
    AADD(aHeads,{'Цена за единицу,'+GlobalValuta+'........... ','OCENA1'})
    AADD(aPict,SummaPic(CURR_MAIN,14))
    AADD(aWhen,{|| lNoClearCena := .T. })
    AADD(aValid,{|| .T. })
    AADD(aGetBlock,NIL)
  ENDIF
  AADD(aHeads,{'Код ОКДП...................... ','COD_OKDP','1','1','1'})
  AADD(aPict,"@KS20")
  AADD(aGetBlock,NIL)
  AADD(aPHeads,{'Код ОКДП','COD_OKDP','XXXXXXXXXXXXXXXXXX'})
ENDIF

GetsAtribut(@aHeads,@aPHeads,@aPict,@aWhen,@aValid,@aRef,@aGetBlock,@_bPreGet,@_bPostGet,@_bScrInit,@_bScrPost,cNameRef,lLabel)

bScrInit := {|| IF(_bScrInit != NIL,EVAL(_bScrInit),NIL) }

bScrPost := {|| IF(_bScrPost != NIL,EVAL(_bScrPost),NIL) }
bCenaN := {||IsklNalog().OR. ;
             ((iMLABEL->(FieldPos("CENAN")) != 0 .AND.;
                      ((lRunLabel.AND.;
                        ((nPoz := ASCAN(aGlobalUchet,{|x| x[1] == GetPrefix() })) = 0.OR.;
                         aGlobalUchet[nPoz,2])).OR.;
                       (!lRunLabel.AND.;
                        !(GetPrefix() == "T").AND.;
                        iMSCHET->UCHET = "1".AND.;
                        !(iMSCHET->XRAN = "1" .AND.;
                          iMSCHET->METODNal != "3")))).AND.;
            (IsUhet(aIn[1]).AND.lIsNomer.AND.!IsUhetPartia(aIn[1]))) }
cRef := IIF(cRef = Nil," ",cRef)
bVPreGet := &("{|| CreateDopRefs('"+cRef+"'), V_FORSetKeys("+IIF(lDopaHeads,".T.",".F.")+","+IIF(lDopaHeadsAltP,".T.",".F.")+",'"+cRef+"')}")


bPreGet:={|| EVAL(bVPreGet),; // Вася
             lIsNomer := .T.,;
             IF(MemVar->nApp = S_LIB_ADD .and. lLabel,;
                aIn[4] := iMGRUP->ED_, NIL),;
             iIF(MemVar->nApp = S_LIB_ADD.OR.MemVar->nApp = S_LIB_FILTER ,m->nCenaN:=0,m->nCenaN:=FIELD->CenaN),;
             iIF(GetPrefix()#'T'.AND.TYPE('m->lYesNalUch')='L'.AND. m->lYesNalUch.AND.MemVar->nApp # S_LIB_FILTER,;
                                  SETKEY(K_CTRL_N,{|| IF(!EMPTY(iMKART->Schet),iMSCHET->(dbSeek(UPPER(iMKART->Schet))),NIL),;
                                                      IF((iMSCHET->XRAN != '1' .OR. iMSCHET->METODNal = '3'),;
                                                         (bakCenaN:=m->nCenaN,;
                                                          GetSumNal(@nCenaN,,EVAL(bCenaN)),;
                                                          IF(bakCenaN#m->nCenaN,m->aLastIn[1]:='',NIL)),;
                                                         SayError({'Просмотр и корректировка налоговой цены',' производится в карточке партии'}))}),NIL),;
             IF(_bPreGet != NIL,EVAL(_bPreGet),NIL) }

bvClearRefs := &("{|| ClearDopRefs('"+IIF(cRef= NIL," ",cRef)+"') }")
bPostGet:={|lSave,lUpdate,nRecClose| EVAL(bvClearRefs),;
 iIF(lSave.AND.RecLock(),;
     (FIELD->CENAN:=m->nCenaN,;
      iIF(FIELDPOS('CENA0N')>0.AND. FIELD->CENA0N=0.AND.iMSCHET->UCHET = "1" ,FIELD->CENA0N:=m->nCenaN,NIL),;
      dbUnLock()),NIL),;
 IF(OpenLabelNum(lSave,lUpdate).AND._bPostGet != NIL,;
    EVAL(_bPostGet,lSave,lUpdate),;
    NIL;
   ), MydbUnLockAll(); //dbUnLockAll(); //Вася & Victor
          }          
bPost := {|| ProtokLabel(m->nApp), IF(lNoClearCena != NIL .AND. !lNoClearCena .AND. GetPrefix() != "T".AND.MemVar->nApp = S_LIB_ADD,iMLABEL->CENA := 0,NIL) }
bPostRead := {|lUpdate,nKey| IF(nApp!=S_LIB_FILTER,;
                                nKey = K_ESC .OR.;
                                ((!EMPTY(aIn[2]) .OR. SayError("Укажите номенклатурный номер !")).AND.;
                                 (!iTypeGen.OR.iNameGen1=5.OR.m->nNumAttr=0.OR.  (!EMPTY(aIn[m->nNumAttr])) .OR. SayError('Поле со штрих-кодом должно быть заполнено')).AND. ;
                                 (lNoName .OR. !EMPTY(aIn[3]) .OR. SayError("Укажите наименование ТМЦ !"))),.T.) }

IF !(lMode != NIL .AND. ValType(lMode) = "C" .AND. lMode = "ФИЛЬТР В ПРАЙСЕ")
  EVAL(bAddKoef,'Koef')
  EVAL(bAddKoef,'Koef1')
  IF TYPE(itNorma) = "A" .AND. iNorma[2]
     AADD(aHeads,{'Норма запаса.................. ','Norma'})
     AADD(aPict,GetPict(13,iMGRUP->Kol_))
     AADD(aPHeads,{' Норма запаса','Norma',GetPict(13,iMGRUP->Kol_)})
  ENDIF
ENDIF

// Вася. - 22 июня 2005 года.
// Делаю окошки с дополнительными параметрами.
n := LEN(aHeads)

V_AddDopaHeads(@aHeads,@aPict,@aRef,@aWhen,@aValid,@aGetBlock,lDopaHeads,cRef)
// Возвращает количество сразу отображаемых элементов aHeads

RETURN n




PROCEDURE V_AddDopaHeads(aHeads,aPict,aRef,aWhen,aValid,aGetBlock,lDopaHeads,cRef)
// Вася - 5 декабря 2004
Local V_naHeadsLen := 0
// Вася - для параметров, которые вызываются по ALT_P
Local V_naHeadsLenBeforeAltP := 0
Local LDopaHeadsAltP := .T.
Local alDop
Local aDopRefCreateClear := {} // массив для дополнительных справочников
Local cStr

Local aPHeads:={}


// Вася. - 22 июня 2005 года.
// Делаю окошки с дополнительными параметрами.


aDopRefCreateClear := {}

V_naHeadsLenBeforeAltP := LEN(aHeads)
cRef := IIF(cRef = nil," ",cRef)

SaveaHeadsLenBeforeAltP(cRef,V_naHeadsLenBeforeAltP)

Set_YesNoAltP(cRef,.F.) // как будто нет окошка по AltP



IF iMLABEL->(FieldPos("CDATTR1")) > 0.AND.LDopaHeadsAltP
              IF iCCDOPNAME1[2]
                  AADD(aHeads,{PADR(IIF(EMPTY(ALLTRIM(iCCDOPNAME1[1])),"Доп.атрибут 1 (симв)" ,ALLTRIM(iCCDOPNAME1[1])),20,".")+":",cSelLabel+"->CDAttr1","1",'1','0', , ,0})
                  AADD(aPHeads,{IIF(EMPTY(ALLTRIM(iCCDOPNAME1[1])),"Дополн. атрибут 1 (симв.)",ALLTRIM(iCCDOPNAME1[1]))+":",cSelLabel+"->CDAttr1",})
                  cStr := "aIn["+STR(LEN(aHeads))+"]"
                  AADD(aDopRefCreateClear,{ cSelSprDop+'->(SprDop("'+cRef+'V_REF1",3,,"'+cStr+'","5","'+iCCDOPNAME1[1]+'"))', cREf+'V_REF1' })
              ENDIF
              IF iCCDOPNAME2[2]
                  AADD(aHeads,{PADR(IIF(EMPTY(ALLTRIM(iCCDOPNAME2[1])),"Доп.атрибут 2 (симв)" ,ALLTRIM(iCCDOPNAME2[1])),20,".")+":",cSelLabel+"->CDAttr2","1",'1','0', , ,0})
                  AADD(aPHeads,{IIF(EMPTY(ALLTRIM(iCCDOPNAME2[1])),"Дополн. атрибут 2 (симв.)",ALLTRIM(iCCDOPNAME2[1]))+":",cSelLabel+"->CDAttr2",})
                  cStr := "aIn["+STR(LEN(aHeads))+"]"
                  AADD(aDopRefCreateClear,{ cSelSprDop+'->(SprDop("'+cRef+'V_REF2",3,,"'+cStr+'","6","'+iCCDOPNAME2[1]+'"))', cREf+'V_REF2' })
              ENDIF
              IF iCCDOPNAME3[2]
                  AADD(aHeads,{PADR(IIF(EMPTY(ALLTRIM(iCCDOPNAME3[1])),"Доп.атрибут 3 (симв)" ,ALLTRIM(iCCDOPNAME3[1])),20,".")+":",cSelLabel+"->CDAttr3","1",'1','0', , ,0})
                  AADD(aPHeads,{IIF(EMPTY(ALLTRIM(iCCDOPNAME3[1])),"Дополн. атрибут 3 (симв.)",ALLTRIM(iCCDOPNAME3[1]))+":",cSelLabel+"->CDAttr3",})
                  cStr := "aIn["+STR(LEN(aHeads))+"]"
                  AADD(aDopRefCreateClear,{ cSelSprDop+'->(SprDop("'+cRef+'V_REF3",3,,"'+cStr+'","7","'+iCCDOPNAME3[1]+'"))', cREf+'V_REF3' })
              ENDIF
              IF iCCDOPNAME4[2]
                  AADD(aHeads,{PADR(IIF(EMPTY(ALLTRIM(iCCDOPNAME4[1])),"Доп.атрибут 4 (симв)" ,ALLTRIM(iCCDOPNAME4[1])),20,".")+":",cSelLabel+"->CDAttr4","1",'1','0', , ,0})
                  AADD(aPHeads,{IIF(EMPTY(ALLTRIM(iCCDOPNAME4[1])),"Дополн. атрибут 4 (симв.)",ALLTRIM(iCCDOPNAME4[1]))+":",cSelLabel+"->CDAttr4",})
                  cStr := "aIn["+STR(LEN(aHeads))+"]"
                  AADD(aDopRefCreateClear,{ cSelSprDop+'->(SprDop("'+cRef+'V_REF4",3,,"'+cStr+'","8","'+iCCDOPNAME4[1]+'"))', cREf+'V_REF4' })
              ENDIF
              IF iCNDOPNAME1[2]
                  AADD(aHeads,{PADR(IIF(EMPTY(ALLTRIM(iCNDOPNAME1[1])),"Доп.атрибут 5 (числ)" ,ALLTRIM(iCNDOPNAME1[1])),20,".")+":",cSelLabel+"->NDAttr1","1",'1','0', , ,0})
                  AADD(aPHeads,{IIF(EMPTY(ALLTRIM(iCNDOPNAME1[1])),"Дополн. атрибут 5 (числ.)",ALLTRIM(iCNDOPNAME1[1]))+":",cSelLabel+"->NDAttr1",})
              ENDIF
              IF iCNDOPNAME2[2]
                  AADD(aHeads,{PADR(IIF(EMPTY(ALLTRIM(iCNDOPNAME2[1])),"Доп.атрибут 6 (числ)" ,ALLTRIM(iCNDOPNAME2[1])),20,".")+":",cSelLabel+"->NDAttr2","1",'1','0', , ,0})
                  AADD(aPHeads,{IIF(EMPTY(ALLTRIM(iCNDOPNAME2[1])),"Дополн. атрибут 6 (числ.)",ALLTRIM(iCNDOPNAME2[1]))+":",cSelLabel+"->NDAttr2",})
              ENDIF

              // Показываем, что будем открывать окошко по AltP
              Set_YesNoAltP(cRef,.T.)
ENDIF


//Вася. - 5 декабря 2004
#ifdef __HARBOUR__
//ALTD()

//IF GlobalTask $ "03SR".OR.GetPrefix()=="S"
//IF GetPrefix()=="S".OR.(EMPTY(ALLTRIM(GetPrefix())).AND.GlobalTask $ "03SR05")


IF lDopaHeads.AND.iMLABEL->(FieldPos("ORD_SYST")) > 0
V_naHeadsLen := LEN(aHeads)



SaveaHeadsLen(cRef,V_naHeadsLEN) // ничего другого я не придумалллл


AADD(aHeads,{"Система заказа...................",cSelLabel+"->ORD_SYST"  ,"1",'1','0', , ,0})
AADD(aHeads,{"Политика заказа..................",cSelLabel+"->ORD_POLICY","1",'1','0', , ,0}) // этот элемент тут просто так сидит. Он не должен быть виден.
AADD(aHeads,{"Поставщик........................",cSelLabel+"->VENDOR"    ,"1",'1','0', , ,0})

cStr := "aIn["+ STR(LEN(aHeads)) +"]"
AADD(aDopRefCreateClear,{GetPrefix()+'Partner'+cRef+'->(ReferPartSet("'+cRef+'V_VENDORS",{"'+cStr+'"},{"CODE"},2,,"UPPER('+cStr+')"))', cRef+'V_VENDORS' })


AADD(aHeads,{"Код тов. по классиф. поставщика..",cSelLabel+"->VND_CODE"  ,"1",'1','0', , ,0})
AADD(aHeads,{"Назв. тов. по классиф. поставщика",cSelLabel+"->VND_NAME"  ,"1",'1','0', , ,0})
AADD(aHeads,{"ЕИ закупки.......................",cSelLabel+"->VND_UNIT"  ,"1",'1','0', , ,0})
AADD(aHeads,{"Код валюты.......................",cSelLabel+"->VND_CUR"   ,"1",'1','0', , ,0})

cStr := "aIn["+STR(LEN(aHeads)) +"]"

AADD(aDopRefCreateClear,{GetPrefix()+'V_VALUTA'+cRef+'->(MakeValutaRefer("'+cRef+'V_Valuta","'+cStr+'",1))', cRef+"V_Valuta" })

AADD(aHeads,{"Цена поставщика..................",cSelLabel+"->VND_PRICE" ,"1",'1','0', , ,0})
AADD(aHeads,{"Минимальная партия...............",cSelLabel+"->LOT_MIN"   ,"1",'1','0', , ,0})
AADD(aHeads,{"Максимальная партия..............",cSelLabel+"->LOT_MAX"   ,"1",'1','0', , ,0})
AADD(aHeads,{"Время доставки...................",cSelLabel+"->ORD_DAY1"  ,"1",'1','0', , ,0})
AADD(aHeads,{"Точка заказа.....................",cSelLabel+"->ORD_POINT" ,"1",'1','0', , ,0})
AADD(aHeads,{"Объем заказа.....................",cSelLabel+"->ORD_QTY"   ,"1",'1','0', , ,0})
//AADD(aHeads,{"Максимальный запас...............",cSelLabel+"->ORD_MAX"   ,"1",'1','0', , ,0})
AADD(aHeads,{"Страховой запас..................",cSelLabel+"->QTY_SFT"   ,"1",'1','0', , ,0})


AADD(aPHeads,{"Система заказа"                   ,cSelLabel+"->ORD_SYST"  , })
//AADD(aPHeads,{"Политика заказа"                ,cSelLabel+"->ORD_POLICY", }) // этот элемент тут просто так сидит. Он не должен быть виден.
AADD(aPHeads,{"Поставщик"                        ,cSelLabel+"->VENDOR"    , })
AADD(aPHeads,{"Код тов. по классиф. поставщика"  ,cSelLabel+"->VND_CODE"  , })
AADD(aPHeads,{"Назв. тов. по классиф. поставщика",cSelLabel+"->VND_NAME"  , })
AADD(aPHeads,{"ЕИ закупки"                       ,cSelLabel+"->VND_UNIT"  , })
AADD(aPHeads,{"Код валюты"                       ,cSelLabel+"->VND_CUR"   , })
AADD(aPHeads,{"Цена поставщика"                  ,cSelLabel+"->VND_PRICE" , })
AADD(aPHeads,{"Минимальная партия"               ,cSelLabel+"->LOT_MIN"   , })
AADD(aPHeads,{"Максимальная партия"              ,cSelLabel+"->LOT_MAX"   , })
AADD(aPHeads,{"Время доставки"                   ,cSelLabel+"->ORD_DAY1"  , })
AADD(aPHeads,{"Точка заказа"                     ,cSelLabel+"->ORD_POINT" , })
AADD(aPHeads,{"Объем заказа",                     cSelLabel+"->ORD_QTY"   , })
//AADD(aPHeads,{"Максимальный запас",               cSelLabel+"->ORD_MAX"   , })
AADD(aPHeads,{"Страховой запас",                  cSelLabel+"->QTY_SFT"   , })






//ENDIF// lDopaHeads
ENDIF
#endif

//ALTD()

INTORefs(cRef,aDopRefCreateClear)




RETURN




// Создаю дополнительные справочники.
PROCEDURE CreateDopRefs(cRef)
Local aRefBlocks := IntoRefs(cRef)
Local nLen := LEN(aRefBlocks)
Local i
Local bBlock
Local cAlias := ALIAS()
Local cStr

//ALTD()

IF SELECT(GetPrefix()+"PARTNER"+cRef) >0
   lsClearPartner := .F.
ELSE
   lsClearPartner := .T.
   NetUse(GetPrefix()+"PARTNER"+cRef,LoadPath()+"Partner")
ENDIF
(GetPrefix()+"Partner"+cRef)->(OrdSetFocus("CODE"))
(GetPrefix()+"Partner"+cRef)->(dbGoTop())

NetUse(GetPrefix()+"V_VALUTA"+cRef,LoadPath()+"VALUTA")
(GetPrefix()+"V_Valuta"+cRef)->(OrdSetFocus("CODE"))
(GetPrefix()+"V_Valuta"+cRef)->(dbGoTop())

FOR i := 1 to nLEN
   bBlock := "{|| "+aRefBlocks[i][1]+" }"
   bBlock := &bBlock
   EVAL(bBlock)
NEXT i
SELECT(cAlias)
cStr := SaveScreen(MaxRow()-1,1,MaxRow()-1,MaxCol() )
ScrTitul(MaxRow()-1, ;
                 IIF(iMLABEL->(FieldPos("ORD_SYST"))>0,"Alt-H:Закупки ","" )+IIF(iMLABEL->(FieldPos("CDATTR1"))>0,"Alt-P:Дополнительные атрибуты  ","" ))
AltD()
V_SaveST(cStr)
RETURN


Static FUNCTION V_SaveST(x)
Local xRet
Static cVal:= ""
IF x == NIL
   xRet := cVal
ELSE
   cVal := x
   xRet := Nil
ENDIF
RETURN xRet


// Создаю дополнительные справочники.
PROCEDURE ClearDopRefs(cRef)
Local aRefBlock := IntoRefs(cRef)
Local nLen := LEN(aRefBlock)
Local i
Local cStr
Local cAlias := ALIAS()
FOR i := 1 to nLEN
ClearRefer(aRefBlock[i][2])
NEXT i
(GetPrefix()+"V_VALUTA"+cRef)->(dbCloseArea())
IF lsClearPartner
   (GetPrefix()+"Partner"+cRef)->(dbCloseArea())
   lsClearPartner := .F.
ENDIF
SELECT(cAlias)
AltD()
cStr := V_SaveST()
RestScreen(MaxRow()-1,1,MaxRow()-1,MaxCol() ,cStr)
//IF !EMPTY(cStr)
//    ScrTitul(maxRow()-1,cStr )
//ENDIF
RETURN


// Идея такая. Сажаю сюда массив блоков кода с созданием справочников. Затем в прегете обращаюсь сюда и сажаю справочники.
FUNCTION IntoRefs(cRef,x)
Local i
Static aNames := {}
Static aVals := {}
cRef := IIF(cRef = NIL," ",cRef)
IF (i := ASCAN(aNames,UPPER(cRef))) = 0
   IF x != NIL
      AADD(aNames,NIL)
      AADD(aVals,NIL)
      i := LEN(aNames)
   ENDIF
ENDIF
IF x == NIL.AND.i == 0
   xRet := nil
ENDIF
IF x == NIL.AND.i>0
   xRet := aVals[i]
ENDIF
IF x != NIL.AND.i>0.AND.i <= LEN(aNames)
   aVals[i] := x
   aNames[i] := UPPER(cRef)
   xRet := x
ENDIF
RETURN xRet




/*Static*/ FUNCTION Set_YesNoAltP(cRef,x)
Local xRet
Local i
Static aNames := {}
Static aVals := {}
cRef := IIF(cRef = NIL," ",cRef)
IF (i := ASCAN(aNames,UPPER(cRef))) = 0
   IF x != NIL
      AADD(aNames,NIL)
      AADD(aVals,NIL)
      i := LEN(aNames)
   ENDIF
ENDIF
IF x == NIL.AND.i == 0
   xRet := nil
ENDIF
IF x == NIL.AND.i>0
   xRet := aVals[i]
ENDIF
IF x != NIL.AND.i>0.AND.i <= LEN(aNames)
   aVals[i] := x
   aNames[i] := UPPER(cRef)
   xRet := x
ENDIF

RETURN xRet






// Ничем не отличается от SaveaHeadsLEN. Но только трогать ЭТО не надо.
FUNCTION SaveaHeadsLenBeforeAltP(cRef,x)
Local xRet
Local i
Static aNames := {}
Static aVals := {}
cRef := IIF(cRef = NIL," ",cRef)
IF (i := ASCAN(aNames,cRef)) = 0
   IF x != NIL
      AADD(aNames,NIL)
      AADD(aVals,NIL)
      i := LEN(aNames)
   ENDIF
ENDIF
IF x == NIL.AND.i == 0
   xRet := nil
ENDIF
IF x == NIL.AND.i>0
   xRet := aVals[i]
ENDIF
IF x != NIL.AND.i>0.AND.i <= LEN(aNames)
   aVals[i] := x
   aNames[i] := cRef
   xRet := x
ENDIF

RETURN xRet




FUNCTION SaveaHeadsLen(cRef,x)
Local xRet
Local i
Static aNames := {}
Static aVals := {}

cRef := IIF(cRef = NIL," ",cRef)
IF (i := ASCAN(aNames,cRef)) = 0
   IF x != NIL
      AADD(aNames,NIL)
      AADD(aVals,NIL)
      i := LEN(aNames)
   ENDIF
ENDIF
IF x == NIL.AND.i == 0
   xRet := nil
ENDIF
IF x == NIL.AND.i>0
   xRet := aVals[i]
ENDIF
IF x != NIL.AND.i>0.AND.i <= LEN(aNames)
   aVals[i] := x
   aNames[i] := cRef
   xRet := x
ENDIF

RETURN xRet

// Сохранение и восстановление массива aHotKey

PROCEDURE V_FORSetKeys(lYesH,lYesP,cRef) // для навески клавиш
Local cStr


  IF lYesH
     SetKey(K_ALT_H,{|| EnterAltH(SaveaHeadsLen(cRef),,cRef) })
  ENDIF
  IF lYesP
     SetKey(K_ALT_P,{|| EnterAltP(SaveaHeadsLenBeforeAltP(cRef), Set_YesNoAltP(cRef),cREf) })
  ENDIF

  /*IF nAPP == 0
  ELSE
     IF V_lSpec != NIL.AND.lYesH
        cStr := "Alt-H:Закупки"
     ELSE
        cStr := ""
     ENDIF
     IF iMLABEL->(FIELDPOS("CDATTR1")) > 0.AND.DopAttrNumber()>0
        cStr := cStr + " Alt-P:Дополнительные атрибуты"
     ENDIF
     ScrTitul(MaxRow(), cStr)
  ENDIF*/
RETURN


// Подсчет количества дополнительных атрибутов, задествованных в altp

FUNCTION DopAttrNumber()
Local nNumber := 0
IF iCCDOPNAME1[2]
nNumber := nNumber+1
ENDIF
IF iCCDOPNAME2[2]
nNumber := nNumber+1
ENDIF
IF iCCDOPNAME3[2]
nNumber := nNumber+1
ENDIF
IF iCCDOPNAME4[2]
nNumber := nNumber+1
ENDIF
IF iCNDOPNAME1[2]
nNumber := nNumber+1
ENDIF
IF iCNDOPNAME2[2]
nNumber := nNumber+1
ENDIF
RETURN nNumber



FUNCTION EnterAltP(i,lYesWindow,cRef)
Local aSet,aKey
Local lDo
Local OldGetList
Local nTop,nBottom
Local oGetNew
Local cCol
Local b_1,b_2,b_3,b_4,b_5,b_6,b_7 // блоки кодов
Local cCol_Say
Local nTTOP := 1,nminus,nplus


PRIVATE cStr


IF iMLABEL->(FieldPos("CDATTR1")) > 0

IF lYesWindow

nminus := 1
nplus := DopAttrNumber()


aSet := SaveSet()
aKey := SaveSetKey()

//Вася




dbPush()


OldGetList := GetList
GetList := {}
IF nAPP == 0        // Это для ввода в SEEK.

altd()
cCol_Say := COL_INPUT

        ShadowBox("[ Дополнительные атрибуты ]",MaxRow()/2 - nminus, MaxCol()/2-34,MaxRow()/2+nplus,MaxCol()/2+34,cCol_SAY)
        nTop := MaxRow()/2 - nminus
        nLeft :=  MaxCol()/2-34


IF iCCDOPNAME1[2]
   ALTD()
   @ nTop+nttop,nLeft+2 SAY PADR(IIF(EMPTY(ALLTRIM(iCCDOPNAME1[1])),"Доп.атрибут 1 (симв)",ALLTRIM(iCCDOPNAME1[1])),20,".")+":" COLOR cCol_SAY
   cStr := "aIn["+ALLTRIM(STR(i+nttop))+"]"
   @ nTop+nttop,nLeft+24 REFER cREf+"V_REF1" GET &cStr PICTURE REPLICATE("X",30)
   nttop := nttop+1
ENDIF

IF iCCDOPNAME2[2]
   @ nTop+nttop,nLeft+2 SAY PADR(IIF(EMPTY(ALLTRIM(iCCDOPNAME2[1])),"Доп.атрибут 2 (симв)",ALLTRIM(iCCDOPNAME2[1])),20,".")+":" COLOR cCol_SAY
   cStr := "aIn["+ALLTRIM(STR(i+nttop))+"]"
   @ nTop+nttop,nLeft+24 REFER cREf+"V_REF2" GET &cStr PICTURE REPLICATE("X",30)
   nttop := nttop+1
ENDIF
IF iCCDOPNAME3[2]
   @ nTop+nttop,nLeft+2 SAY PADR(IIF(EMPTY(ALLTRIM(iCCDOPNAME3[1])),"Доп.атрибут 3 (симв)",ALLTRIM(iCCDOPNAME3[1])),20,".")+":" COLOR cCol_SAY
   cStr := "aIn["+ALLTRIM(STR(i+nttop))+"]"
   @ nTop+nttop,nLeft+24 REFER cRef+"V_REF3" GET &cStr PICTURE REPLICATE("X",30)
   nttop := nttop+1
ENDIF
IF iCCDOPNAME4[2]
   @ nTop+nttop,nLeft+2 SAY PADR(IIF(EMPTY(ALLTRIM(iCCDOPNAME4[1])),"Доп.атрибут 4 (симв)",ALLTRIM(iCCDOPNAME4[1])),20,".")+":" COLOR cCol_SAY
   cStr := "aIn["+ALLTRIM(STR(i+nttop))+"]"
   @ nTop+nttop,nLeft+24 REFER cRef+"V_REF4" GET &cStr PICTURE REPLICATE("X",30)
   nttop := nttop+1
ENDIF




IF iCNDOPNAME1[2]

   cStr := "aIn["+STR(i+nttop)+"][1]"
   @ nTop+nttop,nLeft+2 SAY  PADR(IIF(EMPTY(ALLTRIM(iCNDOPNAME1[1])),"Доп.атрибут 5 (числ)",ALLTRIM(iCNDOPNAME1[1])),20,".")+":                     -                    " COLOR cCol_SAY
   @ nTop+nttop,nLeft+24 GET &cStr PICTURE "99999999999999.9999"
   cStr := "aIn["+STR(i+nttop)+"][2]"
   @ nTop+nttop,nLeft+46 GET &cStr PICTURE "99999999999999.9999"
   nttop := nttop+1
ENDIF

IF iCNDOPNAME2[2]
   cStr := "aIn["+STR(i+nttop)+"][1]"
   @ nTop+nttop,nLeft+2 SAY  PADR(IIF(EMPTY(ALLTRIM(iCNDOPNAME2[1])),"Доп.атрибут 6 (числ)",ALLTRIM(iCNDOPNAME2[1])),20,".")+":                     -                    " COLOR cCol_SAY
   @ nTop+nttop,nLeft+24 GET &cStr PICTURE "99999999999999.9999"
   cStr := "aIn["+STR(i+nttop)+"][2]"
   @ nTop+nttop,nLeft+46 GET &cStr PICTURE "99999999999999.9999"
   nttop := nttop+1
ENDIF


SET CURSOR ON
READ
SET CURSOR OFF





ELSE
IF V_lSpec != NIL
        cCol_SAY := COL_REF1
ELSE
        cCol_Say := COL_INPUT
ENDIF
//cCol_SAY := SETCOLOR()


        ShadowBox("[ Дополнительные атрибуты ]",MaxRow()/2 - nminus, MaxCol()/2-29,MaxRow()/2+nplus,MaxCol()/2+29,cCol_SAY)
        nTop := MaxRow()/2 - nminus
        nLeft :=  MaxCol()/2-29



IF iCCDOPNAME1[2]
   @ nTop+nttop,nLeft+2 SAY PADR(IIF(EMPTY(ALLTRIM(iCCDOPNAME1[1])),"Доп.атрибут 1 (симв)",ALLTRIM(iCCDOPNAME1[1])),20,".")+":" COLOR cCol_SAY
   cStr := "aIn["+ALLTRIM(STR(i+nttop))+"]"
   @ nTop+nttop,nLeft+24 REFER cRef+"V_REF1" GET &cStr PICTURE REPLICATE("X",30)
   nttop := nttop+1
ENDIF

IF iCCDOPNAME2[2]
   @ nTop+nttop,nLeft+2 SAY PADR(IIF(EMPTY(ALLTRIM(iCCDOPNAME2[1])),"Доп.атрибут 2 (симв)",ALLTRIM(iCCDOPNAME2[1])),20,".")+":" COLOR cCol_SAY
   cStr := "aIn["+ALLTRIM(STR(i+nttop))+"]"
   @ nTop+nttop,nLeft+24 REFER cRef+"V_REF2" GET &cStr PICTURE REPLICATE("X",30)
   nttop := nttop+1
ENDIF
IF iCCDOPNAME3[2]
   @ nTop+nttop,nLeft+2 SAY PADR(IIF(EMPTY(ALLTRIM(iCCDOPNAME3[1])),"Доп.атрибут 3 (симв)",ALLTRIM(iCCDOPNAME3[1])),20,".")+":" COLOR cCol_SAY
   cStr := "aIn["+ALLTRIM(STR(i+nttop))+"]"
   @ nTop+nttop,nLeft+24 REFER cRef+"V_REF3" GET &cStr PICTURE REPLICATE("X",30)
   nttop := nttop+1
ENDIF
IF iCCDOPNAME4[2]
   @ nTop+nttop,nLeft+2 SAY PADR(IIF(EMPTY(ALLTRIM(iCCDOPNAME4[1])),"Доп.атрибут 4 (симв)",ALLTRIM(iCCDOPNAME4[1])),20,".")+":" COLOR cCol_SAY
   cStr := "aIn["+ALLTRIM(STR(i+nttop))+"]"
   @ nTop+nttop,nLeft+24 REFER cRef+"V_REF4" GET &cStr PICTURE REPLICATE("X",30)
   nttop := nttop+1
ENDIF


IF iCNDOPNAME1[2]
   cStr := "aIn["+STR(i+nttop)+"]"
   @ nTop+nttop,nLeft+2 SAY  PADR(IIF(EMPTY(ALLTRIM(iCNDOPNAME1[1])),"Доп.атрибут 5 (числ)",ALLTRIM(iCNDOPNAME1[1])),20,".")+":" COLOR cCol_SAY
   @ nTop+nttop,nLeft+24 GET &cStr PICTURE "99999999999999.9999"
   nttop := nttop+1
ENDIF

IF iCNDOPNAME2[2]
   cStr := "aIn["+STR(i+nttop)+"]"
   @ nTop+nttop,nLeft+2 SAY  PADR(IIF(EMPTY(ALLTRIM(iCNDOPNAME2[1])),"Доп.атрибут 6 (числ)",ALLTRIM(iCNDOPNAME2[1])),20,".")+":" COLOR cCol_SAY
   @ nTop+nttop,nLeft+24 GET &cStr PICTURE "99999999999999.9999"
   nttop := nttop+1
ENDIF



SET CURSOR ON
READ
SET CURSOR OFF


ENDIF



dbPop()

GetList := {}
GetList := OldGetList
RestSet(aSet)
RestSetKey(aKey)

ENDIF //IF lYesWindow
ENDIF // iMLABEL->(FieldPos("CDATTR1")) > 0

RETURN



















#ifdef __HARBOUR__

Function EnterAltH( i,lSPEC,cRef ) // i - это после какого номера заканчиваются плохие aHeads.
Local aSet,aKey
Local lDo
Local OldGetList
Local nTop,nBottom
Local oGetNew
Local cCol
Local b_1,b_2,b_3,b_4,b_5,b_6,b_7 // блоки кодов
Local cCol_Say

PRIVATE aArr := {{0,"Не определена"},;
                 {1,"На заказ     "},;
                 {2,"За период    "},;
                 {3,"По остатку   "},;
                 {4,"Ручной заказ "}}
PRIVATE aIzm := {}


PRIVATE cStr

//Вася


IF iMLABEL->(FieldPos("ORD_SYST")) > 0

aSet := SaveSet()
aKey := SaveSetKey()
dbPush()

IF nAPP != S_LIB_ADD

IF !EMPTY(ALLTRIM(iMLABEL->ED))
        AADD(aIzm,{iMLABEL->ED ,iMLABEL->ED })
ENDIF
IF !EMPTY(ALLTRIM(iMLABEL->ED1))
        AADD(aIzm,{iMLABEL->ED1 ,iMLABEL->ED1 })
ENDIF
IF !EMPTY(ALLTRIM(iMLABEL->ED2))
        AADD(aIzm,{iMLABEL->ED2 ,iMLABEL->ED2 })
ENDIF
IF !EMPTY(ALLTRIM(iMLABEL->ED3))
        AADD(aIzm,{iMLABEL->ED3 ,iMLABEL->ED3 })
ENDIF

ENDIF






OldGetList := GetList
GetList := {}
//SayAndWait(STR(nBadHeads))
IF nAPP == 0        // Это для ввода в SEEK Пойдем, Витя, по твоему пути. Чтобы усе было как можно менее заморочено





cCol_Say := COL_INPUT

//        ShadowBox("[ Закупки ]",MaxRow()/2 - 8, MaxCol()/2-39,MaxRow()/2+7,MaxCol()/2+39,cCol_SAY)
        ShadowBox("[ Закупки ]",MaxRow()/2 - 8, MaxCol()/2-39,MaxRow()/2+6,MaxCol()/2+39,cCol_SAY)
        nTop := MaxRow()/2 - 8
        nLeft :=  MaxCol()/2-39

AADD(aArr, {0 , "             "})
//AADD(aIzm, {"     ","     "})

//ALTD()

@ nTop+1,nLeft+2 SAY "Система заказа..................." COLOR cCol_SAY
cStr := "aIn["+ALLTRIM(STR(i+1))+"]"
b_1 := &("{|x| RotateBlock(x,aArr,'"+cStr+"')}")
oGetNew := GetNew(nTop+1,nLeft+36,b_1)
oGetNew:reader := {|oGetNew| RotateAndReader(oGetNew,aArr) }
oGetNew:Picture := "XXXXXXXXXXXXX"
oGetNew:display()
AADD(GetList,oGetNew)

/*cStr := "aIn["+ALLTRIM(STR(i+2))+"]"
b_2 := &("{|| "+cStr+" := ' '}")
EVAL(b_2)*/   // это для тог, чтобы обнулить поле и по нему не делать поиска.



cStr := "aIn["+STR(i+3)+"]"
@nTop+2,nLeft+2 SAY "Поставщик........................" COLOR cCol_SAY
@ nTop+2,nLeft+36 REFER cRef+"V_VENDORS" GET &cStr PICTURE "XXXXXX"


cStr := "aIn["+STR(i+4)+"]"
@ nTop+3,nLeft+2 SAY "Код по каталогу.................." COLOR cCol_SAY
@ nTop+3,nLeft+36 GET &cStr PICTURE REPLICATE("X",20)

cStr := "aIn["+STR(i+5)+"]"
@ nTop+4,nLeft+2 SAY "Название по каталогу............." COLOR cCol_SAY
@ nTop+4,nLeft+36 GET &cStr PICTURE REPLICATE("X",30)

cStr := "aIn["+ALLTRIM(STR(i+6))+"]"
//b_3 := &("{|x| RotateBlock(x,aIzm,'"+cStr+"')}")
@ nTop+5,nLeft+2 SAY "ЕИ закупки......................."  COLOR cCol_SAY
@ nTop+5,nLeft+36 GET &cStr PICTURE "XXXXX"
oGetNew := GetNew(nTop+5,nLeft+36,b_3)




cStr := "aIn["+STR(i+7)+"]"
b_4 := &("{||"+ cStr+":= '   '}")
EVAL(b_4)
@ nTop+6,nLeft+2 SAY "Код валюты......................."  COLOR cCol_SAY
@ nTop+6,nLeft+36 GET &cStr PICTURE "XXX"




cStr := "aIn["+STR(i+8)+"][1]"
@ nTop+7,nLeft+2 SAY "Цена поставщика..................                     -                    " COLOR cCol_SAY
@ nTop+7,nLeft+36 GET &cStr PICTURE "99999999999999.9999"
cStr := "aIn["+STR(i+8)+"][2]"
@ nTop+7,nLeft+58 GET &cStr PICTURE "99999999999999.9999"



cStr := "aIn["+STR(i+9 )+"][1]"
@ nTop+8,nLeft+2 SAY "Минимальная партия...............                     -                   " COLOR cCol_SAY
@ nTop+8,nLeft+36 GET &cStr PICTURE "99999999999999.9999"
cStr := "aIn["+STR(i+9)+"][2]"
@ nTop+8,nLeft+58 GET &cStr PICTURE "99999999999999.9999"



cStr := "aIn["+STR(i+10)+"][1]"
@ nTop+ 9,nLeft+2 SAY "Максимальная партия..............                     -                   " COLOR cCol_SAY
@ nTop+ 9,nLeft+36 GET &cStr PICTURE "99999999999999.9999"
cStr := "aIn["+STR(i+10)+"][2]"
@ nTop+9,nLeft+58 GET &cStr PICTURE "99999999999999.9999"



cStr := "aIn["+STR(i+11)+"][1]"
@ nTop+10,nLeft+2 SAY "Время доставки...................     -                   " COLOR cCol_SAY
@ nTop+10,nLeft+36 GET &cStr  PICTURE "999"
cStr := "aIn["+STR(i+11)+"][2]"
@ nTop+10,nLeft+42 GET &cStr  PICTURE "999"



cStr := "aIn["+STR(i+12)+"][1]"
@ nTop+11,nLeft+2 SAY "Точка заказа.....................                     -                   " COLOR cCol_SAY
@ nTop+11,nLeft+36 GET &cStr PICTURE "99999999999999.9999"
cStr := "aIn["+STR(i+12)+"][2]"
@ nTop+11,nLeft+58 GET &cStr PICTURE "99999999999999.9999"



cStr := "aIn["+STR(i+13)+"][1]"
@ nTop+12,nLeft+2 SAY "Объем заказа.....................                     -                   " COLOR cCol_SAY
@ nTop+12,nLeft+36 GET &cStr PICTURE "99999999999999.9999"
cStr := "aIn["+STR(i+13)+"][2]"
@ nTop+12,nLeft+58 GET &cStr PICTURE "99999999999999.9999"

//cStr := "aIn["+STR(i+14)+"][1]"
//@ nTop+13,nLeft+2 SAY "Максимальный запас...............                     -                   " COLOR cCol_SAY
//@ nTop+13,nLeft+36 GET &cStr PICTURE "99999999999999.9999"
//cStr := "aIn["+STR(i+14)+"][2]"
//@ nTop+13,nLeft+58 GET &cStr PICTURE "99999999999999.9999"


/*cStr := "aIn["+ALLTRIM(STR(i+15))+"][1]"
@ nTop+14,nLeft+2 SAY "Страховой запас..................                     -                   " COLOR cCol_SAY
@ nTop+14,nLeft+36 GET &cStr PICTURE "99999999999999.9999"
cStr := "aIn["+STR(i+15)+"][2]"
@ nTop+14, nLeft+58 GET &cStr PICTURE "99999999999999.9999"*/

cStr := "aIn["+ALLTRIM(STR(i+14))+"][1]"
@ nTop+13,nLeft+2 SAY "Страховой запас..................                     -                   " COLOR cCol_SAY
@ nTop+13,nLeft+36 GET &cStr PICTURE "99999999999999.9999"
cStr := "aIn["+STR(i+14)+"][2]"
@ nTop+13, nLeft+58 GET &cStr PICTURE "99999999999999.9999"

SET CURSOR ON
READ
SET CURSOR OFF






ELSE
IF V_lSpec != NIL
        cCol_SAY := COL_REF1
ELSE
        cCol_Say := COL_INPUT
ENDIF
//cCol_SAY := SETCOLOR()


//        ShadowBox("[]",MaxRow()/2 - 8, MaxCol()/2-35,MaxRow()/2+7,MaxCol()/2+35,cCol_SAY)
        ShadowBox("[]",MaxRow()/2 - 8, MaxCol()/2-35,MaxRow()/2+6,MaxCol()/2+35,cCol_SAY)
        nTop := MaxRow()/2 - 8
        nLeft :=  MaxCol()/2-35

IF LEN(aIzm)==0
        AADD(aIzm,{iMLABEL->ED ,iMLABEL->ED })
ENDIF







@ nTop+1,nLeft+2 SAY "Система заказа..................." COLOR cCol_SAY
cStr := "aIn["+ALLTRIM(STR(i+1))+"]"
b_1 := &("{|x| RotateBlock(x,aArr,'"+cStr+"')}")
oGetNew := GetNew(nTop+1,nLeft+36,b_1)
oGetNew:reader := {|oGetNew| RotateAndReader(oGetNew,aArr) }
oGetNew:PostBlock := {|| CorrectPolicy(i)}
oGetNew:display()
oGetNew:Picture := "XXXXXXXXXXXXX"
AADD(GetList,oGetNew)


cStr := "aIn["+STR(i+3)+"]"
//(GetPrefix()+"Partner")->(ReferPartSet(cRef+"V_VENDORS",{cStr},{"CODE"},2,,"UPPER("+cStr+")"))
@nTop+2,nLeft+2 SAY "Поставщик........................" COLOR cCol_SAY
@ nTop+2,nLeft+36 REFER cRef+"V_VENDORS" GET &cStr

cStr := "aIn["+STR(i+4)+"]"
//ALTD()
//IF nApp =S_LIB_ADD.AND.EMPTY(&cStr)
//    cStr :=PADR(aIn[2] ,LEN(&cStr))
//ENDIF
@ nTop+3,nLeft+2 SAY "Код по каталогу.................." COLOR cCol_SAY
@ nTop+3,nLeft+36 GET &cStr

cStr := "aIn["+STR(i+5)+"]"
@ nTop+4,nLeft+2 SAY "Название по каталогу............." COLOR cCol_SAY
@ nTop+4,nLeft+36 GET &cStr


cStr := "aIn["+ALLTRIM(STR(i+6))+"]"
//b_2 := &("{|| IF(nAPP = 2, aIzm := {PADR(aIn[4],5),PADR(aIn[4],5)},),IF(EMPTY(ALLTRIM("+cStr+")), "+cStr+" := aIn[4],),.T.}")
b_2 := &("{|| IF(nAPP = 2, aIzm := {{PADR(aIn[4],5),PADR(aIn[4],5)}},),.T.}")
b_3 := &("{|| IF((NAPP!=2).AND.!EMPTY(aIzm),!EMPTY(ALLTRIM("+cStr+")),(IIF(EMPTY(ALLTRIM("+cStr+")).AND.NAPP=2,"+cStr+":= PADR(aIn[4],5),NIL),.T.))}")
b_7 := &("{|x| RotateBlock(x,aIzm,'"+cStr+"')}")

@ nTop+5,nLeft+ 2 SAY "ЕИ закупки......................."  COLOR cCol_SAY
        //@ nTop+5,nLeft+36 GET &cStr PICTURE "XXXXX"
oGetNew := GetNew(nTop+5,nLeft+36,b_7)
oGetNew:reader := {|oGetNew| RotateAndReader(oGetNew,aIzm) }
oGetNew:Picture := "XXXXX"
oGetNew:PreBlock := b_2
oGetnew:PostBlock := b_3
oGetNew:display()
AADD(GetList,oGetNew)




cStr := "aIn["+STR(i+7)+"]"
//(GetPrefix()+"V_VALUTA")->(MakeValutaRefer(cRef+'V_Valuta',cStr,1))
b_4 := &("{|| IF(EMPTY(ALLTRIM("+cStr+")), "+cStr+" := "+GetPrefix()+"MLabeL->CODEVAL,),.T.}")
@ nTop+6,nLeft+2 SAY "Код валюты......................."  COLOR cCol_SAY
@ nTop+6,nLeft+36 REFER cRef+"V_VALUTA" GET &cStr
GetList[LEN(GetList)]:PreBlock := b_4




cStr := "aIn["+STR(i+8)+"]"
@ nTop+7,nLeft+2 SAY "Цена поставщика.................." COLOR cCol_SAY
@ nTop+7,nLeft+36 GET &cStr

cStr := "aIn["+STR(i+9 )+"]"
@ nTop+8,nLeft+2 SAY "Минимальная партия..............." COLOR cCol_SAY
@ nTop+8,nLeft+36 GET &cStr

cStr := "aIn["+STR(i+10)+"]"
@ nTop+ 9,nLeft+2 SAY "Максимальная партия.............." COLOR cCol_SAY
@ nTop+ 9,nLeft+36 GET &cStr

cStr := "aIn["+STR(i+11)+"]"
b_5 :=  &("{|| aIn["+STR(i+2)+"] == 1}")
@ nTop+10,nLeft+2 SAY "Время доставки..................." COLOR cCol_SAY
@ nTop+10,nLeft+36 GET &cStr
GetList[LEN(GetList)]:PreBlock := b_5

cStr := "aIn["+STR(i+12)+"]"
b_6 := &("{|| aIn["+STR(i+2)+"] == 2}")
@ nTop+11,nLeft+2 SAY "Точка заказа....................." COLOR cCol_SAY
@ nTop+11,nLeft+36 GET &cStr
GetList[LEN(GetList)]:PreBlock := b_6
GetList[LEN(GetList)]:PostBlock := &("{|| IIF(aIn["+STR(i+12)+"] > 0,.T.,SayError('Точка заказа не может быть нулевой!'))}")

cStr := "aIn["+STR(i+13)+"]"
@ nTop+12,nLeft+2 SAY "Объем заказа....................." COLOR cCol_SAY
@ nTop+12,nLeft+36 GET &cStr 
GetList[LEN(GetList)]:PreBlock := &("{|| aIn["+STR(i+1)+"]== 3}")
GetList[LEN(GetList)]:PostBlock := &("{|| IIF(aIn["+STR(i+1)+"]!= 3,.T.,IIF(aIn["+STR(i+13)+"] > aIn["+STR(i+12)+"].OR.(aIn["+STR(i+13)+"] <= aIn["+STR(i+12)+"].AND.LastKey() == "+STR(K_UP)+"),.T.,SayError('Объем заказа меньше точки заказа!'))  )}")
//GetList[LEN(GetList)]:PostBlock := &("{|| IIF(aIn["+STR(i+13)+"] >= aIn["+STR(i+12)+"],.T.,SayError('Объем заказа меньше точки заказа!'))}")

//cStr := "aIn["+STR(i+14)+"]"
//@ nTop+13,nLeft+2 SAY "Максимальный запас..............." COLOR cCol_SAY
//@ nTop+13,nLeft+36 GET &cStr



/*cStr := "aIn["+STR(i+15)+"]"
@ nTop+14,nLeft+2 SAY "Страховой запас.................." COLOR cCol_SAY
@ nTop+14,nLeft+36 GET &cStr*/

cStr := "aIn["+STR(i+14)+"]"
@ nTop+13,nLeft+2 SAY "Страховой запас.................." COLOR cCol_SAY
@ nTop+13,nLeft+36 GET &cStr

SET CURSOR ON
READ
SET CURSOR OFF



ENDIF


dbPop()

RestSet(aSet)
RestSetKey(aKey)
GetList := {}
GetList := OldGetList


ENDIF //IF iMLABEL->(FieldPos("ORD_SYST")) > 0


RETURN

// корректировка политики заказа.

FUNCTION CorrectPolicy(n)
IF nAPP != 0
      IF aIN[n+1] == 0 // если система заказа не определена
                aIn[n+2] := 0 // то политика не определена
      ENDIF
      IF aIN[n+1] == 1// если система заказа на заказ
                aIn[n+2] := 1 // то политика поставка на заказ
      ENDIF
      IF aIN[n+1] == 2// если система заказа на период
                aIn[n+2] := 1// то политика поставка на заказ
      ENDIF
      IF aIN[n+1] == 3// если система заказа по остатку
                aIn[n+2] := 2// то политика поставка на склад
      ENDIF
      IF aIN[n+1] == 4// если система заказа    ручной заказ
                aIn[n+2] := 0// то политика не опрделена
      ENDIF
ENDIF
RETURN .T.


#endif



PROCEDURE ShowDopAttr()
Local aArray := {}
Local cStr
Local i
AADD(aArray,"Группа:"+iMLABEL->GRUP)
AADD(aArray,"  Номенклатура:"+iMLABEL->NNUM)
AADD(aArray, "Дополнительные атрибуты:")
i := LEN(aArray)
IF iMLABEL->(FieldPos("CDATTR1")) > 0
IF iCCDOPNAME1[2]
   cStr :=" "+ PADR(IIF(EMPTY(ALLTRIM(iCCDOPNAME1[1])),"Доп.атрибут 1 (симв)",ALLTRIM(iCCDOPNAME1[1])),20,".")+":" + iMLABEL->CDATTR1
   AADD(aArray,cStr)
ENDIF
IF iCCDOPNAME2[2]
   cStr :=" "+ PADR(IIF(EMPTY(ALLTRIM(iCCDOPNAME2[1])),"Доп.атрибут 2 (симв)",ALLTRIM(iCCDOPNAME2[1])),20,".")+":" + iMLABEL->CDATTR2
   AADD(aArray,cStr)
ENDIF


IF iCCDOPNAME3[2]
   cStr :=" "+ PADR(IIF(EMPTY(ALLTRIM(iCCDOPNAME3[1])),"Доп.атрибут 3 (симв)",ALLTRIM(iCCDOPNAME3[1])),20,".")+":" + iMLABEL->CDATTR3
   AADD(aArray,cStr)
ENDIF


IF iCCDOPNAME4[2]
   cStr :=" "+ PADR(IIF(EMPTY(ALLTRIM(iCCDOPNAME4[1])),"Доп.атрибут 4 (симв)",ALLTRIM(iCCDOPNAME4[1])),20,".")+":" + iMLABEL->CDATTR4
   AADD(aArray,cStr)
ENDIF

IF iCNDOPNAME1[2]
   cStr := PADR(IIF(EMPTY(ALLTRIM(iCNDOPNAME1[1])),"Доп.атрибут 5 (числ)",ALLTRIM(iCNDOPNAME1[1])),20,".")+":" + STR(iMLABEL->NDATTR1)
   AADD(aArray,cStr)
ENDIF

IF iCNDOPNAME2[2]
   cStr := PADR(IIF(EMPTY(ALLTRIM(iCNDOPNAME2[1])),"Доп.атрибут 6 (числ)",ALLTRIM(iCNDOPNAME2[1])),20,".")+":" + STR(iMLABEL->NDATTR2)
   AADD(aArray,cStr)
ENDIF

IF LEN(aArray) > i
SayAndWait(aArray)
ENDIF

ENDIF
RETURN





//--------------------------------------------------------------------------//
STATIC FUNCTION Razm()
//--------------------------------------------------------------------------//
LOCAL aSetKey:=SaveSetKey()
LOCAL aSet:=SaveSet()
LOCAL cLastColor:=SETCOLOR(COL_SHEADR)
LOCAL nTop:=7,nLeft:=5,nBottom:=20,nRight:=74
LOCAL i
LOCAL aFo:={;
PADR('Основная единица учета '+NA_SCLADE,40),;
iMLABEL->Algo1,iMLABEL->Algo2,iMLABEL->Algo3}
LOCAL aR:={SPACE(13),iMLABEL->R1,iMLABEL->R2,iMLABEL->R3}
LOCAL cDisp := TRIM(iMLABEL->Name)
LOCAL aEd:={{0,iMLABEL->Ed},{1,iMLABEL->Ed1},{2,iMLABEL->Ed2},{3,iMLABEL->Ed3}}
LOCAL aVEd := {}
LOCAL bIncEd := {|| aVEd := {},AEVAL(aEd,{|x,n| IF(!EMPTY(x[2]),AADD(aVEd,{LEN(aVEd),x[2],aFo[n],aR[n]}),NIL) }),IF(EMPTY(aVEd),AADD(aVEd,{0,iMLABEL->Ed,"",0}),NIL) }
LOCAL bEd := {|lDisp,oGet,oGet1| IF(oGet != NIL .AND. !EMPTY(oGet:VarGet()) .AND. EMPTY(oGet1:VarGet()),oGet1:VarPut(PADR("Q*R",LEN(oGet1:VarGet()))),NIL),EVAL(bIncEd),IF(lDisp,(m->GetList[11]:display(),m->GetList[12]:display()),NIL),.T. }

PRIVATE GetList:={}, oGetNew
PRIVATE nPrix := iMLABEL->N_P, nRasx := iMLABEL->N_R
IF iMLABEL->(EOF())
   RETURN(1)
ENDIF
ShadowBox("",nTop,nLeft,nBottom,nRight,COL_SHEADR)
SAYSCREEN(CENTER(cDisp,68),nTop+1,nLeft+1)
SAYSCREEN('───────┬────────────────────────────────────────────┬───────────────',nTop+2,nLeft+1)
SAYSCREEN('  Ед   │ Формула расчета кол-ва в основных единицах │  Значение R   ',nTop+3,nLeft+1)
SAYSCREEN(' измер.│  (Q-кол-во в доп.ед., R-вводимый коэф-т)   │ по умолчанию  ',nTop+4,nLeft+1)
SAYSCREEN('───────┼────────────────────────────────────────────┼───────────────',nTop+5,nLeft+1)
//          12345 │ 123456789012345678901234567890123456789012 │ 1234567890123
@ nTop+6,nLeft+2 GET aEd[1,2] VALID {|oGet| ValidEd(oGet,aEd,1).AND.EVAL(bEd,.T.) }
@ nTop+6,nLeft+8 SAY '│ '+aFo[1]
@ nTop+6,nLeft+53 SAY '│'+aR[1]
@ nTop+7,nLeft+2 GET aEd[2,2] VALID {|oGet| ValidEd(oGet,aEd,2).AND.EVAL(bEd,.T.,oGet,GetList[CurrentGet()+1]) }
@ nTop+7,nLeft+8 SAY '│' GET aFo[2] WHEN {|| VFo(aFo[2],GetList[CurrentGet()+1]),.T.} VALID {|| VFo(aFo[2],GetList[CurrentGet()+1]) }
@ nTop+7,nLeft+53 SAY '│'
@ nTop+7,nLeft+54 GET aR[2] PICT '999999999.99999' WHEN 'R'$UPPER(aFo[2]) VALID {|| VFo(aFo[2],GetList[CurrentGet()]) }
@ nTop+8,nLeft+2 GET aEd[3,2] VALID {|oGet| ValidEd(oGet,aEd,3).AND.EVAL(bEd,.T.,oGet,GetList[CurrentGet()+1],GetList[CurrentGet()+2]) }
@ nTop+8,nLeft+8 SAY '│' GET aFo[3] WHEN {|| VFo(aFo[3],GetList[CurrentGet()+1]),.T.} VALID {|| VFo(aFo[3],GetList[CurrentGet()+1]) }
@ nTop+8,nLeft+53 SAY '│'
@ nTop+8,nLeft+54 GET aR[3] PICT '999999999.99999' WHEN 'R'$UPPER(aFo[3]) VALID {|| VFo(aFo[3],GetList[CurrentGet()]) }
@ nTop+9,nLeft+2 GET aEd[4,2] VALID {|oGet| ValidEd(oGet,aEd,4).AND.EVAL(bEd,.T.,oGet,GetList[CurrentGet()+1],GetList[CurrentGet()+2]) }
@ nTop+9,nLeft+8 SAY '│' GET aFo[4] WHEN {|| VFo(aFo[4],GetList[CurrentGet()+1]),.T.} VALID {|| VFo(aFo[4],GetList[CurrentGet()+1]) }
@ nTop+9,nLeft+53 SAY '│'
@ nTop+9,nLeft+54 GET aR[4] PICT '999999999.99999' WHEN 'R'$UPPER(aFo[4]) VALID {|| VFo(aFo[4],GetList[CurrentGet()]) }
@ nTop+10,nLeft SAY "╟"+REPLICATE('─',nRight-nLeft-1)+"╢"
@ nTop+10,nLeft+8 SAY '┴'
@ nTop+10,nLeft+53 SAY '┴'

@ nTop+11,nLeft+1 SAY "  Основная единица измерения для документов прихода :"

EVAL(bEd,.F.)

oGetNew := GetNew(nTop+11, COL()+1,{|x| RotateBlock(x,aVEd,"nPrix") })
oGetNew:reader := {|oGet| RotateAndReader(oGet,aVEd) }
oGetNew:display()
AADD(GetList,oGetNew)

@ nTop+12,nLeft+1 SAY "  Основная единица измерения для документов расхода :"

oGetNew := GetNew(nTop+12, COL()+1,{|x| RotateBlock(x,aVEd,"nRasx") })
oGetNew:reader := {|oGet| RotateAndReader(oGet,aVEd) }
oGetNew:display()
AADD(GetList,oGetNew)


SETCURSOR(1)
READ
SETCURSOR(0)

EVAL(bIncEd)
AEVAL(aEd,{|x,n| IF(n <= LEN(aVEd),(aEd[n,2] := aVEd[n,2],aFo[n] := aVEd[n,3],aR[n] := aVEd[n,4]),(aEd[n,2] := BLANK(aEd[n,2],.T.),aFo[n] := BLANK(aFo[n]),aR[n] := BLANK(aR[n],.T.))) })

IF EMPTY(aEd[MemVar->nRasx+1,2])
  MemVar->nRasx := 0
ENDIF
IF EMPTY(aEd[MemVar->nPrix+1,2])
  MemVar->nPrix := 0
ENDIF

SELECT iMLABEL
RecLock()
REPLACE Ed WITH aEd[1,2],Ed1 WITH aEd[2,2],Ed2 WITH aEd[3,2],Ed3 WITH aEd[4,2],;
Algo1 WITH aFo[2],Algo2 WITH aFo[3],Algo3 WITH aFo[4],;
R1 WITH aR[2],R2 WITH aR[3],R3 WITH aR[4], FIELD->N_P WITH MemVar->nPrix, FIELD->N_R WITH MemVar->nRasx
UNLOCK
RestSet(aSet)
RestSetKey(aSetKey)
RETURN (3)

STATIC FUNCTION ValidEd(oGet,aEd,nEd)
LOCAL lRet:=.T.
      AEVAL(aEd,{|x,i| lRet:= lRet.AND.(i==nEd.OR.(UPPER(oGet:VarGet())!=UPPER(x[2]).OR.EMPTY(x[2]) )) })
RETURN lRet.OR.SayError({"Наименования единиц измерения должны быть различны!"})


STATIC FUNCTION VFo(cFo,oGet)
PRIVATE Q:=1,R:=1
IF EMPTY(cFo).OR.TYPE(cFo)='N'
   IF("R" $ cFo.AND.EMPTY(oGet:VarGet()),(oGet:VarPut(1),oGet:Display()),NIL)
   RETURN(.T.)
ENDIF
SayError('Ошибка в формуле')
RETURN(.F.)

FUNCTION DispOst(lSec,cPartia,lSclad)  //Есть обращение из S_Kassa.prg!
LOCAL aSetKey:=SaveSetKey()
LOCAL aSet := SaveSet()
LOCAL nArea:=SELECT()
LOCAL cLastColor:=SETCOLOR(COL_SHEADR)
LOCAL a:={},i,n
LOCAL aEd:=IniEd()
LOCAL nKolEd:=IF(LEN(aEd)<1,1,LEN(aEd))
LOCAL nLen:=0,nKol1
LOCAL aKol:={},aKol0:=ARRAY(nKolEd),aName:={}, aPart := {}
LOCAL aFormat:=ARRAY(nKolEd), lPartia := .F.
LOCAL aBase := {;
                 {GetPrefix()+"MKART",GetPrefixPath()+"MKART"},;
                 {GetPrefix()+"MLABEL",GetPrefixPath()+"MLABEL"},;
                 {GetPrefix()+"MSCHET",GetPrefixPath()+"MSCHET"},;
                 {GetPrefix()+"SPR_PART",GetPrefixPath()+"SPR_PART"};
               }
LOCAL nRec :=  iMLABEL->(RECNO())
PRIVATE bPart := {|| EMPTY(iMKART->NNUM) .OR. !EMPTY(iMKART->PARTIA) .OR. (EMPTY(iMKART->PARTIA) .AND. iMSCHET->XRAN != '1') }
BEGIN SEQUENCE
dbOpenBases(aBase)

AFILL(aKol0,0)
AFILL(aFormat,0)
iMSCHET->(ORDSETFOCUS("MSCHET"))
iMKART->(ORDSETFOCUS("MKART"))
iMLABEL->(ORDSETFOCUS("MLABEL"),dbGoTo(nRec))
SELECT iMKART
SET RELATION TO UPPER(SCHET) INTO iMSCHET
dbSetFilter(bPart,"EVAL(bPart)")

PRIVATE Q,R,pFor
DBSEEK(iMLABEL->(UPPER(Grup+NNum+IF(cPartia = NIL,"",cPartia)+IF(lSclad==NIL,"",m->pSclad))))
WHILE UPPER(Grup+NNum+IF(cPartia = NIL,"",Partia)+IF(lSclad==NIL,"",Sclad))==UPPER(iMLABEL->(Grup+NNum)+IF(cPartia = NIL,"",cPartia)+IF(lSclad==NIL,"",pSclad)) .AND. !EOF()
   IF (lSec==NIL.OR.(lSec!=NIL.AND.iMSCLAD->(DBSEEK(UPPER(iMKART->Sclad))).AND.iMSCLAD->Type='1')).AND.;
      ( GlobalTask != 'SR' .OR. GlobalTask != 'ZR'.OR.ASCAN(aSclad,{|x|UPPER(SUBSTR(x,2,6))==UPPER(iMKART->Sclad)})>0)
      AADD(aName,Sclad)
      IF cPartia = NIL
        AADD(aPart,Partia)
        lPartia := lPartia .OR. !EMPTY(Partia)
      ENDIF
      AADD(aKol,ARRAY(nKolEd))
      AFILL(aKol[(n:=LEN(aKol))],0)
      FOR i:=1 TO LEN(aEd)
      pFor:=aEd[i,3]
      Q:=1;R:=aEd[i,4]
      nKol1:=1
      IF !EMPTY(pFor).AND.TYPE(pFor)='N'
         nKol1:=&pFor
      ENDIF
      aKol[n,i]:=Div(KolTek,nKol1)
      aKol0[i]+=aKol[n,i]
      NEXT
   ENDIF
   SKIP
ENDDO
AADD(aPart,'     ')
AADD(aName,'Итого:')
AADD(aKol,aKol0)
AEVAL(aKol0,{|x,j| aFormat[j]:= 15, nLen+=aFormat[j]+7})

AADD(a,PADC(TRIM(iMLABEL->Name),11+nLen))
IF cPartia != NIL
  iSPR_PART->(ORDSETFOCUS("TAG_NUM"))
  iSPR_PART->(dbSeek(UPPER(iMLABEL->GRUP+iMLABEL->NNUM+cPartia)))
  AADD(a,PADC(TRIM(iSPR_PART->NAME),11+nLen))
ENDIF
AADD(a,'─────────┬─'+IF(lPartia,'──────┬','')+REPLICATE('─',nLen+1))
AADD(a,' '+_UP_SCLAD+'  │ '+IF(lPartia,'Партия│ ',' ')+PADC('Остаток',nLen))
AADD(a,'─────────┼─'+IF(lPartia,'──────┼','')+REPLICATE('─',nLen+1))

iMGRUP->(DBSEEK(UPPER(iMLABEL->GRUP)))
FOR n:=1 TO LEN(aKol)
  IF n==LEN(aKol)
    AADD(a,'─────────┼─'+IF(lPartia,'──────┼─','')+REPLICATE('─',nLen))
  ENDIF
  AADD(a,' '+aName[n]+'  │ '+IF(lPartia,aPart[n]+' │ ',''))
  FOR i:=1 TO LEN(aEd)
    a[LEN(a)]+=StrS(aKol[n,i],aFormat[i],IF(i = 1,iMGRUP->Kol_,iMGRUP->Kol1_))+' '+aEd[i,1]+' '
  NEXT
NEXT

IF !EMPTY(a) .AND. LEN(a[1]) > 75
  EVAL(ListBlockPrint(a))
ELSE
  SetKey(K_F9,ListBlockPrint(a))
  ScrTitul(MaxRow()-1,"")
  ScrTitul(MaxRow(),"ESC:Выход F9:Печать")
  BoxMenu('',5,40-LEN(a[1])/2,a)
ENDIF
END SEQUENCE

dbCloseBases(aBase)
SETCOLOR(cLastColor)
SELECT(nArea)
RestSetKey(aSetKey)
RestSet(aSet)
RETURN(1)
//--------------------------------------------------------------------------//
                  STATIC FUNCTION CloseKart(lMode)
//--------------------------------------------------------------------------//
LOCAL sRet:=SETKEY(K_RETURN,NIL)
LOCAL lYes,cGrup:=Grup,nProces, lYes1, lYes2, lYes3
LOCAL nOrd:=ORDNUMBER()
LOCAL aScope,nRec,nRecNo:=RECNO()
LOCAL aBase := ;
 {;
   {GetPrefix()+"MSCHET",GetPrefixPath()+"MSCHET"},;
   {GetPrefix()+"MSTRU",GetPrefixPath()+"MSTRU"},;
   {GetPrefix()+"MDOCM",GetPrefixPath()+"MDOCM"},;
   {"MCODOP",GetPrefixPath()+"MCODOP"},;
   {"MBPSCHET",LoadPath()+"ZAPAS\MBPSCHET"},;
    {GetPrefix()+'SPR_PART',GetPrefixPath()+'SPR_PART'};
 }, aS45 := {}
LOCAL bSave := {|lError|;
            lYes := .F.,;
            lYes2 := .F.,;
            lYes3 := .F.,;
            lYes1 := IsSeekNom(GetPrefix(),iMLABEL->GRUP,iMLABEL->NNUM),;
            lYes1 .AND. (AEVAL(aS45,{|cSchet| lYes2 := lYes2 .OR. iMDOCM->(dbSeek(UPPER(cSchet+iMLABEL->GRUP+iMLABEL->NNUM))) }),.T.),;
            !lYes1 .AND. iMKART->(DBSEEK(UPPER(iMLABEL->(Grup+NNum)))),;
            !lYes1 .AND. iMKART->(DBEVAL({|| lYes := .T. },{|| EMPTY(iMKART->Status) .AND. (!EMPTY(iMKART->PARTIA) .OR. !IsUhetPartia(iMLABEL->GRUP,.T.)) },{|| !lYes .AND. UPPER(iMKART->Grup+iMKART->NNUM) == UPPER(iMLABEL->Grup+iMLABEL->NNum) }),.T.),;
            !lYes1 .AND. !lYes2 .AND. (lYes3:=iSPR_PART->(dbSEEK(' '+UPPER(iMLABEL->GRUP+iMLABEL->NNUM)))),;
            IF(!lYes1 .AND. !lYes .AND. !lYes2 .AND. !lYes3 .AND. RecLock(),;
               (iMLABEL->Status := '1',DBUNLOCK()),;
               IF(!EMPTY(lError),;
                  SayError(IF(lYes,'Ном.номер задействован в картотеке!',;
                                   IF(lYes2,;
                                      IF(GlobalTask = "09" .OR. GetPrefix() == "Z",;
                                         'Ном.номер задействован в журнале учета "МБП в эксплуатации"!',;
                                         {'Ном.номер задействован в журнале учета','"Товаров отгруженных"!'}),;
                                      IF(lYes3,"Номенклатурный номер задействован в карточке партии",;
                                               " Номенклатурный номер задействован в счетах-фактурах !")))),NIL));
                }
IF lMode
   lYes:=YesOrNo('Закрыть и поместить в архив (Esc-отмена):',,;
   '     - номенклатурный номер     ',;
   ' - все незадействованные номера ')
   IF LASTKEY()!=K_ESC
      dbOpenBases(aBase)
      iMDOCM->(ORDSETFOCUS("MDOCM_AM"))
      MCODOP->(ORDSETFOCUS("MCODOP_C"))
      iSPR_PART->(ORDSETFOCUS("TAG_SNUM"))
      IF GlobalTask = "03" .OR. GetPrefix() == "S"
        MCODOP->(dbSeek("23"))
        MCODOP->(DBEVAL({|| AADD(aS45,MCODOP->SCHET_A) },,{|| MCODOP->VID+MCODOP->TYPE = "23" }))
      ELSEIF GlobalTask = "09" .OR. GetPrefix() == "Z"
        MBPSCHET->(DBEVAL({|| AADD(aS45,MBPSCHET->SCHET) }))
      ENDIF
      SELECT iMLABEL
      IF lYes
         SKIP
         IF EOF()
            GO TOP
         ENDIF
         nRec:=RECNO()
         GO nRecNo
         EVAL(bSave,.T.)
      ELSE
         aScope:=SetScope()
         ORDSETFOCUS('MLabel') //Переходим в независимый индекс Grup+NNum
         GO TOP
         nProces := Proces_Ini(LASTREC(),,,"Закрытие ном.номеров ")
         WHILE !EOF()
            Proces_Update(nProces)
            EVAL(bSave)
            SKIP
         ENDDO
         ORDSETFOCUS(nOrd)
         SetScope(aScope)
         GO TOP
         nRec := RECNO()
         Proces_End()
      ENDIF
      dbCloseBases(aBase)
      iMLABEL->(dbGoTo(nRec))
   ENDIF
ELSEIF YesOrNo('Открыть ном.номер?')
   SKIP
   IF EOF()
      GO TOP
   ENDIF
   nRec:=RECNO()
   GO nRecNo
   RecLock()
   REPLACE Status WITH ' '
   UNLOCK
   GO nRec
ENDIF
SETKEY(K_RETURN,sRet)
RETURN(2)

STATIC FUNCTION DispAttr()
    LOCAL cDisp := ""
    LOCAL bDispAttr := {|cName,nRow,nCol|;
                        IF(;
                           &(GetPrefix(cName+"_"))[2],;
                           SAYSCREEN(&(GetPrefix(cName+"_"))[1]+':'+LEFT(iMLABEL->(FieldGet(FieldPos(cName))),25),nRow,nCol),;
                           NIL;
                           );
                        }
    LOCAL bDispKoef := {|cName|;
                        IF(;
                           &(GetPrefix(cName+"_"))[2],;
                           cDisp += ALLTRIM(&(GetPrefix(cName+"_"))[1])+': '+ALLTRIM(STR(iMLABEL->(FieldGet(FieldPos(cName))),13,3))+" ",;
                           NIL;
                           );
                        }
EVAL(bDispAttr,"Marka",20,08)
EVAL(bDispAttr,"Sort",21,08)
EVAL(bDispAttr,"Profil",20,43)
EVAL(bDispAttr,"Razmer",21,43)
EVAL(bDispKoef,"Koef")
EVAL(bDispKoef,"Koef1")

IF TYPE(itNorma) = "A" .AND. iNorma[2].AND.!EMPTY(iMLABEL->Norma)
   cDisp += 'Норма запаса: '+ALLTRIM(STRS(iMLABEL->Norma,13,3))+' '
ENDIF

SAYSCREEN(PADC(cDisp,65),22,08)

RETURN(NIL)

STATIC FUNCTION DispTree()
LOCAL nTop := 16, nLeft := 6

DispBegin()


IF cSaveScrDisp = NIL
   cSaveScrDisp := SAVESCREEN(nTop,nLeft,MaxRow(),MaxCol())
ENDIF

IF LASTKEY() = K_ALT_I
  MemVar->lDispAttr := !MemVar->lDispAttr
  IF !MemVar->lDispAttr
    RESTSCREEN(nTop,nLeft,MaxRow(),MaxCol(),cSaveScrDisp)
  ENDIF
ENDIF

IF MemVar->lDispAttr
  // Отображение иерархического справочника
  DispLabelTree(nTop,nLeft,iMLABEL->NNOPER,COL_REFER,.F.,NIL,{|| RESTSCREEN(nTop,nLeft,MaxRow(),MaxCol(),cSaveScrDisp) })
ENDIF

DispEnd()

RETURN NIL
//----------------------------------------------------------------------------//
                       FUNCTION LabelPrint()
//----------------------------------------------------------------------------//
// Печать номенклатурного справочника
   STATIC sIn
   LOCAL nTop := INT(MAXROW()/2-7), nLeft := INT(MAXCOL()/2-27), aSet := SaveSet(), aSetKeys := SaveSetKey()
   LOCAL aHeader, nLen
   LOCAL aCols, bFor, lRun := .F.,bakRec, lSeek, cPict, nRound, nProces
   LOCAL aFieldsHead
   LOCAL cFormat
   LOCAL bFooter, lAnalitSchet := .T.
   LOCAL nLin,  cValutaName := SPACE(20)
   LOCAL oGetNew, bakOrder
   LOCAL cReport
   LOCAL cKeyTree, nBottom

   LOCAL bFor_obor := {|| aIn[2] = 0 .OR. InGetTree(aIn[2],iMLABEL->NNOPER) },aGrup
   LOCAL aPoz, nTree := 1
   LOCAL nHandle,cFile:=TEMPFILE(_TMP_DIR,"ERR"), aPrintTop , aPrintBot
   LOCAL lError := .F., lLenError

   PRIVATE cVarName := "", lViborTree := .F.,bakOper

   PRIVATE GetList := {}, aIn[2]

   nHandle:=FCREATE(cFile)

   IF nHandle < 0
     RETURN NIL
   ENDIF

dbPush()
SELECT iNAME_TRE
dbPush()
SetScope()
ORDSETFOCUS("TAG_OPER")
SELECT iTREE
dbPush()
SetScope()
ORDSETFOCUS("TAG_TOP")
InClearTree()
SprDopTree('TREE_SPR',2,,'1','aIn[1]',"[ Иерахические справочники ]",{|| NIL },'MemVar->cVarName',{|| NIL })

BEGIN SEQUENCE


  IF VALTYPE(sIn) <> 'A'
    aIn[1] :=  0
    aIn[2] := 0
  ELSE
    AEVAL( sIn, {|x,i| aIn[i] :=x } )
  ENDIF


  SETCOLOR(COL_INPUT)
  FRAME("[ Печать номенклатурного справочника ]",nTop-1,nLeft+2,nTop+4,nLeft+56,COL_INPUT,1,.T.,.T.)
  @ nTop+1,  nLeft+6 SAY 'Иерархический справ.:'
  @ nTop+2,  nLeft+6 SAY 'Иерархический фильтр:'


  SETCOLOR(COL_GET)

  oGetNew := GetNew(nTop+1, nLeft+28,{|x| aIn[1] := IF(EMPTY(aIn[1]),GetInSpr({},aIn[2]),aIn[1]),IF(x != NIL .AND. EMPTY(x),aIn[1] := 0,NIL),iTREE->(dbSeek(aIn[1])),MemVar->cVarName := iTREE->NAME },'aIn[1]','@KS25')
  oGetNew:reader := {|oGet| ReferGetReader(oGet,"TREE_SPR") }
  oGetNew:preBlock := {|| bakOper := aIn[1],.T. }
  oGetNew:postBlock := {|| IF(bakOper != aIn[1] .OR. EMPTY(aIn[2]),aIn[2] := aIn[1],NIL),.T. }
  AADD(GetList,oGetNew:display())

  oGetNew := GetNew(nTop+2, nLeft+28,{|x| lViborTree := lViborTree.OR.(x = "Да "),IF(x = "Да ",__Keyboard(CHR(13)),NIL),IF(x = "Нет",aIn[2] := 0,NIL),IF(iTREE->(dbSeek(aIn[2])) .AND. aIn[2] != aIn[1],"Да ","Нет") },'aIn[2]','XXX')
  oGetNew:reader := {|oGet| CondReader( oGet,,) }
  oGetNew:preBlock := {|| lViborTree := .F.,!EMPTY(aIn[1]) }
  oGetNew:postBlock := {|oGet| IF( LastKey() = 13 .AND. ( oGet:buffer = "Да " .OR. lViborTree ),;
                                    aIn[2] := LabelGetTopSpr( aIn[2], .F., .F.,, aIn[1] ),;
                                    NIL ),;
                               .T. }
  AADD(GetList,oGetNew:display())

  SET CURSOR ON
  READ
  SET CURSOR OFF

  IF LASTKEY() == K_ESC
    BREAK
  ENDIF


  sIn := ACLONE(aIn)

  // 1 - текущее значение ключа группы
  // 2 - позиция вставки наименования
  // 5 - наименование текущего ключа записи

  #DEFINE GRUP_KEY axGrup[1]
  #DEFINE TEK_POZ  axGrup[2]
  #DEFINE TEK_KEY  EVAL(axGrup[3])
  #DEFINE NAME_KEY RestTreeName(.T.,TEK_KEY)
  #DEFINE N_LEN    45


  aGrup := {}
  iNAME_TRE->(dbSeek(STR(aIn[1],17,0)),;
             DBEVAL({||;
                     nTree++,;
                     AADD(aGrup,{;
                                  NIL,;
                                  (nTree-2)*5+1,;
                                  BlockStringToBlock("{|| TreeFullGetKey("+NTOC(nTree)+",DATA_TREE->KEY) }");
                                 });
                     },,{|| iNAME_TRE->NNOPER_TOP = aIn[1] }))

  IF EMPTY(aGrup)
    SayError(" Структура справочника не заполнена !")
    BREAK
  ENDIF
  aPoz := A_COL(aGrup,2)  // массив текущих позиций
  SELECT iMLABEL
  dbGoBottom()
  nBottom := RECNO()
  dbGoTop()
  PROCES TO nProces PROMPT "Обработка данных..." MAX nBottom-iMLABEL->(RecNo()) ROW 18 INDIK
  CreateMetka(,"DATA_TREE",{;
                           {"GRUP","C",5,0},;
                           {"NNUM","C",13,0},;
                           {"NAME","C",60,0},;
                           {"KEY","C",nTree*LenFullKey(),0};
                           },;
                          "UPPER(KEY+NAME+GRUP+NNUM)";
              )
  SELECT DATA_TREE
  ORDSETFOCUS("TAG_METKA")
  SELECT iMLABEL
  DBEVAL({||  DATA_TREE->(dbUnLock()) },{|| Proces_Update(nProces),EVAL(bFor_obor) .AND. DATA_TREE->(cKeyTree := TreeGetKey(nTree,iMLABEL->NNOPER,nTree),IF(dbSeek(cKeyTree+UPPER(iMLABEL->NAME+iMLABEL->GRUP+iMLABEL->NNUM)),RecLock(),!EMPTY(cKeyTree) .AND. AddRec() .AND. (DATA_TREE->NAME := iMLABEL->NAME,DATA_TREE->NNUM := iMLABEL->NNUM,DATA_TREE->GRUP := iMLABEL->GRUP,DATA_TREE->KEY := cKeyTree,.T.))) })
  PROCES END

  nLen := ATAIL(aPoz)+5+N_LEN

  PROCES TO nProces PROMPT "Формирование отчета..." MAX DATA_TREE->(LastRec()) ROW 18 INDIK
  FWRITE(nHandle,CHR(13)+CHR(10))
  FWRITE(nHandle,RTRIM(PADC(GetPrefixLabel()[4],nLen))+CHR(13)+CHR(10))
  FWRITE(nHandle,CHR(13)+CHR(10))
  FWRITE(nHandle,CHR(13)+CHR(10))
  FWRITE(nHandle,REPLICATE("▀",nLen)+CHR(13)+CHR(10))
  FWRITE(nHandle,CHR(13)+CHR(10))

  SELECT DATA_TREE
  SET RELATION TO UPPER(Grup+NNum) INTO iMLABEL ADDITIVE
  DBEVAL({||;
         Proces_Update(nProces),;
         aPrintBot := {},;
         aPrintTop := {},;
         AEVAL(aGrup,{|axGrup|;
                  IF(GRUP_KEY != TEK_KEY,;
                     (;
                     IF(GRUP_KEY != NIL,;
                        AADD(aPrintBot,{TreeLineStr(@aPoz,TEK_POZ,.F.,nLen)}),;
                        NIL;
                        ),;
                     AADD(aPrintTop,{TreeLineStr(@aPoz,TEK_POZ,.T.)+RTRIM(NAME_KEY)}),;
                     GRUP_KEY := TEK_KEY;
                     ),;
                     NIL;
                     );
                      }),;
         AEVAL(aPrintBot,{|x,n| AEVAL(aPrintBot[LEN(aPrintBot)-n+1],{|cStr| FWRITE(nHandle,RTRIM(cStr)+CHR(13)+CHR(10)) }) }),;
         AEVAL(aPrintTop,{|x| AEVAL(x,{|cStr| FWRITE(nHandle,RTRIM(cStr)+CHR(13)+CHR(10)) }) }),;
         FWRITE(nHandle,RTRIM(TreeLineStr(aPoz,nLen-N_LEN,.T.)+PADR(DATA_TREE->GRUP+" "+DATA_TREE->NNUM+" "+DATA_TREE->NAME,N_LEN))+CHR(13)+CHR(10));
         })
  aPrintBot := {}
  AEVAL(aGrup,{|axGrup|;
              IF(GRUP_KEY != NIL,;
                 AADD(aPrintBot,{TreeLineStr(@aPoz,TEK_POZ,.F.,nLen)}),;
                 NIL;
                 );
               })

  AEVAL(aPrintBot,{|x,n| AEVAL(aPrintBot[LEN(aPrintBot)-n+1],{|cStr| FWRITE(nHandle,RTRIM(cStr)+CHR(13)+CHR(10)) }) })
  FWRITE(nHandle,CHR(13)+CHR(10))
  FWRITE(nHandle,REPLICATE("▀",nLen)+CHR(13)+CHR(10))
  PROCES END

  DeleteMetka()

  FCLOSE(nHandle)
  View(cFile)


END SEQUENCE

dbPop()
dbPop()
dbPop()

RestSet(aSet)
RestSetKey(aSetKeys)
InClearTree(.T.)

RETURN NIL
//----------------------------------------------------------------------------//
FUNCTION TreeLineStr(aPoz,nPoz,lTop,nMaxLen)
//----------------------------------------------------------------------------//
// Возвращает скомпанованую строку - отчерк под итого и в нач. разделит.
LOCAL cLine := ""
IF lTop
  AEVAL(aPoz,{|x| IF(x <= nPoz,cLine := PADR(cLine,x-1)+"│","") })
ELSE
  AEVAL(aPoz,;
  {|x|;
    IF(x < nPoz,cLine := PADR(cLine,x-1)+"│",""),;
    IF(x = nPoz,cLine := PADR(cLine,x-1)+"└","");
   })
  cLine := PADR(cLine,nMaxLen,"─")
ENDIF
RETURN cLine
//--------------------------------------------------------------------------//
                   FUNCTION IsUhet(cGrup)
//--------------------------------------------------------------------------//
// Возвращает .T. если учет по учетным ценам
LOCAL lUhet, lPush := .F., cSchetFocus, cStruFocus, aStruScope, cStruFilter, nStruRec, nSchetRec

IF UPPER(iMSTRU->GRUP) != UPPER(cGrup) .OR. UPPER(iMSTRU->SCHET) != UPPER(iMSCHET->SCHET)
  lPush := .T.
  nSchetRec := iMSCHET->(Recno())
  cSchetFocus := iMSCHET->(ORDSETFOCUS("MSCHET"))
  nStruRec := iMSTRU->(Recno())
  cStruFocus := iMSTRU->(ORDSETFOCUS("TAG_GRUP"))
  aStruScope := iMSTRU->(GetScope())
  iMSTRU->(SetScope())
  cStruFilter := iMSTRU->(dbFilter())
  iMSTRU->(dbSeek(UPPER(cGrup)))
  iMSCHET->(dbSeek(UPPER(iMSTRU->SCHET)))
ENDIF
lUhet := iMSCHET->UCHET = "1"
IF lPush
  iMSCHET->(ORDSETFOCUS(cSchetFocus))
  iMSTRU->(ORDSETFOCUS(cStruFocus))
  IF !EMPTY(cStruFilter)
    iMSTRU->(dbSetFilter(&("{||"+cStruFilter+"}"),cStruFilter))
  ENDIF
  IF !EMPTY(aStruScope)
    iMSTRU->(SetScope(aStruScope))
  ENDIF
  iMSTRU->(dbGoTo(nStruRec))
  iMSCHET->(dbGoTo(nSchetRec))
ENDIF
RETURN lUhet
//--------------------------------------------------------------------------//
                    PROCEDURE SetRunLabel(lSet,lShFact)
//--------------------------------------------------------------------------//
// Выставление флагов для запроса цены при вводе нового номенклатурного спр.
LOCAL GlobalUchet
IF lSet
  GlobalUchet := .F.
  lRunLabel := .T.
  lRunShFact := ValType(lShFact) = "L" .AND. lShFact
  IF !(GetPrefix() == "T")
    iMSCHET->(DBEVAL({|| GlobalUchet:=.T. },{|| iMSCHET->Uchet='1' },{|| !GlobalUchet }))
    AADD(aGlobalUchet,{GetPrefix(),GlobalUchet})
  ENDIF
ELSE
  GlobalUchet := {}
  lRunLabel := .F.
        lRunShFact := .F.
ENDIF
RETURN
//--------------------------------------------------------------------------//
                    PROCEDURE SetKeyLabel(nSet,oGet,lSet,cGrup)
//--------------------------------------------------------------------------//
// Навеска (lSet - .T.) и снятие (lSet - .F.)  SetKey()
// по типу кода nSet :
// 1 -  марка
// 2 -  размер
// 3 -  профиль
// 4 -  сорт
// 5 -  номенклатурный номер
STATIC bKey_0 , bKey_1, bKey_2, bKey_3, bKey_4, cScr
LOCAL aHotKey := {{},{},{}}, cMess
IF (GetPrefix()=="S".OR.GetPrefix()=="Z".OR.GetPrefix()=="").AND.iTypeGen.AND.nSet=iNameGen1.AND.nApp!=S_LIB_FILTER
  IF lSet
    cScr := BrSaveScreen(24,0,24,MaxCol())
    cMess := ALLTRIM(CHARREPL(CHR(255)+" ╔═╗║╝═╚║┌─┐│┘─└│",CHARODD(SCREENSTR(24,0)),CHR(32)))+" Alt-1,2:Генерация кода"
    ScrTitul(24,cMess)
    HOT_ALT({|| IF(!EOF(),"0: Генерация контр. символа (EAN-13)",NIL) },0,NIL,1)
    HOT_ALT({|| IF(!EOF(),"1: Генерация штрих-кода (Весовой)",NIL) },0,NIL,2)
    HOT_ALT({|| IF(!EOF(),"2: Генерация штрих-кода (EAN-13)",NIL) },0,NIL,3)
    HOT_ALT({|| IF(!EOF(),"3: Генерация штрих-кода (EAN-8)",NIL) },0,NIL,4)
    HOT_ALT({|| IF(!EOF().AND.iSizeLCode>0 ,"4: Генерация локального кода ",NIL) },0,NIL,5)
    StackHotKey(.T.,aHotKey)
    bKey_0 := SetKey(K_ALT_0,{|| NotHotKey(),GenCodeLabel(oGet,nSet,,,,cGrup,.T.),ClearHotKey() })
    bKey_1 := SetKey(K_ALT_1,{|| NotHotKey(),GenCodeLabel(oGet,nSet,"Весовой",iStrGen2,.F.,cGrup),ClearHotKey() })
    bKey_2 := SetKey(K_ALT_2,{|| NotHotKey(),GenCodeLabel(oGet,nSet,"Штриховой",iStrGen1,.T.,cGrup),ClearHotKey() })
    bKey_3 := SetKey(K_ALT_3,{|| NotHotKey(),GenCodeLabel(oGet,nSet,"Штриховой",iStrGen1,.F.,cGrup,,.T.),ClearHotKey() })
    IF iSizeLCode>0
       bKey_4 := SetKey(K_ALT_4,{|| NotHotKey(),GenCodeLabel(oGet,nSet,"Локальный",'',.F.,cGrup,,.F.,.T.),ClearHotKey() })
    ENDIF
  ELSE
    BrRestScreen(cScr)
    cScr := NIL
    StackHotKey(.F.)
    SetKey(K_ALT_0,bKey_0)
    SetKey(K_ALT_1,bKey_1)
    SetKey(K_ALT_2,bKey_2)
    SetKey(K_ALT_3,bKey_3)
    SetKey(K_ALT_4,bKey_4)
    bKey_0 := NIL
    bKey_1 := NIL
    bKey_2 := NIL
    bKey_3 := NIL
  ENDIF
ENDIF
RETURN
//--------------------------------------------------------------------------//
   FUNCTION GenCodeLabel(oGet,nSet,cNameCode,cStrCode,lTypeCode,cGrup,;
                         lContrl,lEan8,lGenNom,lNoSave,lNoSay)
//--------------------------------------------------------------------------//
// Генерация соответствующего кода
// oGet - get объект (или сторка для неимеющих:) GetList и aIn)
// nSet - указание в каком поле генерируется код
//        1 -  марка
//        2 -  размер
//        3 -  профиль
//        4 -  сорт
//        5 -  номенклатурный номер
// cNameCode - наименование кода
// cStrCode  - первые два символа кода
// lTypeCode - тип генерациии .T. - полные 10 символов уникальны
//                            .F. - укороченный 5 символов уникальны
// cGrup - код группы
// lContrl - генерация контрольного символа
// lGenNom - генерация локального кода
// lNoSave - не писать в базу (возможны проблемы но так надо)
// lNoSay -  не ругаться в случае ошибки (не генерит и молчит)
LOCAL cCode := BLANK(IF(ValType(oGet)=="C",oGet,aIn[oGet:name[3]]),.T.)
LOCAL nCode := -1,nCode1 := -1
LOCAL nPoz := iMLABEL->(FieldPos({"MARKA","RAZMER","PROFIL","SORT","NNUM"}[nSet]))
LOCAL nTag := {"TAG_MARKA","TAG_RAZMER","TAG_PROFIL","TAG_SORT","TAG_NNUM"}[nSet]
LOCAL cKey, nLenPref


lGenNom=!EMPTY(lGenNom)
IF(VALTYPE(lContrl)=="L",,lContrl:=.F.)
IF(VALTYPE(lEan8)=="L",,lEan8:=.F.)
IF !EMPTY(lGenNom)
   lGenNom = .T.
   cStrCode = ALLTRIM(iStrGen3)
   lTypeCode =.F.
   lContrl = .F.
   lEan8 = .F.
ENDIF

IF iMLABEL->(RecLock())
  iMLABEL->(FieldPut(nPoz,cCode))
  iMLABEL->(dbUnLock())
ENDIF

nLenPref = IF(lGenNom,LEN(ALLTRIM(iStrGen3)),2)
IF EMPTY(nTag)
        dbPush(cSelLabel,{"MLABELM","MLABELR","MLABELP","MLABELS","MLABEL_S"}[nSet],"","","")
        // KEY : STATUS+GRUP
        cKey := UPPER(FIELD->STATUS+FIELD->GRUP+cStrCode)
        WHILE !EOF()
        dbSeek(UPPER(LEFT(cKey,LEN(cKey)-1)+CHR(ASC(RIGHT(cKey,1))+1)),.T.)
        IF cKey = UPPER(FIELD->STATUS+FIELD->GRUP)
        cKey := RIGHT(cKey,LEN(cKey)-LEN(cStrCode))
        cKey := UPPER(LEFT(cKey,LEN(cKey)-1)+CHR(ASC(RIGHT(cKey,1))+1))
        ELSE
        cKey := UPPER(FIELD->STATUS+FIELD->GRUP)
        ENDIF
        cKey += cStrCode
        dbSkip(-1)
   nCode := MAX(nCode,VAL(IF(lGenNom,SUBSTR(FieldGet(nPoz),nLenPref+1,iSizeLCode-nLenPref),IF(lTypeCode,SUBSTR(FieldGet(nPoz),3,10),SUBSTR(FieldGet(nPoz),3,5)))))
        dbSkip()
        ENDDO

   IF nCode >= IF(lGenNom,VAL(REPLICATE('9',iSizeLCode-nLenPref)),IF(lTypeCode,9999999999,99999))
     IF EMPTY(lNoSay)
        SayError({"Формирование кода ("+LOWER(ALLTRIM(cNameCode))+") невозможно !"," Достигнуто максимально возможное значение. "})
     ENDIF
        ELSE
    cCode := cStrCode+PADL(NTOC(nCode+1),IF(lGenNom,iSizeLCode-nLenPref,IF(lTypeCode,10,5)),"0")
    IF lTypeCode.OR.lEan8
                cCode += EndEan(cCode)
        ENDIF
        WHILE MSeek(ALIAS(),ORDNAME(),cCode,{|| UPPER(FIELD->STATUS+FIELD->GRUP) })
        nCode++
      IF nCode >= IF(lGenNom,VAL(REPLICATE('9',iSizeLCode-nLenPref)),IF(lTypeCode,9999999999,99999))
         IF EMPTY(lNoSay)
            SayError({"Формирование кода ("+LOWER(ALLTRIM(cNameCode))+") невозможно !"," Достигнуто максимально возможное значение. "})
         ENDIF
        EXIT
        ELSE
         cCode := cStrCode+PADL(NTOC(nCode+1),IF(lGenNom,iSizeLCode-nLenPref,IF(lTypeCode,10,5)),"0")
        IF lTypeCode.OR.lEan8
                cCode += EndEan(cCode)
        ENDIF
        ENDIF
        ENDDO
        ENDIF
        dbPop()
ELSE
  IF lContrl
    cCode:= ALLTRIM(IF(ValType(oGet)=="C", oGet, aIn[oGet:name[3]]))
    IF EMPTY(cCode).OR.LEN(cCode)>12.OR.!EMPTY(LEN(CHARREM("0123456789",cCode)))
      IF EMPTY(lNoSay)
       SayError("Формирование контрольного символа невозможно !")
      ENDIF
    ELSE
      cCode:=PADR(ALLTRIM(cCode),12,"0")
      nCode:=VAL(cCode)
      IF nCode >= 999999999999
        IF EMPTY(lNoSay)
           SayError({"Формирование контрольного символа невозможно !"," Достигнуто максимально возможное значение. "})
        ENDIF
      ELSE
        cCode+=EndEan(cCode)
      ENDIF
    ENDIF
  ELSE
    dbPush(cSelLabel,nTag,"",{"UPPER(STATUS"+"+LEFT("+{"MARKA","RAZMER","PROFIL","SORT","NNUM"}[nSet]+","+STR(IF(lGenNom,nLenPref,2))+"))","1"+UPPER(cStrCode)},"")
    dbGoBottom()
    nCode1:=VAL(IF(lGenNom,SUBSTR(FieldGet(nPoz),nLenPref+1,iSizeLCode-nLenPref),IF(lTypeCode,SUBSTR(FieldGet(nPoz),3,10),SUBSTR(FieldGet(nPoz),3,5))))
    dbPush(cSelLabel,nTag,"",{"UPPER(STATUS"+"+LEFT("+{"MARKA","RAZMER","PROFIL","SORT","NNUM"}[nSet]+","+STR(IF(lGenNom,nLenPref,2))+"))"," "+UPPER(cStrCode)},"")
    dbGoBottom()
    nCode:=VAL(IF(lGenNom,SUBSTR(FieldGet(nPoz),nLenPref+1,iSizeLCode-nLenPref),IF(lTypeCode,SUBSTR(FieldGet(nPoz),3,10),SUBSTR(FieldGet(nPoz),3,5))))
    nCode:=MAX(nCode,nCode1)
    dbPop()
    dbPop()
    IF nCode >= IF(lGenNom,VAL(REPLICATE('9',iSizeLCode-nLenPref)),IF(lTypeCode,9999999999,99999))
        IF EMPTY(lNoSay)
          SayError({"Формирование кода ("+LOWER(ALLTRIM(cNameCode))+") невозможно !"," Достигнуто максимально возможное значение. "})
        ENDIF
    ELSE
      cCode := cStrCode+PADL(NTOC(nCode+1),IF(lGenNom,iSizeLCode-nLenPref,IF(lTypeCode,10,5)),"0")
      IF lTypeCode.OR.lEan8
        cCode += EndEan(cCode)
      ENDIF
      dbPush(cSelLabel,nTag,"","","")
      WHILE dbSeek(UPPER(" "+cCode)) .OR. dbSeek(UPPER("1"+cCode))
        nCode++
        IF nCode >= IF(lGenNom,VAL(REPLICATE('9',iSizeLCode-nLenPref)),IF(lTypeCode,9999999999,99999))
          IF EMPTY(lNoSay)
             SayError({"Формирование кода ("+LOWER(ALLTRIM(cNameCode))+") невозможно !"," Достигнуто максимально возможное значение. "})
          ENDIF
          EXIT
        ELSE
          cCode := cStrCode+PADL(NTOC(nCode+1),IF(lGenNom,iSizeLCode-nLenPref,IF(lTypeCode,10,5)),"0")
          IF lTypeCode.OR.lEan8
            cCode += EndEan(cCode)
          ENDIF
        ENDIF
      ENDDO
      dbPop()
    ENDIF
  ENDIF
ENDIF

IF ValType(oGet)=="C"
   oGet:= PADR(cCode,LEN(oGet))
   cCode:= oGet
ELSE
   aIn[oGet:name[3]] := PADR(cCode,LEN(aIn[oGet:name[3]]))
ENDIF

IF EMPTY(lNoSave).AND.iMLABEL->(RecLock())
  iMLABEL->(FieldPut(nPoz,cCode))
  iMLABEL->(dbUnLock())
ENDIF

RETURN cCode
//--------------------------------------------------------------------------//
                    PROCEDURE AddKeyLabel(nSet,oGet,cGrup)
//--------------------------------------------------------------------------//
// Генерациия при добавлении записи по типу кода nSet :
// 1 -  марка
// 2 -  размер
// 3 -  профиль
// 4 -  сорт
// 5 -  номенклатурный номер
LOCAL cCase
IF (GetPrefix() == "S".OR.GetPrefix() == "Z".OR.GetPrefix() == "").AND.MemVar->nApp=S_LIB_ADD.AND.iTypeGen
  IF iNameGen1==nSet
    aIn[oGet:name[3]]:=BLANK(aIn[oGet:name[3]],.T.)
  ENDIF
ENDIF
RETURN
//--------------------------------------------------------------------------//
FUNCTION ValidCodeLabel(cCode,nSet)
//--------------------------------------------------------------------------//
        // Проверка при добавлении записи по типу кода nSet :
        // 1 -  марка
        // 2 -  размер
        // 3 -  профиль
        // 4 -  сорт
        // 5 -  номенклатурный номер
    LOCAL lRet:=.T.,nRec:=RECNO()
        LOCAL nTag:={"TAG_MARKA","TAG_RAZMER","TAG_PROFIL","TAG_SORT","TAG_NNUM"}[nSet]
        LOCAL cField:={"MARKA","RAZMER","PROFIL","SORT","NNUM"}[nSet]
    LOCAL nPoz := iMLABEL->(FieldPos({"MARKA","RAZMER","PROFIL","SORT","NNUM"}[nSet]))
    dbPush(,nTag,"RECNO() != "+STR(RECNO(),10,0),"","")
        IF EMPTY(cCode)
      lRet:=SayError("Поле со штрих-кодом должно быть заполненым !")
        ELSEIF dbSeek(UPPER(" "+cCode)).OR.dbSeek(UPPER("1"+cCode))
      lRet:=SayError("Такой штрих-код уже используется !")
    ELSEIF iMLABEL->(dbGoTo(nRec),RecLock())
      iMLABEL->(FieldPut(nPoz,cCode))
      iMLABEL->(dbUnLock())
        ENDIF
        dbPop()
RETURN lRet
//--------------------------------------------------------------------------//
                         STATIC FUNCTION IsCloseNumber(cGrup,cNNum,nRecClose)
//--------------------------------------------------------------------------//
// Проверяет наличие номенклатуры cGrup,cNNum
// Возвращает признак наличия и номер записи закрытой номенклатуры по ссылке
LOCAL lSeek := .F.
dbPush(cSelLabel,"MLABEL_S","",{"UPPER(STATUS+GRUP+NNUM)",UPPER("1"+cGrup+cNNum),,.F.,{"MLABEL_S"}},"")
lSeek := !EOF()
nRecClose := RECNO()
dbPop()
RETURN lSeek
//--------------------------------------------------------------------------//
                  STATIC FUNCTION OpenLabelNum(lSave,lUpdate)
//--------------------------------------------------------------------------//
// Открывает номенлкладтурный номер если его пытаются добавить
// Возвращает признак успешности открытия
LOCAL nRecClose, lNoDel := .T.

IF MemVar->nApp = S_LIB_ADD.AND.lSave.AND.iMLABEL->STATUS = ' '.AND.IsCloseNumber(iMLABEL->GRUP,iMLABEL->NNUM,@nRecClose)
  lNoDel := .F.
  xDELETE()
  IF YesOrNo({" Данный номенклатурный номер закрыт "," Открыть номенклатурный номер ?"})
    dbGoTo(nRecClose)
    IF(RecLock(),(iMLABEL->STATUS := ' ',dbUnLock()),NIL)
  ENDIF
ENDIF

RETURN lNoDel

******************
FUNCTION GetFieldBCode()
******************

RETURN {"MARKA","RAZMER","PROFIL","SORT","NNUM"}[iNameGen1]

******************
FUNCTION GetTagBCode(cGrup)
******************

RETURN IF(TYPE(itNameGen1)='N' .AND. iNameGen1>0,IF(EMPTY(cGrup).OR.EMPTY(&(cGrup)),{"TAG_MARKA","TAG_RAZMER","TAG_PROFIL","TAG_SORT","TAG_NNUM"}[iNameGen1],;
                       {"MLABELM","MLABELR","MLABELP","MLABELS","MLABEL_S"}[iNameGen1]),"MLABEL_S")
******************
FUNCTION SeekBCInKart(cBCode,lNoStatus,lNoSclad)
******************
LOCAL cRet:=CHR(10)
If lNoStatus = NIL
   lNoStatus = .F.
EndIF
If lNoSclad = NIL
   lNoSclad = .F.
EndIF
dbPush(cSelLABEL,GetTagBCode())
If dbSeek(UPPER(' '+cBCode))
   cRet = UPPER(IF(lNoStatus,'',' ')+IF(lNoSclad,'',pSclad)+iMLABEL->(Grup+NNum))
EndIF
dbPop()

RETURN cRet
//--------------------------------------------------------------------------//
                         FUNCTION LabelGetRec(cGrup,cNNum)
//--------------------------------------------------------------------------//
// Возвращает номер найденной записи
// ВНИМАНИЕ ! Смещает указатель !
STATIC nStRecGrup, nStRecNNum
IF cGrup = NIL
  PRIVATE nRec
  MemVar->nRec := IF(nStRecNNum != NIL,nStRecNNum,IF(nStRecGrup != NIL,nStRecGrup,(dbGoTop(),RECNO())))
  nStRecNNum := nStRecGrup := NIL
  RETURN MemVar->nRec
ENDIF
IF nStRecNNum = NIL .AND. UPPER(FIELD->GRUP) = UPPER(cGrup)
 IF(UPPER(FIELD->NNUM) = UPPER(cNNum),nStRecNNum := RECNO(),IF(nStRecGrup = NIL,nStRecGrup := RECNO(),NIL))
ENDIF
RETURN .T.

******************
FUNCTION ValidStrNNum(cGrup,lNoFact)
******************
LOCAL nRet := 0
If cGrup == NIL
   cGrup = iMLABEL->Grup
EndIF
If iTypeGen .AND. TYPE('pSclad') = 'C' .AND. !EMPTY(pSclad) .AND. !IsSxema(cGrup,pSclad,lNoFact)
   SayError( {'Не определена схема хранения (счет учета)',NA_SCLADE+' '+pSclad+' для группы '+cGrup})
   nRet = 1
EndIF
RETURN nRet

******************
FUNCTION UstTagBCode(cDest1,aSortSeek,lSclad,lAllSpr,lOnlyNNum,bAddSort,lOst,cPref,nOrdBC,pSBTag,pSBKey)
******************
LOCAL nPos
If lSclad == NIL
   If iTypeGen.AND.m->lYesBarCode .AND. (EMPTY(&(cDest1)) .Or. lAllSpr)
      AADD(aSortSeek,;
      {'- группам,номерам ТМЦ     ',;
      {'Группа?:     ','Ном. номер?: '},{'pLastGrup','NNum'},;
      'TRIM(UPPER(SPACE(1)+aIn[1]+aIn[2]))',{'@K','@K'},{,},{'MGrupLab',},"MLABEL_S"})
      AADD(aSortSeek,{'- группам,наименованиям   ',{'Группа?:    ','Наименование?:'},;
      {'pLastGrup','Space(10)'},;
      'TRIM(UPPER(SPACE(1)+aIn[1]+aIn[2]))',{'@K','@K'},{,},{'MGrupLab',},"MLAB_ST"})
   Else
      AADD(aSortSeek,;
      {'- номерам ТМЦ             ',;
      'Ном. номер?: ','NNum',;
      'TRIM(UPPER(SPACE(1)+pLastGrup+aIn[1]))','@K',,,"MLABEL_S"})
      cPref = 'SPACE(1)+UPPER(pLastGrup)'
      nOrdBC = GetTagBCode('pLastGrup')
      AADD(aSortSeek,{'- наименованиям           ','Наименование?:',;
      'Space(10)',;
      'TRIM(UPPER(SPACE(1)+pLastGrup+aIn[1]))','@K',,,"MLAB_ST"})
      pSBTag:='MLAB_ST'
      pSBKey:=UPPER(SPACE(1)+pLastGrup)
   EndIF
   IF lOst
      If iTypeGen.AND.m->lYesBarCode .AND. (EMPTY(&(cDest1)) .Or. lAllSpr)
         AADD(aSortSeek,;
         {'- группам,ценам остатков  ',;
         {'Группа?:      ','Цена '+IF(GetPrefix() == 'T','','остатка')+'?','Наименование?'},{'pLastGrup',IF(GetPrefix() == "T",'OCENA1','Cena'),'SPACE(15)'},;
         'TRIM(UPPER(SPACE(1)+aIn[1]+STR(aIn[2],15,2)+aIn[3]))',;
         {'@K','999999999999.99','@K XXXXXXXXXXXXXXX'},{,,},{'MGrupLab',,},"MLABELC"})
      Else
         AADD(aSortSeek,;
         {'- ценам остатков          ',;
         {'Цена '+IF(GetPrefix() == 'T','','остатка')+'?','Наименование?'},{IF(GetPrefix() == "T",'OCENA1','Cena'),'SPACE(15)'},;
         'TRIM(UPPER(SPACE(1)+pLastGrup+STR(aIn[1],15,2)+aIn[2]))',;
         {'999999999999.99','@K XXXXXXXXXXXXXXX'},{,},{,},"MLABELC"})
      EndIf
   ENDIF
   EVAL(bAddSort,"Marka","MLABELM",&(cDest1))
   EVAL(bAddSort,"Sort","MLABELS",&(cDest1))
   EVAL(bAddSort,"Profil","MLABELP",&(cDest1))
   EVAL(bAddSort,"Razmer","MLABELR",&(cDest1))
   If iTypeGen.AND.m->lYesBarCode .AND. (EMPTY(&(cDest1)) .Or. lAllSpr)
      aadd(aSortSeek,;
         {'- наименованиям           ','Наименование?:',;
          'Space(10)',;
          'TRIM(UPPER(SPACE(1)+aIn[1]))','@K',,,'MLABEL_T'})
      pSBTag:='MLABEL_T'
      pSBKey:=' '
      aadd(aSortSeek,;
        {'- штрих-кодам                   ',;
         'Штрих-код?: ',GetFieldBCode(),;
         'SPACE(1)+UPPER(aIn[1])','@K XXXXXXXXXXXXX',;
         NIL,,GetTagBCode()})
   EndIF
   If iTypeGen
      If (nPos:= ASCAN(aSortSeek,{|x|'штрих-кодам' $ x[1]})) > 0
         aSortSeek[nPos,8] = GetTagBCode(cDest1)
         aSortSeek[nPos,4] = IF(EMPTY(&(cDest1)),'SPACE(1)+UPPER(aIn[1])','SPACE(1)+UPPER(pLastGrup+aIn[1])')
         cPref = IF(EMPTY(&(cDest1)),'SPACE(1)','SPACE(1)+UPPER(pLastGrup)')
         nOrdBC = aSortSeek[nPos,8]
      EndIF
      If !lAllSpr .AND. !lOnlyNNum .AND. !Empty(&(cDest1))
        SetScope('UPPER(Status)',SPACE(1))
        SetScope('UPPER(Status+Grup)',SPACE(1)+UPPER(&(cDest1)),,{'MLABEL_S','MLAB_ST','MLABELM','MLABELS','MLABELP','MLABELR','MLABELC'},.T.)
      Else
        SetScope('UPPER(Status)',SPACE(1))
      EndIF
   ELSE
      SetScope('UPPER(Status+Grup)',SPACE(1)+UPPER(m->pLastGrup))
   EndIF
Else
   If iLabelNum = 4 .AND.m->lYesBarCode
      If (nPos:= ASCAN(aSortSeek,{|x|'штрих-кодам' $ x[1]})) > 0
         aSortSeek[nPos,8] := IF(EMPTY(&(cDest1)),'MKART_BC',"MKART_SN")
         aSortSeek[nPos,4] = IF(EMPTY(&(cDest1)),'UPPER(SPACE(1)+pSclad+aIn[1])','UPPER(SPACE(1)+pSclad+pLastGrup+aIn[1])')
         cPref = IF(EMPTY(&(cDest1)),'SPACE(1)+UPPER(pSclad)','SPACE(1)+UPPER(pSclad+pLastGrup)')
         nOrdBC = aSortSeek[nPos,8]
      EndIF
   EndIf
   If !lAllSpr .AND. !lOnlyNNum .AND. !Empty(&(cDest1))
         SetScope('UPPER(Status+Sclad)',SPACE(1)+UPPER(pSclad))
         SetScope('UPPER(Status+Sclad+Grup)',SPACE(1)+UPPER(pSclad+&(cDest1)),,{'MKART_SN','MKART_ST'},.T.)
   ELSE
         SetScope('UPPER(Status+Sclad)',SPACE(1)+UPPER(pSclad))
   EndIF
EndIF
RETURN .T.

******************
FUNCTION VozvrGrup()
******************
IF (cSelGrup)->Code # (cSelLabel)->Grup
   (cSelGrup)->(dbSeek(UPPER((cSelLabel)->Grup)))
Endif
RETURN FinGet(cSelGrup,'CODE',.T.)

//---------------------------------------------------------------------------
FUNCTION ProtokLabel(nMode)
//---------------------------------------------------------------------------
// Запись в протокол изменений справочника номенклатур
LOCAL cFileDb:= LoadPath()+"TMP\MLabel_.dbf", cAlias:= ALIAS()
IF FILE(LoadPath()+"Eldorado.txt")
   IF SELECT("MLabel_") = 0
   IF !FILE(cFileDb)
      dbCreate(cFileDb,{{"OPER","C",4,0},{"GRUP_","C",5,0},{"NNUM_","C",13,0},;
                        {"NAME_","C",60,0},{"GRUP","C",5,0},{"NNUM","C",13,0},;
                        {"NAME","C",60,0},{"ID_STATION","C",25,0},;
                        {"RECNO","C",17,0},{"DATE","C",8,0},{"TIME","C",8,0}})
   ENDIF
   NetUse("MLabel_",cFileDb)
   ENDIF
   SELECT MLabel_
   AddRec()
   IF nMode!=-2 //Если не удаление
      REPLACE OPER WITH IF(nMode==S_LIB_ADD,"Add ","Edit"), GRUP_ WITH m->aLastIn[1],;
              NNUM_ WITH m->aLastIn[2], NAME_ WITH m->aLastIn[3],;
              GRUP WITH m->aIn[1], NNUM WITH m->aIn[2], NAME WITH m->aIn[3]
   ELSE
      REPLACE OPER WITH "Del ", GRUP_ WITH iMLABEL->GRUP, NNUM_ WITH iMLABEL->NNUM,;
              NAME_ WITH iMLABEL->NAME, GRUP WITH iMLABEL->GRUP,;
              NNUM WITH iMLABEL->NNUM, NAME WITH iMLABEL->NAME
   ENDIF
   REPLACE ID_STATION WITH IDENT_USER, RECNO WITH STR(iMLABEL->(RecNo()),17,0),;
           DATE WITH DTOC(Date()), TIME WITH  TIME()
   DbUnLock()
ENDIF
DbSelectArea(cAlias)
RETURN .T.

******************
FUNCTION NumEdName(cEd)
******************
//Возвращает номер единицы измерения в текущей записи MLABEL по коду е.и.
// ' ' - основная
// '1' - '3' - номер
// NIL - не найдена
IF UPPER(cEd) = UPPER(MLabel->Ed)
   RETURN ' '
ELSEIF UPPER(cEd) = UPPER(MLabel->Ed1)
   RETURN '1'
ELSEIF UPPER(cEd) = UPPER(MLabel->Ed2)
   RETURN '2'
ELSEIF UPPER(cEd) = UPPER(MLabel->Ed3)
   RETURN '3'
ENDIF
RETURN NIL

******************
FUNCTION KoefEdNum(cNum)
******************
// Возращает коэффициент пересчета из е.и. с номером cNum в основную,
// используя текущую запись MLabel
PRIVATE R, Q:=1
IF EMPTY(cNum) .OR. cNum<'1' .OR. cNum > '3'
   RETURN 1
ELSE
   m->R := MLabel->(FIELDGET(FIELDPOS('R'+cNum)))
ENDIF
RETURN Algo(MLabel->(FIELDGET(FIELDPOS('Algo'+cNum))))

#ifdef _ANALIZ
//--------------------------------------------------------------------------//
FUNCTION Algo(cAlgoritm,cRetType)
//--------------------------------------------------------------------------//
LOCAL nSum:= IF(cRetType = NIL,0,""), cType
IF !EMPTY(cAlgoritm).AND.((cType := TYPE(cAlgoritm))=IF(cRetType = NIL,"N",cRetType).OR.cType = "UI")
  nSum:=&cAlgoritm
  IF ValType(nSum) != IF(cRetType = NIL,"N",cRetType)
    nSum := IF(cRetType = NIL,0,"")
    SayError({" Ошибка в формуле ",cAlgoritm})
  ENDIF
ENDIF
RETURN (nSum)
#endif

******************
FUNCTION UdalNNum()
******************
LOCAL aBase := ;
 {;
   {GetPrefix()+"MDOCM",GetPrefixPath()+"MDOCM"},;
   {"MKart",GetPrefixPath()+"MKart"},;
   {"SSH_OP",LoadPath()+"REAL\SH_OP.DBF"},;
   {"SSH_FACT",LoadPath()+"REAL\SH_FACT.DBF"},;
   {"SH_FACT",LoadPath()+"TOVAR\SH_FACT.DBF"},;
   {"SH_OP",LoadPath()+"TOVAR\SH_OP.DBF"};
 }
LOCAL nRec, lFirst:=.T., cTemp
dbPush()
dbGOTOP()
dbOpenBases(aBase)
iMKART->(ORDSETFOCUS('MKART'))
SH_OP->(ORDSETFOCUS('TAG_TYPEN'))
SSH_OP->(ORDSETFOCUS('TAG_TYPEN'))
dbPush(iSPR_PART,'Tag_Code')
cTemp:=TEMPFILE(PATH_TMP,'IDX')
SELECT iMDOCM
IF FILE(cTemp)
   ERASE (cTemp)
ENDIF
INDEX ON UPPER(Grup+NNum) TAG MyIndex TO (cTemp)

BEGIN SEQUENCE

SELECT MLABEL

DO WHILE !EOF()
   SKIP
   nRec:=RECNO()
   SKIP -1
   IF !IsSeekNom(GetPrefix(),MLABEL->GRUP,MLABEL->NNUM,'',,'базы не окрывать').AND. ;
      !MKART->(dbSEEK(UPPER(MLABEL->GRUP+MLABEL->NNUM))).AND. ;
      !iSPR_PART->(dbSEEK(UPPER(MLABEL->GRUP+MLABEL->NNUM))).AND. ;
      !iMDOCM->(dbSEEK(UPPER(MLABEL->GRUP+MLABEL->NNUM))).AND. ;
      RecLock()
      IF lFirst .AND. YESORNO({'Перед удалением номенклатуры необходимо убедиться в том,',;
                               ' что закрытая номенклатура не задействована ',;
                               'в открытых инвентаризациях, в переоценке',;
                               ' и в прайс-листе торгового зала'},,'Прервать','Продолжить')
         BREAK
      ENDIF
      lFirst:=.F.
      dbDELETE()
      dbUNLOCK()
   ENDIF
   DBGOTO(nRec)
ENDDO
END SEQUENCE
iMDOCM->(DBCLEARINDEX())
dbCloseBases(aBase)
IF FILE(cTemp)
   ERASE (cTemp)
ENDIF
dbPop()
dbPop()

RETURN  2

******************
FUNCTION PutWrkCl(xMetka)    // victor спецодежда   вся функция
******************
LOCAL  nRec := RECNO(), nKol :=0
LOCAL nRecX
   (xMetka)->(dbGOTOP())
   IF (xMetka)->(EOF())
      (xMetka)->(ADDRec())
      (xMetka)->cRec := STR(RecNo(),17,0)
   ENDIF
   DO WHILE  !(xMetka)->(EOF())
      (xMetka)->(dbSkip())
      nRecX:=(xMetka)->(RecNo())
      (xMetka)->(dbSkip(-1))
      dbGOTO(VAL((xMetka)->cRec))
      IF RecLock()
         IF FIELDPOS('Wrk_Cl')>0
            REPLACE Wrk_Cl WITH '1'
         ENDIF
         dbUnLock()
         nKol++
         IF (xMetka)->(RECLock())
            (xMetka)->(dbDELETE())
            (xMetka)->(dbUnLock())
         ENDIF
      ENDIF
      (xMetka)->(dbGoTO(nRecX))
   ENDDO
dbGOTO(nRec)
   SayAndWait({"Отмечено "+AllTrim(Str(nKol))+" записей."},8)

RETURN 2
