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

#define _DEFAULT_PAROL '~`~`~`~`~`'


#INCLUDE "sc_all.ch"
#INCLUDE "sclad.ch"
#INCLUDE "task.ch"
#INCLUDE "inkey.ch"

STATIC DbStatus := {}

/*************************************************************/
/* Формирование справочника                                  */
/*************************************************************/

// Количество разделителей в шаблоне сумм
FUNCTION SummaZap( nDec, nLen )
RETURN( INT( (nLen-IF( nDec>0, 4, 3) )/3 ) )

// Формирование шаблона для вывода сумм
FUNCTION SummaPic( nDec, nLen, lRazd )
  LOCAL cFormat := '', nZ
  IF( ValType(nLen)<>'N',nLen:=13, )
  IF( ValType(lRazd)<>'L',lRazd:=.F., )
  IF( nDec>0, nDec+=1, )
  IF lRazd
    FOR nZ = 1 TO INT((nLen-nDec)/3+0.9)
      cFormat = ',999'+cFormat
    NEXT
    cFormat = PADL(REMLEFT(RIGHT(cFormat,nLen-nDec),","),nLen-nDec,"9")
  ENDIF
RETURN (  PADL( cFormat+PADR( '.',nDec  ,'9' ), nLen, '9' ) )





PROCEDURE SetPublic(cTask)
PUBLIC INST_COLOR := ISCOLOR(), ; // Цветной монитор
       INST_PAROL := "",        ; // Пароль Администратора
       INST_CFG   := "",        ; // Конфигурация поставки
       INST_DATE,               ; //
       GlobalDemo,              ; //
       lIsGlobValuta := .T.,    ; // валютный вариант
       GlobalValuta  := "РУБ"     // Основная валюта

PUBLIC lNewFirm := .F.

PUBLIC GlobalTask:= IF(ValType(cTask)=='C',cTask,'00'),;         // Номер задачи
       aPublicColors,;
       GlobalTmpPath := ''       // Путь к директории временных файлов

PUBLIC HelpFile:='', Help_Code:='00'

PUBLIC CURR_DATA :=DATE()     , ; //
       CURR_A_BEG:=BOM(DATE()), ; // Начало активного периода
       CURR_A_END:=EOY(DATE()), ; // Конец активного периода
       CURR_BEG  :=BOY(DATE()), ; // начало расчетного периода
       CURR_END  :=DATE(),      ; //
       CURR_BREAK:= .F.  ,      ; // Признак аварийного завершения
       CURR_MAIN :=  0   ,      ; // Значность основной валюты
       CURR_PROJE   :=  .F.,    ; // Номер проекта вводится?
       CURR_CURS    :=  .T.,    ; // Курс по ЦБ ?
       CURR_BCURS   :=  'Curs*Multy', ; // Расчет курса
       CURR_KARB    :=  1,      ; // Множитель для глобальной валюты
       CURR_ZAP     :=  .T.,    ; // Выводить суммы с разделителем
       CURR_PROF    := DATE(),;     // Дата последней пеpеиндексации в сети
       CURR_MDATA   := CTOD("  /  /  "),;  // Максимально возможная дата
       CURR_LDATA   := CTOD("  /  /  "),;  // Минимально возможная дата
       CURR_DTIME   := .F.,;              // Возможность вывода системной даты и времени при печати
       CURR_FTIME   := PADR("  Дата : Время : ",50),;  // Формат вывода системной даты и времени при печати
       Global_BCURS   :=  {|Curs,Multy| Curs*Multy}, ; // Расчет курса
       Global_BVSUMMA :=  {|Curs,Multy,Sum| ROUND(Curs*Multy*Sum,CURR_MAIN)},; // расчет валюты
       Global_Analit  := { 0, .F., ' ' },;
       WAIT_OPEN := 0,;   // Изменение 3.60
       Global_Set     := _GLOB_SET_DEF  // ГЛОБАЛЬНЫЕ НАСТРОЙКИ

PUBLIC PRN0_TYPE   :='1',;
       PRN0_WIDTH  :=80,;
       PRN0_WTYPE  :='1',;
       PRN0_PAPER  :=.T.,;
       PRN0_STR    := 58,;
       PRN0_PROBROS:=.F.,;
       PRN0_PAUSE  :=.T.,;
       PRN0_DEVICE := "LPT1",;
       PRN0_PSEVDO := .T.,;
       PRN0_E_YES  := .F.,;
       PRN0_E_PATH := '',;
       PRN0_E_FILE := '',;
       PRN0_FONT   := '',;
       PRN0_HEAD := '0',;
       PRN0_NUMSTR := .F.,;
       PRN0_BEGSTR := 1,;
       PRN0_LCODE := .F.,;
       PRN0_BCODE := "",;
       PRN0_ECODE := "",;
       PRN0_LSUM := .F.,;
       PRN0_TNAME := SPACE(50),;   // Изменение 3.30
       PRN0_PTYPE := 0,;   // Изменение 3.60
       PRN0_TDEVICE := "COM1",;
       PRN0_TVIEW := .F.,;
       PRN0_TNAST := .T.,;
       PRN0_TFILE := PADR("TERMO.STR",70),;
       PRN0_TERROR := .T.,;
       PRN0_TCOPY  := 1,;
       PRN0_TCODE  := {"      ","      "},;
       PRN0_TSHAB  := .F.,;
       PRN0_TWIN   := .F.,;
       PRN0_WIN    := .F.,;
       PRN0_ORINT  := '0',;   // Ориентация бумаги
       PRN0_OTSTUP := 0,  ;     // Отступ сверху
       PRN0_BEST_PRINT := ''  // Путь к БЭСТ принт серверу
Public PRN0_WIN_PRINT  := if('SCLADR'$ExeName().or.'ZAPASR'$ExeName(),1,0) // V@
Public PRN0_WPRINTER   := Space(254)


PUBLIC ;
       LBL_INDEKS:= '', ;
       LBL_NAME  := '', ;
       LBL_BOSS  := '', ;
       LBL_BOSS2 := '', ;
       LBL_SHEF  := '', ;
       LBL_SHEF2 := '', ;
       LBL_ADRES := '', ;
       LBL_TEL   := '', ;
       LBL_FAX   := '', ;
       LBL_POZ   := 1 , ;
       LBL_CODE  := '', ;
       LBL_OKPO  := ''



RETURN






//
/*************************************************************/
/* Формирование справочника                                  */
/*************************************************************/
PROCEDURE MakeValutaRefer( cRefer, cDest, nTypeRefer )
LOCAL aAccuracy := {{0,"До целых   "},{1,"До десятых "},{2,"До сотых   "},{3,"До тысячных"}}
  cRefer     := IF( ValType(cRefer)=="C",     cRefer,    "RefV" )
  nTypeRefer := IF( ValType(nTypeRefer)=="N", nTypeRefer, 1     )

  MakeRefer( cRefer, 'Справочник валют', nTypeRefer, ;
             {'Код','Наименование'}, {3,35,15},      ;
             COL_REFER, {'CODE'}, {cDest}, 'UPPER('+cDest+')', ;
             {FIELDBLOCK('CODE'),FIELDBLOCK('NAME')},             ;
            {{'','Код валюты?','CODE','TRIM(UPPER(aIn[1]))',Global_Set[1]+'XXX','!EMPTY(aIn[1])'}})
RETURN


//
/*************************************************************/
/* Формирование справочника                                  */
/*************************************************************/
PROCEDURE MakeSchetRefer(cRefer,cDest,nTypeRefer,bPreDisp, bPostDisp,cHelp,cHead,bColor,;
                         cValutDest )
  //nTypeRefer=1-обязательный ввод счетов и аналитики при ее наличии
  //nTypeRefer=2-необязательный ввод счетов и аналитики при ее наличии

  LOCAL aDest := {cDest},;
        aSourse := { "Schet" }

  cRefer     := IF( ValType(cRefer)=="C",     cRefer,    "Plan" )
  nTypeRefer := IF( ValType(nTypeRefer)=="N", nTypeRefer, 1     )
  bPreDisp   := IF( ValType(bPreDisp)=="B",   bPreDisp,   NIL   )
  bPostDisp  := IF( ValType(bPostDisp)=="B",  bPostDisp,  NIL   )
  cHead:=IF(cHead=NIL,"План счетов",cHead)

  IF VALTYPE(cValutDest) == 'C'
    AADD( aDest, cValutDest )
    AADD( aSourse, "(Valuta=='1')")
  ENDIF


  MakeRefer( cRefer, cHead, nTypeRefer,     ;
            { "Счет", "Наименование" }, {4,23,12},  ;
            COL_REFER, aSourse, aDest, 'UPPER('+cDest+')', ;
            {{||FIELD->Schet}, {||LEFT(FIELD->Name_Sch,35)}},;
            {{"","Номер счета?:","Schet","TRIM(UPPER(aIn[1]))",Global_Set[1]+'XXXX','!EMPTY(aIn[1])'}},,,,,,;
            bPreDisp, bPostDisp,,,,cHelp,,,,,'cFind$UPPER(NAME_SCH)')
RETURN


/*************************************************************/
/* Формирование справочника                                  */
/*************************************************************/
//   Общие параметры
// cVarCode   -   имя переменной куда поместить результат
// cRefer     -   Имя справочника ( "RefA" по умолчанию )
// nTypeRefer -   тип рефера      ( 1      по умолчанию )
//
FUNCTION SAnalit( cRefer, cVarCode, nTypeRefer,cHelp,NoInput, cKeyValDisp )
  LOCAL   cKeyaHeads, aYXN, cColor, aSource,   ;
        aDest, cKeyVal, abFields, aSortSeek, aInputHeads, aPict,       ;
        aWhen, aValid, bPost, bPreDisp, bPostDisp, bColor,;
        aRef, bCoProc, nRowHelp, nColHelp, aGetBlock, cFindMacro,cHead,;
        bMacro1,bMacro2

  LOCAL lSclad:=GlobalTask$'030905'


  cRefer     := IF( ValType(cRefer)=="C", cRefer,  "RefA"   )
  cHead      := "Аналит. учет по счету " // Название справочника
  nTypeRefer := IF( ValType(nTypeRefer)<>"N", 1, nTypeRefer)            /* Тип справочника          */
  cKeyaHeads := {"Код","Наименование"}/* Наименования столбцов    */
  aYXN := { 3, 35, 10 }           /* Координаты               */
  cColor := COL_REFER             /*                          */
  aSource := { 'CODE' }          /*                          */
  aDest   := { cVarCode }      /*                          */
  cKeyVal := "UPPER(SaveLoadType()+"+cVarCode+")" /*           */
  IF EMPTY(cKeyValDisp)
    cKeyValDisp:= "SaveLoadType()"
  ENDIF
  abFields := { {|| FIELD->CODE },;
                {|| FIELD->NAME } }/*                         */
  aSortSeek := {;
                { "- по кодам         ", "Код аналитики.:",         ;
                                  "CODE",                        ;
                                  "UPPER(SaveLoadType()+RTRIM(aIn[1]))",      ;
                                  Global_Set[1]+REPLICATE('X',6) , "((aIn[1]:=Global_Analit(aIn[1]))!=NIL).AND.!EMPTY(aIn[1])", ,1     ;
               },;
                { "- по наименованию  ", "Наименование.:",;
                                         "NAME",                               ;
                                         "UPPER(SaveLoadType()+RTRIM(aIn[1]))",      ;
                                         Global_Set[1]+REPLICATE('X',10), "!EMPTY(aIn[1])", ,2            ;
                  } ;
                 }                  /* Сортировка и Поиск       */
    // Краткое наменование
    IF Global_Analit[2]
      AADD( cKeyaHeads, 'Краткое имя' )
      AADD( abFields, {||FIELD->KEY} )
      aYXN := { 3, 25, 10 }           /* Координаты               */
      AADD( aSortSeek, { "- по краткому имени", "Краткое имя.:",;
                                         "KEY",                               ;
                                         "UPPER(SaveLoadType()+RTRIM(aIn[1]))",      ;
                                         IF(EMPTY(Global_Set[1]),"@!",Global_Set[1]+'!')+REPLICATE('X',15),;
                                          "!EMPTY(aIn[1])", ,3            ;
                       })
    ENDIF

  bPreDisp  := {||SetScope( "UPPER(Schet)", SaveLoadType() ) }
//  aRef := { 'Spraw' }
  bPostDisp := {|| SetScope(),IF(lSclad,SETKEY(K_ESC,NIL),NIL)}      /*                       */


  cFindMacro := 'cFind$UPPER(NAME)'

    MakeRefer( cRefer, {||cHead+TRIM(SaveLoadType())+' '}, nTypeRefer,;
               cKeyaHeads, aYXN, cColor, aSource,;
               aDest, cKeyVal, abFields, aSortSeek, aInputHeads, aPict,    ;
               aWhen, aValid, bPost, bPreDisp, bPostDisp, bColor, ;
               cKeyValDisp,aRef,cHelp, bCoProc, nRowHelp, nColHelp, ;
               aGetBlock, cFindMacro)

RETURN( .T. )

FUNCTION SaveLoadType( cSchet ) // Сохраним номер типа для потомков
  STATIC cStaticSchet := "    "
   IF ValType( cSchet ) == "C"
     cStaticSchet := UPPER(cSchet)
   ENDIF
RETURN( cStaticSchet )


FUNCTION MyRun(cSysName,cGlobalTask,cPath)
LOCAL cScreenMain:=SAVESCREEN(),lNew:=.T.,nNum
LOCAL aLegal:={2,.T.,777,1}
MEMVAR lNewFirm

PUBLIC lDemoKassa:=!(aLegal[1]=1.OR.aLegal[1]=2)
PUBLIC lArmKassa:=aLegal[2]
GlobalTask := cGlobalTask
PUBLIC help_code:='0'
PUBLIC PATH_DB := IF( ValType(cPath)=="C", cPath, "DBASE\")
PUBLIC PATH_DBA,PATH_TMP
LoadPath( PATH_DB )
SETBLINK(.F.)
PUBLIC frmFile,frmFile1

PUBLIC aIn0:={},aPos0:={}
PUBLIC yesGood := ( GlobalTask$'03SR' .OR. GlobalTask == "SZ" )
PUBLIC yesMatReal:=GlobalTask=='05'
PUBLIC aSclad,aMol,aFilial,aMoves,aVid,aMovesL
PUBLIC pVid:='1',pType:='1'
PUBLIC pSclad,pScladName,pNameMol,pCodeDoc,pNumDoc,pCodeDoc1,pNumDoc1
PUBLIC yesReal:=.F. //наличие реализации
PUBLIC GlobalName
PUBLIC RKolCen_:=0,LabelNum_:=1,Koef1_:={'',.F.}
PUBLIC pLastNum,pNextNum,pLastNum1,pNextNum1,pLastGrup:=SPACE(5)
PUBLIC DEF_MFACT,__DEF_ALL_PRIVATE
PUBLIC lYesBarCode
PUBLIC aImExLegal

// Текущие алиасы доступа с базам данных
PUBLIC iSelect
// Установка алиасов
SetPrefix()


MemVar->lYesBarCode := .T.
MemVar->aImExLegal := {2,.T.,777,1}


SET DELETED ON
lNewFirm := .T.

WHILE .T.
    
  RKolCen_:=0
  LabelNum_:=1
  Koef1_:={'',.F.}
  pLastGrup:=SPACE(5)
  pVid:='1'
  pType:='1'
  IF !IsBestIni(cSysName,{||PathToUser()},{||Open0(.T.)})
     RESTSCREEN(,,,,cScreenMain)
     CLOSE ALL
     RETURN (NIL)
  ENDIF
  AddMoves()
  RestPar('Main')
  SETBLINK(.F.)
  READEXIT(.F.)
  SET CONFIRM ON
  SET FIXED ON
  SET DECIMALS TO 5
  
  DispPeriod()
  SETKEY (K_F1, {||My_Help("HELP"+GlobalTask)})
  
  PATH_TMP:=m->GlobalTmpPath

//  lNewFirm := .F.
  
  QMenu('0')
  IF !lNewFirm
     EXIT
  ENDIF


  CURR_BREAK := !CURR_BREAK
  SaveStatus()
  RESTSCREEN(,,,,cScreenMain)
  CLOSE ALL
  

ENDDO

RETURN (NIL)

FUNCTION ValidSDate(dDate,lFirst,NoFin)
lFirst:=IF(lFirst==NIL,.F.,.T.)
IF LASTKEY()==K_RETURN.OR.LASTKEY()==K_DOWN
   IF !lFirst.AND.dDate<SCL_BEG
      SayError('Дата меньше начала расчетного периода склада!')
      dDate:=SCL_BEG
      RETURN(.F.)
   ENDIF
   IF dDate<CURR_BEG.AND.NoFin==NIL
      SayError('Дата меньше начала финансового расчетного периода!')
      dDate:=CURR_BEG
      RETURN(.F.)
   ENDIF
ENDIF
RETURN .T.

FUNCTION Valid1Date(dDate)
IF LASTKEY()==K_RETURN.OR.LASTKEY()==K_DOWN
   IF dDate>SCL_BEG
      SayError('Дата начального остатка больше'+CHR(13)+CHR(10)+'начала расчетного периода склада!')
      dDate:=SCL_BEG
      RETURN(.F.)
   ENDIF
ENDIF
RETURN .T.

FUNCTION DispPeriod()
@ 0,26 SAY '▒ Начало расчетного периода: '+DTOC(SCL_BEG)+' ▒' COLOR "w/n"
RETURN NIL

//Построение справочников
FUNCTION MakeDocRefer(cRefer,cDest,nType)
// Должны быть заданы PRIVATE-переменные pVid,pType!
//Подразумевается cDest='pCodeDoc'
nType:=IF(nType==NIL,1,nType)
IF (cDest==NIL)
   cDest:="pCodeDoc"
ENDIF   
MakeRefer(cRefer,"Виды документов",nType,{"Код","Наименование"},{4,43,12},;
COL_REFER,{"Code"},{cDest},"UPPER(pVid+pType+"+cDest+")",{{||Code},{||Name}})
RETURN (NIL)

FUNCTION MakeScladRefer(cRefer,cDest,nTypeRefer)
LOCAL aYXN:={3,42,12}
LOCAL aHeads:={'Код','Наименование'}
MakeRefer(cRefer,'Склады',nTypeRefer,aHeads,aYXN,;
COL_REFER,{"Code"},{cDest},"UPPER("+cDest+")",{{||Code},{||ShortName}})
RETURN (NIL)

FUNCTION MakePeopleRefer(cRefer,cDest,nTypeRefer,cDest2)
LOCAL aHeads:={'Таб.N','Фамилия','Имя','Отчество'}
LOCAL aYXN:={4,5,12}
LOCAL aSortSeek:={;
   {'- по табельным номерам ',;
    'Табельный номер?','CODE','UPPER(TRIM(aIn[1]))','@K XXXXXX','ToRight(1)'},;
   {'- по фамилиям          ',;
    'Фамилия?:','SHORTNAME','UPPER(TRIM(aIn[1]))','@K XXXXXXXXXXXXXXXXXX'},;
   {'- по подразделениям    ',;
    'Код подразделения?:','KODSTRU','UPPER(TRIM(aIn[1]))','XXXXXX','ToRight(1)'}}
LOCAL fiblocks:={{||Code},{||ShortName},{||FIELD->Name1},{||FIELD->Name2}}
IF cDest2!=NIL
   MakeRefer(cRefer,'Сотрудники',nTypeRefer,aHeads,aYXN,;
   COL_REFER,{"Code",;
   "PADR(TRIM(ShortName)+' '+LEFT(FIELD->Name1,1)+IF(!EMPTY(FIELD->Name1),'.','')+"+;
   "LEFT(FIELD->Name2,1)+IF(!EMPTY(FIELD->Name2),'.',''),25)";
   },{cDest,cDest2},"UPPER("+cDest+")",fiblocks,aSortSeek,,,,,,,;
   ,,,,"F2:Справочник сотрудников")
ELSE
   MakeRefer(cRefer,'Сотрудники',nTypeRefer,aHeads,aYXN,;
   COL_REFER,{"Code"},{cDest},"UPPER("+cDest+")",fiblocks,aSortSeek,,,,,,,;
   ,,,,"F2:Справочник сотрудников")
ENDIF
RETURN (NIL)

FUNCTION GetPict(nLen,nDec)
RETURN REPLICATE('9',nLen-1-nDec)+IF(nDec>0,'.'+REPLICATE('9',nDec),'9')

FUNCTION IniEd()
LOCAL nArea:=SELECT()
LOCAL aEd:={}
SELECT MLabel
IF !EMPTY(Ed)
   AADD(aEd,{Ed,Ed,' ',0})
ENDIF
IF !EMPTY(Ed1)
   AADD(aEd,{Ed1,Ed1,Algo1,R1})
ENDIF
IF !EMPTY(Ed2)
   AADD(aEd,{Ed2,Ed2,Algo2,R2})
ENDIF
IF !EMPTY(Ed3)
   AADD(aEd,{Ed3,Ed3,Algo3,R3})
ENDIF
IF LEN(aEd)=0
   aEd:={{SPACE(5),SPACE(5),' ',0}}
ENDIF
SELECT(nArea)
RETURN aEd


FUNCTION RestPar(cForm)
LOCAL cUser:=SPACE(10),cUser0:=SPACE(10)
LOCAL nArea:=SELECT()
LOCAL xValue,lArm:=.F.,nProces
PRIVATE cParam
IF LEN( cForm ) = 2 .AND. ( cForm$'030509SR' .OR. cForm == "SZ" )
   Stru->(ORDSETFOCUS(1))
   lArm:=.T.
ELSE
   cForm:=PADR(cForm,4)
   Stru->(ORDSETFOCUS(2))
ENDIF
IF TYPE('ST_FILE')=='C' //Сеть
   cUser:=m->ST_FILE
ENDIF
SELECT Stru
IF DBSEEK(UPPER(cForm))
   IF lArm
      nProces := Proces_Ini(LASTREC()*IF(GlobalTask='03',0.3,IF(GlobalTask=='05',0.7,1)),,,"Загрузка параметров")
   ENDIF
   WHILE UPPER(IF(lArm,Stru->Arm,Stru->Form))==UPPER(cForm)
      IF lArm
         Proces_Update(nProces)
      ENDIF
      cParam:=Stru->Ident
      IF !EMPTY(cParam)
         IF !EMPTY(Vid)
            PUBLIC &cParam:={NIL,.T.,.T.}
         ELSE
            PUBLIC &cParam
         ENDIF
         User->(DBSEEK(UPPER(IF(Stru->Common,cUser0,cUser)+Stru->(Form+Ident))))
         GetVal()
      ENDIF
      SKIP
   ENDDO
   IF lArm
      Proces_End()
   ENDIF
ENDIF
SELECT(nArea)
IF UPPER(cFORM)='MLAB'.AND.SELECT('MLABEL')>0.AND.MLabel->(FIELDPOS('KOEF1'))=0
   m->Koef1_[2]:=.F.
ENDIF
RETURN(NIL)


FUNCTION SavePar(cForm)
LOCAL nArea:=SELECT()
LOCAL cUser:=SPACE(10),cUser0:=SPACE(10),nProces
LOCAL xValue,lArm:=.F.
IF !_REC_YES
   RETURN(NIL)
ENDIF
IF TYPE('ST_FILE')=='C' //Сеть
   cUser:=m->ST_FILE
ENDIF
SELECT Stru
IF RecLock()
   DBUNLOCK()
   IF LEN(cForm)=2 .AND. ( cForm$'030509SR' .OR. cForm == "SZ" )
      Stru->(ORDSETFOCUS(1))
      lArm:=.T.
   ELSE
      cForm:=PADR(cForm,4)
      Stru->(ORDSETFOCUS(2))
   ENDIF
   DBSEEK(UPPER(cForm))
   IF lArm
      nProces := Proces_Ini(LASTREC()*IF(GlobalTask='03',0.3,IF(GlobalTask=='05',0.7,1)),,,"Запись параметров")
   ENDIF
   WHILE Stru->(UPPER(IF(lArm,FIELD->Arm,FIELD->Form)))==UPPER(cForm)
      IF lArm
         Proces_Update(nProces)
      ENDIF
      IF !EMPTY(Stru->Ident)
         SELECT User
         DBSEEK(UPPER(IF(Stru->Common,cUser0,cUser)+Stru->(Form+Ident)))
         IF EOF()
            AddRec()
            REPLACE User WITH IF(Stru->Common,cUser0,cUser),;
                    Form WITH Stru->Form,;
                    Ident WITH Stru->Ident
         ENDIF
         PutVal()
         UNLOCK
     ENDIF
      SELECT Stru
      SKIP
   ENDDO
   IF lArm
      Proces_End()
   ENDIF
ENDIF
SELECT(nArea)
RETURN(NIL)

FUNCTION ClosePar(cForm)
LOCAL nArea:=SELECT(),lArm:=.F.
PRIVATE cParam
IF LEN(cForm)=2 .AND. ( cForm$'030509SR' .OR. cForm == "SZ" )
   Stru->(ORDSETFOCUS(1))
   lArm:=.T.
ELSE
   cForm:=PADR(cForm,4)
   Stru->(ORDSETFOCUS(2))
ENDIF
SELECT Stru
DBSEEK(UPPER(cForm))
WHILE UPPER(IF(lArm,Stru->Arm,Stru->Form))==UPPER(cForm)
   IF !EMPTY(Ident)
      cParam:=Stru->Ident
      RELEASE &cParam
   ENDIF
   SKIP
ENDDO
SELECT(nArea)
RETURN(NIL)

STATIC FUNCTION GetVal()
LOCAL xValue:=IF(iUSER->(EOF()).OR.EMPTY(iUSER->xVal),iSTRU->Init0,iUSER->xVal)
LOCAL cParam := GetPrefix()+ALLTRIM(iSTRU->Ident)
DO CASE
   CASE iSTRU->TypeVal='C'
   xValue:=PADR(xValue,LEN(TRANSFORM(SPACE(300),TRIM(iSTRU->Pict))))
   CASE iSTRU->TypeVal='N'
   xValue:=VAL(xValue)
   CASE iSTRU->TypeVal='D'
   xValue:=CTOD(xValue)
   CASE iSTRU->TypeVal='L'
   xValue:=IF(xValue='T'.OR.xValue='.T.',.T.,.F.)
   CASE iSTRU->TypeVal='A'
   xValue:= &(ALLTRIM(xValue))
   OTHERWISE
   xValue:=NIL
ENDCASE
IF TYPE(cParam)='A' .AND. !iSTRU->TypeVal='A'
   IF xValue!=NIL
      &cParam.[1]:=xValue
   ENDIF
   IF iUSER->(EOF())
      &cParam.[2]:=iSTRU->When0
   ELSE
      &cParam.[2]:=iUSER->lVal
   ENDIF
   &cParam.[3]:=iSTRU->Common
ELSEIF TYPE(cParam)!='U'
   &cParam:=xValue
ENDIF
RETURN xValue

STATIC FUNCTION PutVal(i)
LOCAL cType
LOCAL cParam := GetPrefix()+ALLTRIM(iSTRU->Ident)
LOCAL xValue:= IF(i!=NIL,m->aIn[i],IF((cType := TYPE(cParam))='A',&cParam.[1],IF(cType != "U",&cParam,"")))
LOCAL cSave := ""

RecLock()
DO CASE
   CASE iSTRU->TypeVal='C'
   REPLACE xVal WITH xValue
   CASE iSTRU->TypeVal='N'
   REPLACE xVal WITH STR(xValue)
   CASE iSTRU->TypeVal='D'
   REPLACE xVal WITH DTOC(xValue)
   CASE iSTRU->TypeVal='L'
   REPLACE xVal WITH IF(xValue,'T','F')
   CASE iSTRU->TypeVal='A'
   cSave := "{"
   AEVAL(xValue,{|x| cSave += LockStrF(x,.T.)+","})
   cSave := LEFT(cSave,LEN(cSave)-1)+"}"
   REPLACE xVal WITH cSave
ENDCASE
IF i==NIL.AND.TYPE(cParam)='A'.AND. iSTRU->TypeVal!='A'
   REPLACE lVal WITH &cParam.[2]
ENDIF
UNLOCK
RETURN NIL

FUNCTION VGRightF(nDispLen,nGet,nGetKol)  //Valid после ввода группы с добавлением пробела
RETURN VGRight(nDispLen,nGet,nGetKol)  //Valid после ввода группы

FUNCTION VGRight(nDispLen,nGet,nGetKol)  //Valid после ввода группы
LOCAL nArea:=SELECT(),nOrd
LOCAL get:=GETACTIVE()
IF (nGet==NIL)
   nGet:=1
ENDIF
SELECT MLabel
IF (EMPTY(aIn[nGet+1]))
   DBSEEK(UPPER(aIn[nGet]))
   IF (EMPTY(NNum))
      SKIP
   ENDIF
ELSEIF !DBSEEK(UPPER(aIn[nGet]+aIn[nGet+1]))
   DBSEEK(UPPER(aIn[nGet]))
ENDIF
IF (TYPE('nApp')=='N'.AND.nApp>0)
   aIn[nGet+1]:=MLabel->NNum
ENDIF
IF (nDispLen!=NIL)
   SAYSCREEN(LEFT(MGrup->Name,nDispLen),M->GetList[nGet]:row,M->GetList[nGet]:col+14)
   SAYSCREEN(LEFT(MLabel->Name,nDispLen),M->GetList[nGet+1]:row,M->GetList[nGet+1]:col+14)
ENDIF
SELECT (nArea)
IF TYPE('pLastGrup')='C'
   pLastGrup:=LEFT(aIn[nGet],5)
ENDIF
IF nGetKol!=NIL.AND.nApp>0
   GetList[nGetKol]:picture:=GetPict(14,Kol_)
   GetList[nGetKol]:display()
ENDIF
RETURN (.T.)



//Работа с валютой

FUNCTION WCodeVal(nGet)
IF TYPE('nApp')='N'.AND.nApp>0.AND.EMPTY(aIn[nGet])
   aIn[nGet]:=GlobalValuta
ENDIF
RETURN (.T.)

FUNCTION VCodeVal(nRow,nCol,nRow1,nCol1)
IF SELECT('MOVES')=0.OR.YesValuta
   IF UPPER(Valuta->Code)==UPPER(GlobalValuta)
      SAYSCREEN(PADR(PADR("Курс",10,'.')+':',25),nRow,nCol)
   ELSE
      SAYSCREEN(PADR("Курс ("+IF(Valuta->Myltiply<=1,'',ALLTRIM(STR(Valuta->Myltiply,7))+" ")+;
      GlobalValuta+" за 1 "+Valuta->Code+"):",25),nRow,nCol)
   ENDIF
   IF nRow1!=NIL
      SAYSCREEN(Valuta->Code,nRow1,nCol1)
   ENDIF
ENDIF
RETURN (.T.)

FUNCTION WCenaVal(oGet,nRowHelp,nAdd,lPrice)
//nRowHelp указывается только при входе из произв.счета (Real\R_SchetP.prg)
LOCAL nArea:=SELECT(),lRet:=.T.,lRef:=.F.
IF TYPE('pDate1')!='D'
   pDate1:=pDate
ENDIF
IF UPPER(pCodeVal)==UPPER(GlobalValuta)
   pCenaVal:=VAL(STR(1,12,5))
   IF oGet!=NIL
      oGet:colorSpec:=COL_INPUTA
   ENDIF
   lRet:=.F.
ELSE
   OpenBase({'VCurs'})
   IF oGet!=NIL
      oGet:colorSpec:=COL_GET
      IF lPrice==NIL
         MakeRefer('VCurs','Курс '+pCodeVal,3,;
         {"Дата","Курс"},{5,37,9},COL_REFER,;
         {"VCurs"},{"pCenaVal"},"GetCursDate()",;
         {{||Date},{||VCurs->VCurs}},,,,,,,;
         {||SetScope("UPPER(Valuta)",UPPER(pCodeVal))},{||SetScope()})
      ELSE
         MakeRefer('VCurs','Курс '+pCodeVal,3,;
         {"Дата","Курс"},{5,37,9},COL_REFER,;
         {"VCurs","VCurs"},{"pCenaVal","aCurs[CURRENTGET()-1,2]"},"GetCursDate()",;
         {{||Date},{||VCurs->VCurs}},,,,,,,;
         {||SetScope("UPPER(Valuta)",UPPER(pCodeVal))},{||SetScope()})
      ENDIF
      lRef:=.T.
   ENDIF
   IF pCenaVal=1.OR.CURR_CURS.OR.nRowHelp!=NIL
      DBSEEK(UPPER(pCodeVal)+DTOS(IF(pVid=='1',pDate1,pDate)),.T.)
      IF UPPER(FIELD->Valuta)!=UPPER(pCodeVal)
         SKIP -1
      ENDIF
      IF UPPER(FIELD->Valuta)=UPPER(pCodeVal).AND.Date=IF(pVid="1",pDate1,pDate)
         IF nAdd!=NIL.AND.nAdd==2
            pCenaVal:=FIELD->VCurs
         ENDIF
         IF pVid='1'.AND.CURR_CURS.AND.Date=pDate1.AND.nRowHelp==NIL.AND.oGet!=NIL
            oGet:colorSpec:=COL_INPUTA
            lRet:=.F.
         ENDIF
      ELSE
         SKIP -1
         IF UPPER(FIELD->Valuta)=UPPER(pCodeVal) //.AND.Date<=IF(pVid=="1",pDate1,pDate)
            IF nAdd!=NIL.AND.nAdd==2
               pCenaVal:=FIELD->VCurs
            ENDIF
         ENDIF
      ENDIF
   ENDIF
ENDIF
SELECT (nArea)
RETURN (lRet)

FUNCTION GetCursDate()
IF TYPE('pDate1')!='D'
   pDate1:=pDate
ENDIF
DBSEEK(UPPER(pCodeVal)+DTOS(IF(pVid=='1',pDate1,pDate)),.T.)
IF UPPER(FIELD->Valuta)!=UPPER(pCodeVal)
   SKIP -1
ELSEIF !(UPPER(FIELD->Valuta)=UPPER(pCodeVal).AND.Date=IF(pVid="1",pDate1,pDate))
   SKIP -1
ENDIF
RETURN(UPPER(Valuta+DTOS(Date)))


FUNCTION VCenaVal()
LOCAL nArea:=SELECT()
IF TYPE('pDate1')!='D'
   pDate1:=pDate
ENDIF
IF UPPER(pCodeVal)!=UPPER(GlobalValuta)
   IF pVid='1'.AND.CURR_CURS.AND.LASTKEY()!=K_UP.AND.;
      !(VCurs->Date=IF(pVid=="1",pDate1,pDate).AND.UPPER(VCurs->Valuta)=UPPER(pCodeVal))
      VCurs->(AddRec())
      REPLACE VCurs->Valuta WITH pCodeVal,VCurs->Date WITH IF(pVid=="1",pDate1,pDate),;
      VCurs->VCurs WITH pCenaVal
      DBUNLOCK()
   ENDIF
   ClearRefer('VCurs')
   VCurs->(DBCLOSEAREA())
ENDIF
RETURN(.T.)

FUNCTION SelectSclad(lPlus,lMake)
LOCAL cFilter
LOCAL cFindMacro := 'cFind$UPPER(ShortNAME)'
LOCAL aSortSeek:={;
 {'- по кодам         ','Код?.........:  ','Code','TRIM(UPPER(aIn[1]))','@K','ToRight(1)',,1},;
 {'- по наименованиям ','Наименование?:  ','ShortName','TRIM(UPPER(aIn[1]))','@K',,,3};
 }
LOCAL nArea:=SELECT(),nRet:=0
LOCAL cHead:='Склад'+IF(lPlus==NIL,'',IF(lPlus,'-получатель','-сдатчик'))
IF lMake==NIL
   NetUse('MSclad','MSclad')
ENDIF
MakeRefer('ScladMenu',cHead,1,{'Код','Наименование'},{7,39,10},;
COL_SHEADR,,,,{{||Code},{||ShortName}},;
aSortSeek,,,,,,,{||pSclad:=Code},,,,,,,,,cFindMacro)
IF ( GlobalTask == 'SR' .OR. GlobalTask == 'SZ' ) .AND. TYPE('LBL_CODE') == 'C'
   SET FILTER TO UPPER(Filial)==UPPER(LBL_CODE)
ENDIF
DoRefer(,'ScladMenu')
IF LASTKEY()!=K_ESC
   nRet:=ASCAN(aSclad,{|x|UPPER(SUBSTR(x,2,6))==UPPER(pSclad)})
ENDIF
ClearRefer('ScladMenu')
CLOSE
SELECT(nArea)
RETURN(nRet)

FUNCTION Open0(lFirst)
LOCAL nProces
CLOSE ALL

   IF lFirst=NIL
      Busy(.T.,'Закрытие баз данных')
   ENDIF
   OpenBase({'Plan_Sch','Analit','NANALIT','Stru','User','Moves','MGrup','MStru','MSCHET'},,,;
   IF(lFirst!=NIL,'Настройка параметров','Закрытие баз данных'))
   IF lFirst=NIL
      Busy(.F.)
   ENDIF
   // Отрубим закрытые счета
   PLAN->(dbSetFilter({|| PLAN->STATUS <> "0" },'PLAN->STATUS <> "0"'),dbGoTop())
   
IF NetUse('Cargo','Cargo')
   IF (lFirst!=NIL)
      DO CASE
         CASE GlobalTask='03'
         CreaMenu({'s_menu','s_menuh'})
         CASE GlobalTask='09'
         CreaMenu({'z_menu','z_menuh'})
         CASE GlobalTask = 'SR'
         CreaMenu({'sr_menu','sr_menuh'})
         CASE GlobalTask = 'SZ'
         CreaMenu({'sz_menu','sz_menuh'})
         CASE GlobalTask='11'
         CreaMenu({'a_menu','a_menuh'})
      ENDCASE
      AddSclad()
      AddMoves()
      OpenBase({'Valuta'})
      DBSEEK(UPPER(GlobalValuta))
      GlobalName:=TRIM(Name)
      m->CURR_MAIN:=Valuta->Accuracy
      CLOSE
   ENDIF
ENDIF
RETURN (NIL)

FUNCTION AddSclad()
LOCAL i,j
aSclad:={}
aMol:={}
aFilial:={}
OpenBase({'MSclad'})
IF ( GlobalTask == 'SR' .OR. GlobalTask == 'SZ' ) .AND. TYPE('LBL_CODE') == 'C'
   SET FILTER TO UPPER(Filial)==UPPER(LBL_CODE)
ENDIF
IF FIELDNUM('FILIAL')>0
   DBEVAL({||AADD(aSclad,' '+Code+'. '+ShortName+' '),;
   AADD(aMol,{NameMol,RECNO()}),;
   AADD(aFilial,{Filial,RECNO()});
   })
ELSE
   DBEVAL({||AADD(aSclad,' '+Code+'. '+ShortName+' '),;
   AADD(aMol,{NameMol,RECNO()});
   })
ENDIF
CLOSE
RETURN(NIL)

FUNCTION AddMoves(lVidDoc,lOper)
LOCAL i,j,n:=0
aMoves:={}
aVid:={}
aMovesL:={}
IF SELECT('MOVES')=0
   OpenBase({'Moves'})
ENDIF
SELECT Moves
GO TOP
DBEVAL({||AADD(aMoves,' '+IF(EMPTY(Type),'   ',STR(++n,2,0)+'.')+Name+' '),;
AADD(aVid,{Vid,Type,RECNO()}),;
AADD(aMovesL,!EMPTY(Type))},;
{||!EMPTY(Status).AND.;
 !((lVidDoc!=NIL.OR.lOper!=NIL).AND.(Vid+Type=='14'.OR.Vid='0')).AND.;
((Moves->Use03.AND.!(lVidDoc!=NIL.AND.Num>=50));
 )})
GO TOP
RETURN(NIL)


FUNCTION MakeGrupRefer(cRefer,cDest,nTypeRefer)
LOCAL cFindMacro := 'cFind$UPPER(NAME)'
//Полный справочник групп
LOCAL aSortSeek:={;
 {'- шифрам        ','Шифр?:        ',;
 'Code','UPPER(aIn[1])','@K','ToRight(1)'},;
 {'- наименованиям ','Наименование?:','LEFT(Name,10)',;
 'TRIM(UPPER(aIn[1]))','@K'};
}
cDest:=IF(cDest==NIL,'aIn[1]',cDest)
MakeRefer(cRefer,"Группы запасов",nTypeRefer,{"Шифр","Наименование"},;
{4,31,11},COL_REFER,{"Code"},{cDest},"UPPER("+cDest+")",{{||Code},{||Name}},;
aSortSeek,,,,,,,,,,,,,,,,cFindMacro)
RETURN (NIL)

FUNCTION MakeGrupSRefer(cRefer,cDest,nTypeRefer,lKit)
//Справочник групп на складе pSclad (Private)
//SELECT MStru (2),SetScope('UPPER(Sclad)',pSclad),SET RELATION TO UPPER(Grup) INTO MGrup
LOCAL cHelp:=IF(lKit!=NIL,'F2:Справочник групп Ctrl-F2:Комплекты',NIL)
LOCAL bPre,bPost
LOCAL cFindMacro := 'cFind$UPPER(NAME)'
LOCAL aSortSeek:={;
 {'- шифрам        ','Шифр?:        ',;
 'Grup','UPPER(pSclad+aIn[1])','@K','ToRight(1)',,2}}
IF FIELDPOS('Name')>0
   AADD(aSortSeek,;
 {'- наименованиям ','Наименование?:','Name',;
 'TRIM(UPPER(pSclad+aIn[1]))','@K',,,3})
ENDIF
cDest:=IF(cDest==NIL,'aIn[1]',cDest)
//IF aKitBuffer!=NIL
//   bPre:={||Pre(aKitBuffer)}
//   bPost:={||Post(aKitBuffer)}
//ENDIF
MakeRefer(cRefer,"Группы запасов на складе "+TRIM(pSclad),nTypeRefer,{"Шифр","Наименование"},;
{4,28,11},COL_REFER,{"Grup"},{cDest},"UPPER(pSclad+"+cDest+")",{{||Grup},{||MGrup->Name}},;
aSortSeek,,,,,,bPre,bPost,,,,cHelp,,,,,cFindMacro)
RETURN (NIL)

FUNCTION TotRep()
RETURN (NIL)

FUNCTION View()
RETURN (NIL)

FUNCTION MAGCALC()
RETURN(NIL)

FUNCTION Bloknot()
RETURN(NIL)

FUNCTION Hot_VCurs()
RETURN(NIL)

FUNCTION DisplayHelp()
RETURN(NIL)

FUNCTION Total(cKey,aFields,cBase,cFilter,aBlock,bWhile,lSum) //Заменитель TOTAL
LOCAL aStru:=DBSTRUCT(),i,nArea:=SELECT(),xKey,aRez:=ARRAY(LEN(aFields)),aBuf,nRec,nRec0
IF cFilter==NIL
   cFilter:='.T.'
ENDIF
cFilter:='{||'+cFilter+'}'
FOR i:=1 TO LEN(aStru)
IF aStru[i,2]=='N'.AND.aStru[i,3]==19.AND.aStru[i,4]>=3
   aStru[i,4]:=CURR_MAIN+1
ENDIF
NEXT
DBCREATE(cBase,aStru)
NetUseExc('TempTotal',cBase)
SELECT (nArea)
GO TOP
nRec:=RECNO()
AFILL(aRez,0)
xKey:=&(cKey)
WHILE .T.
   IF EVAL(&(cFilter)).OR.EOF()
      IF !xKey==&(cKey).OR.EOF()
         nRec0:=RECNO()
         GO nRec
         aBuf:=Scatter()
         SELECT TempTotal
         TempTotal->(AddRec())
         TempTotal->(Gather(aBuf))
         AEVAL(aFields,{|x,j|&('FIELD->'+aFields[j]):=aRez[j]})
         IF lSum==NIL.OR.!lSum
            AFILL(aRez,0)
         ENDIF
         SELECT (nArea)
         GO nRec0
         nRec:=nRec0
         IF EOF()
            EXIT
         ENDIF
         xKey:=&(cKey)
      ENDIF
      IF aBlock==NIL
         AEVAL(aFields,{|x,j|aRez[j]+=&(aFields[j])})
      ELSE
         AEVAL(aFields,{|x,j|aRez[j]+=EVAL(aBlock[j])})
      ENDIF
   ENDIF
   SKIP
   IF bWhile!=NIL.AND.!EVAL(bWhile)
      GO LASTREC()+1
   ENDIF
ENDDO
SELECT TempTotal
CLOSE
SELECT(nArea)
RETURN NIL

/*********************************************
FUNCTION Total(cKey,aFields,cBase,cFilter,aBlock,lSum) //Заменитель TOTAL
LOCAL aStru:=DBSTRUCT(),i,nArea:=SELECT(),xKey,aRez:=ARRAY(LEN(aFields)),aBuf,nRec,nRec0
IF cFilter==NIL
   cFilter:='.T.'
ENDIF
cFilter:='{||'+cFilter+'}'
FOR i:=1 TO LEN(aStru)
IF aStru[i,2]=='N'.AND.aStru[i,3]==19.AND.aStru[i,4]==3
   aStru[i,4]:=CURR_MAIN+1
ENDIF
NEXT
DBCREATE(cBase,aStru)
NetUseExc('TempTotal',cBase)
SELECT (nArea)
GO TOP
nRec:=RECNO()
AFILL(aRez,0)
xKey:=&(cKey)
WHILE .T.
   IF EVAL(&(cFilter)).OR.EOF()
      IF !xKey==&(cKey).OR.EOF()
         nRec0:=RECNO()
         GO nRec
         aBuf:=Scatter()
         SELECT TempTotal
         TempTotal->(AddRec())
         TempTotal->(Gather(aBuf))
         AEVAL(aFields,{|x,j|&('FIELD->'+aFields[j]):=aRez[j]})
         IF lSum==NIL
            AFILL(aRez,0)
         ENDIF
         SELECT (nArea)
         GO nRec0
         nRec:=nRec0
         IF EOF()
            EXIT
         ENDIF
         xKey:=&(cKey)

      ENDIF
      IF aBlock==NIL
         AEVAL(aFields,{|x,j|aRez[j]+=&(aFields[j])})
      ELSE
         AEVAL(aFields,{|x,j|aRez[j]+=EVAL(aBlock[j])})
      ENDIF
   ENDIF
   SKIP
ENDDO
SELECT TempTotal
CLOSE
SELECT(nArea)
RETURN NIL
********************************************/

FUNCTION WDoc()
RETURN(NIL)

FUNCTION VDoc()
RETURN(NIL)

FUNCTION ControlMem()
RETURN(NIL)

FUNCTION COMMENT()
RETURN(NIL)

FUNCTION SprDop(cNameRef, nType, cMess,cVar,cType,cName,lNoAdd)
//----------------------------------------------------------------------------//
// Справочник значений полей
LOCAL aHeads :=  {{"Наименование.:","NAME"}}
LOCAL aVar:= {cVar}
LOCAL aDest:= {"PADR(NAME,LEN("+aVar[1]+"))"}
LOCAL aWhen := {{|| .T. }}
LOCAL bPost := {|| FIELD->CODE := cType,IF(MemVar->nApp = S_LIB_ADD,FIELD->NNOPER := IncStep("DopOper"),NIL) }
LOCAL aValid := {{|oGet| !EMPTY(oGet:VarGet()) }}

IF(cName != NIL,,cName := "Наименование")
nType:=If(nType==NIL,1,nType)
MakeRefer( cNameRef ," Справочник "+If(RTrim(Upper(Alias()))=='SPR_RECV',"реквизитов ","атрибутов "),nType,{PADC(cName,25,CHR(255))},{4,19,10},COL_REFER,;
aDest,aVar,"'"+cType+"'+UPPER("+aVar[1]+")",;
{{|| PADR(FIELD->NAME,27) }},{{'- по наименованию','Наименование:','NAME'  ,'"'+cType+'"+UPPER(RTRIM(aIn[1]))','@KS25','.T.','',1,}},IF(EMPTY(lNoAdd),aHeads,NIL),,aWhen,aValid,bPost,;
&("{|| dbPush(),ORDSETFOCUS('TAG_CODE'),SetScope(CODE,'"+cType+"') }"),;
{|bakRec| bakRec := RECNO(),dbPop(),dbGoTo(bakRec) },,,,cMess)

RETURN NIL


FUNCTION DELMAIN()
RETURN(NIL)






#define BOX_E Space(8)
#define BOX_D "╔═╗║╝═╚║"
#define BOX_S "┌─┐│┘─└│"
#define BOX_P "▄▄▄██▄██"
//--------------------------------------------------------------------------//
 Function Frame(cHead, nTop, nLeft, nBottom, nRight, cCol, Frm, lShad, lCls)
//--------------------------------------------------------------------------//

   Local cCls   := If(lCls == NIL, "", " ")
   Local cColor := If(cCol == NIL, COL_BROWSE, cCol)

   Local cBox   := If(Frm == NIL, BOX_E,;
                    If(ValType(Frm) == "C", Frm,;
                     If(Frm == 0, BOX_E,;
                      If(Frm == 1, BOX_S,;
                        If(Frm == 2, BOX_D, BOX_P)))))

   If(lShad == NIL,;
    DispBox(nTop, nLeft, nBottom, nRight, cBox + cCls, cColor),;
    ShadowBox("", nTop, nLeft, nBottom, nRight, cColor, cBox))
   If(cHead == NIL,,;
    AOut(cHead, nTop, nLeft + 2,;
         If(cColor == COL_BROWSE, COL_BROWS1, cColor)))

 Return (NIL)
//--------------------------------------------------------------------------//
 Function AOut(Val, nRow, nCol, cColor, aPict)
//--------------------------------------------------------------------------//
// Выводит массив стpуктуpы {x,y,block или xVar, cColor_var }
// ли {{x,y},block или xVar,cColor_var} пpи этом обязат. aPict
// cColor_var - необяз. по умолчан. cColor
   If(ValType(Val) == "A",;
    AEval(Val,;
           {|x,y| IF(;
                     ValType(x[1]) = "A",;
                     AOut(TRANSFORM((FiArea(x[2]))->(EVAL(IF(FieldPos(FiName(x[2])) = 0,MEMVARBLOCK(FiName(x[2])),FIELDBLOCK(FiName(x[2]))))),aPict[y]),x[1][1], x[1][2], IF(LEN(x) > 2,x[3],cColor)),;
                     AOut(x[3],x[1], x[2],  IF(LEN(x) > 3,x[4],cColor));
                    );
            };
          ),;
    (SetPos(If(nRow == NIL, Row(), nRow),;
            If(nCol == NIL, Col(), nCol)),;
            DispOut(If(ValType(Val) == "B", Eval(Val), Val),cColor)))



 Return(NIL)
//--------------------------------------------------------------------------//
FUNCTION FiName(cField)
//--------------------------------------------------------------------------//
RETURN FiNumAlias(cField,3)
//--------------------------------------------------------------------------//
FUNCTION FiArea(cField)
//--------------------------------------------------------------------------//
RETURN FiNumAlias(cField,4)
//--------------------------------------------------------------------------//
STATIC FUNCTION FiNumAlias(cField,nMode)
//--------------------------------------------------------------------------//
LOCAL cAlias,cFi
IF ('->'$cField)
   cAlias:=LEFT(cField,AT('->',cField)-1)
   cFi:=SUBSTR(cField,AT('->',cField)+2)
ELSE
   cAlias:=ALIAS()
   cFi:=cField
ENDIF
DO CASE
   CASE (nMode==1)
   RETURN (cAlias)->(FIELDPOS(cFi))
   CASE (nMode==2)
   RETURN (cAlias)
   CASE (nMode==3)
   RETURN (cFi)
ENDCASE
RETURN (SELECT(cAlias))
//--------------------------------------------------------------------------//
              Function A_Col(masiv,col)
//--------------------------------------------------------------------------//
// возвращает колонку (col) массива (masiv)  как отдельный массив
LOCAL mas_col := {}
AEVAL( masiv, { |x| AADD(mas_col,x[col]) } )
RETURN mas_col
//--------------------------//
  FUNCTION InitListHelp(cMess,lFlag)
//--------------------------//
// Подсказка в MaxRow() при работе в InitList()
LOCAL n_App := 1
IF( ValType(cMess) = "C", , cMess := "" )
IF( ValType(lFlag) = "L", , lFlag := .T. )
IF( Type("nApp") != "N", , n_App := MemVar->nApp )


DO CASE
   CASE n_App==0
   cMess +='Пустое поле:безразличный фактор'
   CASE n_App==1
   cMess +='┘:Ввод  PgDn/PgUp:Вперед/Назад'
   CASE n_App==2
   cMess +='┘:Ввод  PgDn:Досрочный ввод'
ENDCASE

IF lFlag
  ScrTitul(MaxRow(),cMess)
  RETURN .T.
ENDIF
RETURN cMess
//----------------------------------------------------------------------------//
               FUNCTION HeadRej(nRej,cDoc)
//----------------------------------------------------------------------------//
cDoc := IF(ValType(cDoc) = "C",cDoc,"документа")
DO CASE
   CASE nRej = S_LIB_EDIT
     RETURN "[ Правка "+cDoc+" ]"
   CASE nRej = S_LIB_ADD
     RETURN "[ Ввод "+cDoc+" ]"
   CASE nRej = S_LIB_FILTER
     RETURN "[ Фильтp ]"
   CASE nRej = S_LIB_PROSM
     RETURN "[ Пpосмотp "+cDoc+" ]"
ENDCASE
RETURN ""
//----------------------------------------------------------------------------//
FUNCTION ReferPlan( cName, cVar, cVar1 , nType, cMess)
//----------------------------------------------------------------------------//
// План счетов
nType:=If(nType==NIL,1,nType)
MakeRefer( cName ,"План счетов",nType,{"Счет","Наименование"},{3,11,10},COL_REFER,;
{"Schet"},{cVar}, UPPER(cVar1),;
{{||PLAN->Schet},{||LEFT(PLAN->Name_Sch,54)}},;
{{"","Введите номер счета","Schet","UPPER(RTRIM(aIn[1]))"}},,,,,,,,,,,cMess)
RETURN NIL

 Function IncStep(cInc, nLenC)
//----------------------------------------------------------------------------//
// возвращает следущий номер операции
// cInc - уникальное (для треб. счетчика) имя
// nLenC - Длина строки если счетчик-строка
LOCAL nNoper := IF(EMPTY(nLenC), Glob_StepPlus( cInc, "INI\INI_CASH"), STR(Glob_StepPlus( cInc, "INI\INI_CASH"),nLenC,0) )
IF EMPTY(nNoper)
  IF EMPTY(nNoper := IF(EMPTY(nLenC), Glob_StepPlus( cInc, "INI\INI_CASH"), STR(Glob_StepPlus( cInc, "INI\INI_CASH"),nLenC,0)) )
    SayError( {'Ошибка формирования уникального номера !'})
    nNOper:=0
  ENDIF
ENDIF
RETURN nNoper

FUNCTION ValidCode(Code_New, Code_Old, cAlias, nOrd, lAdd   )
//----------------------------------------------------------------------------//
// Проверка кода на уникальность
LOCAL Old_Sel:=Select(), Old_Ord, nRecno, lRet:=.T., nCursor := SetCursor(0)

Select(cAlias)
Old_Ord:=OrdName()
nRecno :=Recno()

If Empty(Code_New)
   lRet:=.F.
Else
   OrdSetFocus(nOrd)/*DbSetOrder(nOrd)*/
   If (!lAdd)
      If ( Code_New != Code_Old )
         If DbSeek(Code_New)
            lRet:=SayError("Данный код уже используется !")
         endif
      endif
   Else
     If DbSeek(Code_New)
        lRet:=SayError("Данный код уже используется !")
     endif
   EndIF
EndIF

OrdSetFocus(Old_Ord)/*DbSetOrder(Old_Ord)*/
DbGoTo( nRecno )
SetCursor(nCursor)
Select(Old_Sel)
RETURN lRet
FUNCTION DISPLABELT()
RETURN NIL
FUNCTION SPRDOPTREE()
RETURN NIL
FUNCTION BLOCKSTRIN()
RETURN NIL
FUNCTION INCLEARTRE()
RETURN NIL
FUNCTION INGETTREE()
RETURN NIL
FUNCTION GETINSPR()
RETURN NIL
FUNCTION LABELGETTO()
RETURN NIL
FUNCTION CREATEMETK()
RETURN NIL
FUNCTION LENFULLKEY()
RETURN NIL
FUNCTION TREEGETKEY()
RETURN NIL
FUNCTION RESTTREENA()
RETURN NIL
FUNCTION DELETEMETK()
RETURN NIL
//---------------------------------------------------------------------------//
FUNCTION RetNumEd(lPlus)
//---------------------------------------------------------------------------//
// Возвращает номер п/п текущей единицы измерения
// lPlus - .T.  в ед. прихода
//         .F.  в ед. расхода
//          0   в осн. ед.
//          1,4   в ед. расхода
//          2,3   в ед. прихода
//          NIL то в случае реализации lPlus = nKolPrice
//                 в случае склада в зависимости pVid и pType
LOCAL nEd
IF GlobalTask = "05"
  IF GetPrefix() == "T"
    lPlus := 0
  ELSEIF lPlus = NIL
    lPlus := MemVar->nKolPrice
  ENDIF
ENDIF
IF lPlus != NIL
  IF ValType(lPlus) = "N"
    nEd := IF(lPlus = 0,0,IF(lPlus = 1 .OR. lPlus = 4,iMLABEL->N_R,iMLABEL->N_P))
  ELSE
    nEd := IF(lPlus,iMLABEL->N_P,iMLABEL->N_R)
  ENDIF
ELSEIF TYPE('pVid') = "C" .AND. TYPE('pType') = "C" .AND. ( pVid = '0' .OR. pVid = '1' .OR. pVid = "2" ) .AND. pType = "9"
        nEd := 0
ELSEIF TYPE('pVid') = "C" .AND. (pVid = '1' .OR. pVid = '2') .AND. pType != "4"
  nEd := IF(pVid = '1' .AND. pType != "+",iMLABEL->N_P,iMLABEL->N_R)
ELSE
  nEd := 0
ENDIF
RETURN nEd+1
//---------------------------------------------------------------------------//
FUNCTION RetEdR(lPlus)
//---------------------------------------------------------------------------//
// Возвращает коэффициент R для текущуей ед. измерения
// lPlus - .T.  в ед. прихода
//         .F.  в ед. расхода
//          0   в осн. ед.
//          1,4   в ед. расхода
//          2,3   в ед. прихода
//          NIL то в случае реализации lPlus = nKolPrice
//                 в случае склада в зависимости pVid и pType
LOCAL nEd
IF GlobalTask = "05"
  IF GetPrefix() == "T"
    lPlus := 0
  ELSEIF lPlus = NIL
    lPlus := MemVar->nKolPrice
  ENDIF
ENDIF
IF lPlus != NIL
  IF ValType(lPlus) = "N"
    nEd := IF(lPlus = 0,0,IF(lPlus = 1.OR.lPlus = 4,iMLABEL->N_R,iMLABEL->N_P))
  ELSE
    nEd := IF(lPlus,iMLABEL->N_P,iMLABEL->N_R)
  ENDIF
ELSEIF TYPE('pVid') = "C" .AND. TYPE('pType') = "C" .AND. ( pVid = '0' .OR. pVid = '1' .OR. pVid = "2" ) .AND. pType = "9"
        nEd := 0
ELSEIF TYPE('pVid') = "C" .AND. (pVid = '1' .OR. pVid = '2') .AND. pType != "4"
  nEd := IF(pVid = '1' .AND. pType != "+",iMLABEL->N_P,iMLABEL->N_R)
ELSE
  nEd := 0
ENDIF
RETURN IF(nEd = 0,1,iMLABEL->(FieldGet(FieldPos("R"+NTOC(nEd)))))
//---------------------------------------------------------------------------//
FUNCTION RetEd(lPlus)
//---------------------------------------------------------------------------//
// Возвращает текущую ед. измерения
// lPlus - .T.  в ед. прихода
//         .F.  в ед. расхода
//          0   в осн. ед.
//          1,4   в ед. расхода
//          2,3   в ед. прихода
//          NIL то в случае реализации lPlus = nKolPrice
//                 в случае склада в зависимости pVid и pType
LOCAL nEd
IF GlobalTask = "05"
  IF GetPrefix() == "T"
    lPlus := 0
  ELSEIF lPlus = NIL
    lPlus := MemVar->nKolPrice
  ENDIF
ENDIF
IF lPlus != NIL
  IF ValType(lPlus) = "N"
    nEd := IF(lPlus = 0,0,IF(lPlus = 1.OR.lPlus = 4,iMLABEL->N_R,iMLABEL->N_P))
  ELSE
    nEd := IF(lPlus,iMLABEL->N_P,iMLABEL->N_R)
  ENDIF
ELSEIF TYPE('pVid') = "C" .AND. TYPE('pType') = "C" .AND. ( pVid = '0' .OR. pVid = '1' .OR. pVid = "2" ) .AND. pType = "9"
        nEd := 0
ELSEIF TYPE('pVid') = "C" .AND. (pVid = '1' .OR. pVid = '2') .AND. pType != "4"
  nEd := IF(pVid = '1' .AND. pType != "+",iMLABEL->N_P,iMLABEL->N_R)
ELSE
  nEd := 0
ENDIF
RETURN iMLABEL->(FieldGet(FieldPos("ED"+IF(nEd = 0,"",NTOC(nEd)))))
//---------------------------------------------------------------------------//
FUNCTION RetKolEd(nKol,lPlus)
//---------------------------------------------------------------------------//
// Переводит кол-во в тек.доп.ед.изм.
// или проводит перевод цены из доп.ед.изм. в основную
// lPlus - .T.  в ед. прихода
//         .F.  в ед. расхода
//          0   в осн. ед.
//          1   в ед. расхода
//          2   в ед. прихода
//          3   в ед. прихода KolOut1 или KolOut
//          4   в ед. расхода KolOut2 или KolOut
//          NIL то в случае реализации lPlus = nKolPrice
//                 в случае склада в зависимости pVid и pType
LOCAL nKol1
LOCAL nEd,pFor
IF GlobalTask = "05"
  IF GetPrefix() == "T"
    lPlus := 0
  ELSEIF lPlus = NIL
    lPlus := MemVar->nKolPrice
  ENDIF
ENDIF
IF lPlus != NIL
  IF ValType(lPlus) = "N"
    nEd := IF(lPlus = 0,0,IF(lPlus = 1 .OR. lPlus = 4,iMLABEL->N_R,iMLABEL->N_P))
    IF lPlus < 3
      lPlus := NIL
    ENDIF
        ELSEIF TYPE('pVid') = "C" .AND. TYPE('pType') = "C" .AND. ( pVid = '0' .OR. pVid = '1' .OR. pVid = "2" ) .AND. pType = "9"
                nEd := 0
    lPlus := NIL
  ELSE
    nEd := IF(lPlus,iMLABEL->N_P,iMLABEL->N_R)
    lPlus := NIL
  ENDIF
ELSEIF TYPE('pVid') = "C" .AND. TYPE('pType') = "C" .AND. ( pVid = '0' .OR. pVid = '1' .OR. pVid = "2" ) .AND. pType = "9"
        nEd := 0
ELSEIF TYPE('pVid') = "C" .AND. (pVid = '1' .OR. pVid = '2') .AND. pType != "4"
  nEd := IF(pVid = '1' .AND. pType != "+",iMLABEL->N_P,iMLABEL->N_R)
ELSE
  nEd := 0
ENDIF
IF lPlus = NIL
  PRIVATE Q,R
  pFor:= iMLABEL->(FieldGet(FieldPos("ALGO"+IF(nEd = 0,"",NTOC(nEd)))))
  m->Q := 1
  m->R:= iMLABEL->(FieldGet(FieldPos("R"+IF(nEd = 0,"",NTOC(nEd)))))
  nKol1:=1
  IF !EMPTY(pFor).AND.TYPE(pFor)='N'
     nKol1:=iMLABEL->(&pFor)
  ENDIF
  RETURN Div(nKol,nKol1)
ENDIF
IF FieldPos("KolOut1") != 0
  RETURN IF(lPlus = 3,FIELD->KolOut1,FIELD->KolOut2)
ENDIF
RETURN FIELD->KolOut
//---------------------------------------------------------------------------//
FUNCTION RetSumEd(nSum,lPlus)
//---------------------------------------------------------------------------//
// Переводит цену в тек.доп.ед.изм.
// или проводит перевод кол-ва из доп.ед.изм. в основную
// lPlus - .T.  в ед. прихода
//         .F.  в ед. расхода
//          0   в осн. ед.
//          1   в ед. расхода
//          2   в ед. прихода
//          3   в ед. прихода SumOut1/KolOut1 или SumOut/KolOut
//          4   в ед. расхода SumOut2/KolOut2 или SumOut/KolOut
//          NIL то в случае реализации lPlus = nKolPrice
//                 в случае склада в зависимости pVid и pType
LOCAL nSum1
LOCAL nEd,pFor
IF GlobalTask = "05"
  IF GetPrefix() == "T"
    lPlus := 0
  ELSEIF lPlus = NIL
    lPlus := MemVar->nKolPrice
  ENDIF
ENDIF
IF lPlus != NIL
  IF ValType(lPlus) = "N"
    nEd := IF(lPlus = 0,0,IF(lPlus = 1 .OR. lPlus = 4,iMLABEL->N_R,iMLABEL->N_P))
    IF lPlus < 3
      lPlus := NIL
    ENDIF
        ELSEIF TYPE('pVid') = "C" .AND. TYPE('pType') = "C" .AND. ( pVid = '0' .OR. pVid = '1' .OR. pVid = "2" ) .AND. pType = "9"
        nEd := 0
    lPlus := NIL
  ELSE
    nEd := IF(lPlus,iMLABEL->N_P,iMLABEL->N_R)
    lPlus := NIL
  ENDIF
ELSEIF TYPE('pVid') = "C" .AND. TYPE('pType') = "C" .AND. ( pVid = '0' .OR. pVid = '1' .OR. pVid = "2" ) .AND. pType = "9"
  nEd := 0
ELSEIF TYPE('pVid') = "C" .AND. (pVid = '1' .OR. pVid = '2') .AND. pType != "4"
  nEd := IF(pVid = '1' .AND. pType != "+",iMLABEL->N_P,iMLABEL->N_R)
ELSE
  nEd := 0
ENDIF
IF lPlus = NIL
  PRIVATE Q,R
  pFor:= iMLABEL->(FieldGet(FieldPos("ALGO"+IF(nEd = 0,"",NTOC(nEd)))))
  m->Q := 1
  m->R:= iMLABEL->(FieldGet(FieldPos("R"+IF(nEd = 0,"",NTOC(nEd)))))
  nSum1:=1
  IF !EMPTY(pFor).AND.TYPE(pFor)='N'
     nSum1:=iMLABEL->(&pFor)
  ENDIF
  RETURN nSum*nSum1
ENDIF
IF FieldPos("KolOut1") != 0
  RETURN IF(lPlus = 3,Div(FIELD->SumOut1,FIELD->KolOut1),Div(FIELD->SumOut2,FIELD->KolOut2))
ELSEIF FieldPos("SumOutR") != 0
  RETURN Div(FIELD->SumOutR,FIELD->KolOut)
ENDIF
RETURN Div(FIELD->SumOut,FIELD->KolOut)
//--------------------------------------------------------------------------//
                   FUNCTION IsUhetPartia(cGrup,lPartia)
//--------------------------------------------------------------------------//
// Возвращает .T. если учет по учетным ценам партии
// Если lPartia - .T., то возвращается .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->XRAN = "1" .AND. (iMSCHET->METOD != "3" .OR. !EMPTY(lPartia))
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
//--------------------------------------------------------------------------//
               FUNCTION FinGet(cAlias,cName,lShOp)
//--------------------------------------------------------------------------//
// Возвращает значение поля
LOCAL cRet
IF lShOp = NIL .AND. SELECT("SH_OP") != 0 .AND. SH_OP->TYPE $ "45" .AND. SH_OP->(FieldPos(cName)) != 0
 RETURN SH_OP->(FieldGet(FieldPos(cName)))
ENDIF
RETURN IF((cAlias)->(FieldPos(cName)) != 0,(cAlias)->(FieldGet(FieldPos(cName))),IF((cAlias)->(TYPE(cName))= "U","",(cAlias)->(&cName)))
