PSC_Constants.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.Runtime.InteropServices;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
using System.Data;

using PDA.Service;

using FRACT = System.Decimal;


namespace PDA.Service
{
    public partial class AppC
    {
        // Îáùèé êîä äëÿ àâòîðèçàöèè
        internal const string GUEST = "1";

        public const int RC_NOID = 401;         // íå óêàçàí ID îïèñàíèÿ
        public const int RC_BADID = 20;         // íå ðàñïîçíàí ID ñåðèè (íåò îïèñàíèÿ)

        public const int F_CHGZMK = 63;         // ñìåíà çàìêà
        public const int F_OPENSH = 71;         // ïîäíÿòü øëàãáàóì íà ïðîõîäíîé
        public const int F_CLOSESH = 72;        // ïîäíÿòü øëàãáàóì íà ïðîõîäíîé

        // Íîìåðà äîïóñòèìûõ êîìàíä
        internal const int COM_ZSPR     = 0;    // çàãðóçêà ñïðàâî÷íèêîâ
        internal const int COM_ZPL      = 1;    // çàãðóçêà ñâåäåíèé ïî ¹ ïóòåâîãî
        internal const int COM_ZCONTR   = 2;    // êîíòðîëü íà âûåçäå
        internal const int COM_ZOPEN    = 3;    // ïîäíÿòü øëàãáàóì
        internal const int COM_ZCLOSE   = 4;    // çàêðûòü øëàãáàóì
        // ñèìâîëüíûå çíà÷åíèÿ êîìàíä
        internal static string[] saComms = { "ZSPR", "ZPL", "ZCONTR", "ZOPEN", "ZCLOSE" };


        // Òåðìèíàòîð äëÿ êîìàíäû
        internal static byte[] baTermCom = { 13, 10 };
        // Òåðìèíàòîð äëÿ ïåðåäàâàåìûõ äàííûõ
        internal static byte[] baTermMsg = { 13, 10, 0x2E, 13, 10 };

        // ñòðîê â îêíå Help
        internal const int HELPLINES = 19;
        // ñòðîê â îêíå äîï.èíôîðìàöèè
        internal const int INFLINES = 17;

        // òèïû äîêóìåíòîâ
        public const int TYPD_SAMV = 0;             // îòãðóçêà-ñàìîâûâîç
        public const int TYPD_ÑVYV = 1;             // îòãðóçêà-öåíòðîâûâîç
        public const int TYPD_SVOD = 2;             // îòãðóçêà ïî ñâîäó
        public const int TYPD_VPER = 3;             // âíóòðåííåå ïåðåìåùåíèå
        public const int TYPD_AKT_SPIS = 4;         // àêò ñïèñàíèÿ
        public const int TYPD_INV = 7;             // èíâåíòàðèçàöèÿ
        public const int TYPD_VZV_TTN = 10;         // âîçâðàò ïî íàêëàäíîé
        public const int TYPD_VZV_SVOD = 12;        // âîçâðàò ïî ñâîäó

        internal const int DIR_IN = 1;
        internal const int DIR_OUT = 2;

        internal const int GRUZ_EMPTY = 1;
        internal const int GRUZ_MAIN = 2;

    }


}

namespace Proh
{
   

    // íàñòðîéêè ïðîãðàììû
    public sealed class AppPars
    {

        //===***===
        // Ïóòü ê ðåçåðâíîé êîïèè
        private string m_AppStore;
        // Ïóòü ê ÍÑÈ
        private string m_NSIPath;
        // Ïóòü ê äàííûì
        private string m_DataPath;

        // HOST-name ñåðâåðà
        private string m_Host;
        // ¹ ïîðòà ñåðâåðà (îáìåí äàííûìè)
        private int m_SrvPort;
        // ¹ ïîðòà ñåðâåðà (îáìåí ñîîáùåíèÿìè)
        private int m_SrvPortM;
        // Âêë/âûêë îáìåí ñîîáùåíèÿìè ñ ñåðâåðîì
        private bool m_WaitSock;

        // HOST-name ñåðâåðà øëàãáàóìà
        private string m_HostSh;
        // ¹ ïîðòà ñåðâåðà øëàãáàóìà
        private int m_SrvPortSh;

        // Ñìåí â ñóòêè
        private int m_Smennost;


        private bool 
            m_OpenSrv,                  // Êîìàíäà Îòêðûòü - ÷åðåç ñåðâåð
            m_CloseSrv,                 // Êîìàíäà Çàêðûòü - ÷åðåç ñåðâåð
            m_ChkPrmOut = true,         // Ïðîâåðêà ïðîïóñêà íà âûåçäå
            m_2DFull;                   // ×òåíèå ïîëíîñòüþ âñåé ñåðèè 2D

        // Login äëÿ äîñòóïà ê ñåðâåðó øëàãáàóìîâ
        private string m_LoginSh = "test";
        // Pass äëÿ äîñòóïà ê ñåðâåðó øëàãáàóìîâ
        private string m_PassSh = "TseT";
        // DevID øëàãáàóìà
        private string m_DevID = "SHLG";

        //-----*****-----*****-----
        // Òåêóùåå ïîëå (èíäåêñ)
        private int m_CurField;

        /// Ïàíåëü ââîäà
        /// 

        // òàáëèöà ñ ïàðàìåòðàìè
        private static string sFilePars = "TermPars.xml";

        public AppPars()
        {
            m_AppStore = @"\BACKUP\OAO_SP\TermMC";
            m_NSIPath = @"\BDDOC\";
            m_DataPath = @"\BDDOC\";

            m_Host = "BPR_SERV3";
            m_SrvPort = 11010;
            m_SrvPortM = 11001;
            m_WaitSock = false;
            m_HostSh = "10.0.0.213";
            m_SrvPortSh = 1235;
            Smennost = 2;

            m_OpenSrv = true;
            m_CloseSrv = false;
            m_2DFull = false;

            CurField = 0;
        }

        //---***---***---
        #region Îáùèå ïàðàìåòðû 

        // Ïóòü ê ðåçåðâíîé êîïèè
        public string sAppStore
        {
            get { return m_AppStore; }
            set { m_AppStore = value; }
        }
        // Ïóòü ê ÍÑÈ
        public string sNSIPath
        {
            get { return m_NSIPath; }
            set { m_NSIPath = value; }
        }
        // Ïóòü ê äàííûì
        public string sDataPath
        {
            get { return m_DataPath; }
            set { m_DataPath = value; }
        }

        // HOST-name ñåðâåðà
        public string sHostSrv
        {
            get { return m_Host; }
            set { m_Host = value; }
        }
        // ¹ ïîðòà ñåðâåðà (îáìåí äàííûìè)
        public int nSrvPort
        {
            get { return m_SrvPort; }
            set { m_SrvPort = value; }
        }
        // ¹ ïîðòà ñåðâåðà (îáìåí ñîîáùåíèÿìè)
        public int nSrvPortM
        {
            get { return m_SrvPortM; }
            set { m_SrvPortM = value; }
        }
        // Âêë/âûêë îáìåí ñîîáùåíèÿìè ñ ñåðâåðîì
        public bool bWaitSock
        {
            get { return m_WaitSock; }
            set { m_WaitSock = value; }
        }
        // Ñìåííîñòü â ñóòêè
        public int Smennost
        {
            get { return m_Smennost; }
            set { m_Smennost = value; }
        }
        // HOST-name ñåðâåðà øëàãáàóìà
        public string sHostSrvSh
        {
            get { return m_HostSh; }
            set { m_HostSh = value; }
        }
        // ¹ ïîðòà ñåðâåðà øëàãáàóìà
        public int nSrvPortSh
        {
            get { return m_SrvPortSh; }
            set { m_SrvPortSh = value; }
        }
       
        #endregion
        //-----*****-----*****-----
        #region Ïàðàìåòðû ââîäà
        // Ïàðàìåòû ââîäà äàííûõ äëÿ ïîëåé
        //public FieldDef[] aFields = new FieldDef[5];

        // Òåêóùåå ïîëå
        public int CurField
        {
            get { return m_CurField; }
            set { m_CurField = value; }
        }

        // Êîìàíäà Îòêðûòü - ÷åðåç ñåðâåð
        public bool bOpenSrv
        {
            get { return m_OpenSrv; }
            set { m_OpenSrv = value; }
        }
        // Êîìàíäà Çàêðûòü - ÷åðåç ñåðâåð
        public bool bCloseSrv
        {
            get { return m_CloseSrv; }
            set { m_CloseSrv = value; }
        }
        // ×òåíèå ïîëíîñòüþ âñåé ñåðèè 2D
        public bool b2DFull
        {
            get { return m_2DFull; }
            set { m_2DFull = value; }
        }

        // Login äëÿ äîñòóïà ê ñåðâåðó øëàãáàóìîâ
        public string LoginSh
        {
            get { return m_LoginSh.Trim(); }
            set { m_LoginSh = value; }
        }
        // Pass äëÿ äîñòóïà ê ñåðâåðó øëàãáàóìîâ
        public string PassSh
        {
            get { return m_PassSh.Trim(); }
            set { m_PassSh = value; }
        }
        // DevID øëàãáàóìà
        public string DevID
        {
            get { return m_DevID.Trim(); }
            set { m_DevID = value; }
        }

        // Êîíòðîëü ïðîïóñêà íà âûåçäå
        public bool CheckPermitOnOut
        {
            get { return m_ChkPrmOut; }
            set { m_ChkPrmOut = value; }
        }


        #endregion

        public static object InitPars(string sPath)
        {
            int nRet = AppC.RC_OK;
            object xx = null;

            sFilePars = sPath + "\\" + sFilePars;

            nRet = Srv.ReadXMLObj(typeof(AppPars), out xx, sFilePars);
            AppPars xNew = (AppPars)xx;
            if (nRet != AppC.RC_OK)
            {
                if (xNew == null)
                {
                    xNew = new AppPars();
                    SavePars(xNew);
                }
            }
            return (xNew);
        }

        public static int SavePars(AppPars x)
        {
            return (Srv.WriteXMLObjTxt(typeof(AppPars), x, sFilePars));
        }


    }

    // ïàðàìåòðû òåêóùåé ñìåíû (ïîëüçîâàòåëÿ)
    public class Smena
    {
        private static string sXML = "CS.XML";          // èìÿ ôàéëà ñ íàñòðîéêàìè ïîëüçîâàòåëü/ñìåíà

        private int m_Sklad;                            // êîä ñêëàäà
        private int m_Uch;                              // êîä ó÷àñòêà
        private DateTime m_Date;                        // äàòà ïî óìîë÷àíèþ
        private int m_Smena;                            // òåêóùàÿ ñìåíà

        private string 
            m_SDate = "";                               // äàòà ïî óìîë÷àíèþ (ñèìâîëüíàÿ)

        // ïðàâà ïîëüçîâàòåëåé
        public enum USERRIGHTS: int
        {
            USER_KLAD   = 1,                            // êëàäîâùèê
            USER_BOSS_SMENA   = 10,                     // íà÷àëüíèê ñìåíû
            USER_BOSS_SKLAD   = 100,                    // íà÷àëüíèê ñêëàäà
            USER_ADMIN   = 1000,                        // íà÷àëüíèê ñìåíû
            USER_SUPER = 2000                           // íàâåðíîå, Òîëèê
        }


        public string sUser = "";                       // êîä ïîëüçîâàòåëÿ
        public string sUName = "";                      // ÔÈÎ
        public USERRIGHTS 
            urCur = USERRIGHTS.USER_KLAD;               // òåêóùèå ïðàâà    

        // äàòà-âðåìÿ ïîñëåäíåé çàãðóçêè âñåõ ñïðàâî÷íèêîâ
        public DateTime dtLoadNS;

        public DateTime dBeg;                           // íà÷àëî ñìåíû
        public DateTime dEnd;                           // îêîí÷àíèå ñìåíû
        public int nLogins;

        public int nStatus;

        public int nDocs = 0;

        // êîä ñêëàäà
        public int nSklad
        {
            get { return m_Sklad; }
            set { m_Sklad = value; }
        }
        // êîä ó÷àñòêà
        public int nUch
        {
            get { return m_Uch; }
            set { m_Uch = value; }
        }
        // ñìåíà
        public int CurSmena
        {
            get { return m_Smena; }
            set { m_Smena = value; }
        }

        // Äàòà
        public DateTime CurDate
        {
            get { return m_Date; }
            set { m_Date = value; }
        }

        // äàòà äîêóìåíòîâ (ñèìâîëüíàÿ)
        public string DocDate
        {
            get { return m_SDate; }
            set
            {
                try
                {
                    CurDate = DateTime.ParseExact(value, "dd.MM.yy", null);
                }
                catch
                {
                    CurDate = DateTime.Now;
                }
                m_SDate = CurDate.ToString("dd.MM.yy");
            }
        }


        public static int ReadSm(ref Smena xS, string sPath)
        {
            object x;
            int nRet = Srv.ReadXMLObj(typeof(Smena), out x, sPath);
            if (nRet == AppC.RC_OK)
            {
                xS = (Smena)x;
                xS.sUName = xS.sUser = "";
            }
            else
                xS = new Smena();

            return (nRet);
        }

        public int SaveCS(string sP, int nD)
        {
            //xSm.nDocs = DT[NSI.TBD_DOC].dt.Rows.Count;
            //Srv.WriteXMLObjTxt(typeof(Smena), xSm, xP.sDataPath + sP_CS);
            //dsM.WriteXml(xP.sDataPath + sP_CSDat);


            this.nDocs = nD;
            return (Srv.WriteXMLObjTxt(typeof(Smena), this, sP + sXML));
        }


    }


    public class AvtoCtrl
    {
        // Íàïðàâëåíèå äâèæåíèÿ (âúåçä/âûåçä)
        private int m_InOut = AppC.DIR_IN;

        // Ãðóæåíûé èëè íåò
        private int m_Empty = AppC.GRUZ_EMPTY;

        // Öåëü ïåðåìåùåíèÿ
        private int m_Purp;

        // ¹ òÿãà÷à/ïîëóïðèöåïà
        private string m_Avto = "";

        // ¹ ïóòåâîãî
        private string m_NPutev = "";

        // Ìàññà
        private FRACT m_Massa = 0;

        // Ìåñò
        private int m_Mest = 0;

        // Ñóììà
        private FRACT m_Summa = 0;

        // ¹ äîêóìåíòîâ
        private string m_TTN;

        // êîëè÷åñòâî äîêóìåíòîâ
        private int m_KolTTN = 0;

        // êîëè÷åñòâî äîêóìåíòîâ
        private int m_KolTTN_EBD = 0;

        // ¹ ïóòåâîãî äëÿ êîòîðîãî äåëàëè çàãðóçêó
        private string m_LoadPL = "";

        // ¹ ïðîïóñêà
        private string m_NPropusk = "";


        //--------------------------
        // Âðåìÿ âúåçä
        private DateTime m_DateIn;

        // Âðåìÿ âûåçä
        private DateTime m_DateOut;

        public AvtoCtrl(int DirM)
        {
            m_InOut = DirM;
        }


        //=================================
        public bool bCanOpen = true;

        public string PLWasLoad
        {
            get { return m_LoadPL; }
            set { m_LoadPL = value; }
        }

        // ïàðàìåòðû ñ ñåðâåðà
        public string SrvAns = "";
        public string SrvCTM = "";

        // Íàïðàâëåíèå äâèæåíèÿ
        public int DirMove
        {
            get { return m_InOut; }
            set { m_InOut = value; }
        }

        // Òèï ãðóçà
        public int GruzType
        {
            get { return m_Empty; }
            set { m_Empty = value; }
        }

        // Öåëü ïåðåìåùåíèÿ
        public int Purp
        {
            get { return m_Purp; }
            set { m_Purp = value; }
        }

        // Òÿãà÷
        public string Avto
        {
            get { return m_Avto; }
            set { m_Avto = value; }
        }

        // ¹ ïóòåâîãî
        public string Putev
        {
            get { return m_NPutev; }
            set { m_NPutev = value; }
        }

        // Ìàññà
        public FRACT Massa
        {
            get { return m_Massa; }
            set { m_Massa = value; }
        }

        // Ìåñò
        public int Mest
        {
            get { return m_Mest; }
            set { m_Mest = value; }
        }

        // Ñóììà
        public FRACT Summa
        {
            get { return m_Summa; }
            set { m_Summa = value; }
        }

        // ¹ äîêóìåíòîâ
        public string TTN
        {
            get { return m_TTN; }
            set { m_TTN = value; }
        }

        // êîëè÷åñòâî äîêóìåíòîâ (ââåäåíî/îòñêàíèðîâàíî)
        public int KolTTN
        {
            get { return m_KolTTN; }
            set { m_KolTTN = value; }
        }

        // êîëè÷åñòâî äîêóìåíòîâ (äàë ñåðâåð)
        public int KolTTN_EBD
        {
            get { return m_KolTTN_EBD; }
            set { m_KolTTN_EBD = value; }
        }

        // âðåìÿ âûåçäà
        public DateTime TimeOut
        {
            get { return m_DateOut; }
            set { m_DateOut = value; }
        }

        // ¹ ïðîïóñêà
        public string Propusk
        {
            get { return m_NPropusk; }
            set { m_NPropusk = value; }
        }


        // î÷èñòêà äëÿ íîâîé ìàøèíû
        public void ClearAvt(int DM, Control x)
        {
            DirMove = DM;
            Avto = "";
            if (x == null)
                Putev = "";
            Massa = 0;
            Mest = 0;
            Summa = 0;
            TTN = "";
            Propusk = "";

            KolTTN = 0;
            KolTTN_EBD = 0;

            bCanOpen = true;
            PLWasLoad = "";
        }

    }

    // ïîëÿ äîêóìåíòà
    public class DocPars
    {
        public static TextBox tKTyp = null;    // 
        public static Label tNTyp = null;    // 

        public static TextBox tDate = null;    // 

        public static TextBox tKPost = null;    // 

        public static TextBox tNDoc = null;    // 

        public int nTypD;               // òèï äîêóìåíòà (êîä)
        public string sTypD;            // òèï äîêóìåíòà (íàèìåíîâàíèå)

        public DateTime dDatDoc;        // äàòà äîêóìåíòà

        public long nPost;               // êîä ïîñòàâùèêà
        public string sPost;             // íàèìåíîâàíèå ïîñòàâùèêà

        public string sNomDoc;          // ¹ äîêóìåíòà

        public DocPars(int nReg)
        {
            switch(nReg){
                case AppC.F_ADD_REC:
                    nTypD = AppC.TYPD_INV;
                    break;
                case AppC.F_UPLD_DOC:
                case AppC.F_LOAD_DOC:
                    nTypD = AppC.TYPD_VPER;
                    break;
                default:
                    sNomDoc = "";
                    break;
            }
            //dDatDoc = xS.CurDate;
        }

        // íàèìåíîâàíèå òèïà äîêóìåíòà
        public static string TypName(ref int nTD)
        {
            string s = "Íåèçâåñòíî";
            switch (nTD)
            {
                case AppC.TYPD_SAMV:
                    s = "Ñàìîâûâîç";
                    break;
                case AppC.TYPD_ÑVYV:
                    s = "Öåíòðîâûâîç";
                    break;
                case AppC.TYPD_VPER:
                    s = "Â_Ïåðåìåùåíèå";
                    break;
                case AppC.TYPD_SVOD:
                    s = "Ñâîä";
                    break;
                case AppC.TYPD_AKT_SPIS:
                    s = "Àêò ñïèñàíèÿ";
                    break;
                case AppC.TYPD_INV:
                    s = "Èíâåíòàðèçàöèÿ";
                    break;
                case AppC.TYPD_VZV_TTN:
                    s = "Âîçâðàò-ÒÒÍ";
                    break;
                case AppC.TYPD_VZV_SVOD:
                    s = "Âîçâðàò-ñâîä";
                    break;
                case AppC.EMPTY_INT:
                    s = "";
                    break;
                default:
                    nTD = AppC.EMPTY_INT;
                    break;
            }
            return (s);
        }
    }


    // òåêóùèé äîêóìåíò
    public class CurDoc
    {
        public DataRow drCurRow = null; // òåêóùàÿ ñòðîêà â òàáëèöå

        public int nId;                 // êîä äîêóìåíòà

        public bool bSpecCond;          // îñîáûå óñëîâèÿ äëÿ äåòàëüíûõ ñòðîê

        public int nDocSrc;             // ïðîèñõîæäåíèå äîêóìåíòà (çàãðóæåí èëè ââåäåí)
        public int nStrokZ;             // ñòðîê â çàÿâêå
        public int nStrokV;             // ñòðîê ââåäåíî

        public DocPars xDocP;

        public byte[] From2D;
        public int nHead2D;
        public int nFull2D;
        public long nIDSer;

        public CurDoc(int nReg){
            switch (nReg)
            {
                case AppC.F_ADD_REC:
                    // ñîçäàíèå íîâîãî äîêóìåíòà
                    //nCurRec = AppC.EMPTY_INT;
                    nId = AppC.EMPTY_INT;
                    break;
                default:
                    break;
            }

            //nDt = NSI.I_DOCOUT;
            xDocP = new DocPars(nReg);

            bSpecCond = true;
            nStrokZ = 0;
        }
    }

    // òåêóùàÿ çàãðóçêà
    public class CurLoad
    {
        //ðåæèì çàãðóçêè
        public IntRegsAvail ilLoad;

        // ïàðàìåòðû ôèëüòðà
        public DocPars xLP;

        // ðåçóëüòàò çàãðóçêè
        public DataSet dsZ;
        // ñèìâîëüíîå âûðàæåíèå ôèëüòðà
        public string sFilt;

        public CurLoad()
            : this(AppC.UPL_CUR) {}
        public CurLoad(int nRegLoad)
        {
            xLP = new DocPars(AppC.F_LOAD_DOC);
            ilLoad = new IntRegsAvail(nRegLoad);
        }
    }

    // äîñòóïíûå çíà÷åíèÿ ðåæèìîâ
    public class IntRegsAvail
    {
        private struct RegAttr
        {
            public int RegValue;
            public string RegName;
            public bool bRegAvail;

            public RegAttr(int RV, string RN, bool RA)
            {
                RegValue = RV;
                RegName = RN;
                bRegAvail = RA;
            }
        }

        private List<RegAttr> lRegs;
        private int nI;

        public IntRegsAvail() : this(AppC.UPL_CUR) { }

        public IntRegsAvail(int nSetCur)
        {
            lRegs = new List<RegAttr>(5);
            lRegs.Add(new RegAttr(AppC.UPL_CUR, "Òåêóùèé", true));
            lRegs.Add(new RegAttr(AppC.UPL_ALL, "Âñå", false));
            lRegs.Add(new RegAttr(AppC.UPL_FLT, "Ïî ôèëüòðó", false));

            nI = 0;
            CurReg = nSetCur;
        }

        // ïîèñê ïî çàäàííîìó çíà÷åíèþ
        private int FindByVal(int V)
        {
            int ret = -1;
            int nK = 0;
            foreach (RegAttr ra in lRegs)
            {
                if (ra.RegValue == V)
                {
                    ret = nK;
                    break;
                }
                nK++;
            }
            return (ret);
        }

        // Òåêóùèé ðåæèì
        public int CurReg {
            get { return (lRegs[nI].RegValue); }
            set
            {
                int nK = FindByVal(value);
                if (nK >= 0)
                    nI = nK;
            }
        }

        // Íàèìåíîâàíèå òåêóùåãî ðåæèìà
        public string CurRegName
        {
            get { return (lRegs[nI].RegName); }
        }

        // óñòàíîâèòü äîñòóïíîñòü òåêóùåãî ðåæèìà
        public bool CurRegAvail
        {
            get { return (lRegs[nI].bRegAvail); }
            set { 
                RegAttr ra = lRegs[nI];
                ra.bRegAvail = value;
                lRegs[nI] = ra;
            }
        }

        // óñòàíîâèòü ñëåäóþùèé/ïðåäûäóùèé äîñòóïíûå ðåæèìû
        public string NextReg(bool bUp)
        {
            int nK;

            if (bUp == true)
            {// âûáîð ñëåäóþùåãî
                nK = (nI == lRegs.Count - 1) ? 0: nI + 1;
                while ((nK < lRegs.Count) && (nK != nI))
                {
                    if (lRegs[nK].bRegAvail == true)
                    {
                        nI = nK;
                        break;
                    }
                    nK++;
                    if (nK == lRegs.Count)
                        nK = 0;
                }
            }
            else
            {
                nK = (nI == 0)? lRegs.Count - 1 : nI - 1;
                while ((nK >= 0) && (nK != nI))
                {
                    if (lRegs[nK].bRegAvail == true)
                    {
                        nI = nK;
                        break;
                    }
                    if (nK == 0)
                        nK = lRegs.Count - 1;
                    else
                        nK--;
                }
            }

            return (lRegs[nI].RegName);
        }

        // ôëàã äîñòóïíîñòè äëÿ âñåõ
        public void SetAllAvail(bool bFlag)
        {
            for (int i = 0; i < lRegs.Count; i++ )
            {
                RegAttr ra = lRegs[i];
                ra.bRegAvail = bFlag;
                lRegs[i] = ra;
            }
        }

        // Óñòàíîâèòü äîñòóïíîñòü êîíêðåòíîìó
        public bool SetAvail(int nReg, bool v)
        {
            bool ret = false;
            int nK = FindByVal(nReg);
            if (nK >= 0)
            {
                RegAttr ra = lRegs[nK];
                ra.bRegAvail = v;
                lRegs[nK] = ra;
                ret = true;
            }
            return (ret);
        }


    }

    // òåêóùàÿ âûãðóçêà
    public class CurUpLoad
    {
        //ðåæèì âûãðóçêè
        public IntRegsAvail ilUpLoad;

        // ïàðàìåòðû ôèëüòðà
        public DocPars xLP;

        // ïàðàìåòðû êîìàíäû
        public string sComPar;

        public CurDoc xCur;

        public List<int> naComms;

        public CurUpLoad()
            : this(AppC.UPL_CUR) {}

        public CurUpLoad(int nRegUpl)
        {
            xLP = new DocPars(AppC.F_UPLD_DOC);
            ilUpLoad = new IntRegsAvail(nRegUpl);
        }

        //public DataRow SetFiltInRow(NSI xNSI)
        public string SetFiltInRow()
        {

            string sF = String.Format("(TD={0}) AND (DT={1}) AND (KPP1={2})",
                xLP.nTypD, xLP.dDatDoc.ToString("yyyyMMdd"), xLP.nPost);

            return ("(" + sF + ")");
        }

    }

    public class ScanDat
    {
        // ðåçóëüòàòû ñêàíèðîâàíèÿ
        public ScannerAll.BCId ci;      // òèï øòðèõ-êîäà
        public string s;                // øòðèõ-êîä
        public DateTime dScan;          // äàòà-âðåìÿ ñêàíèðîâàíèÿ

        public ScanDat(ScannerAll.BarcodeScannerEventArgs e)
        {
            ci = e.nID;
            s = e.Data;
            dScan = DateTime.Now;

        }

    }

    public sealed class PSC_Types
    {

        public struct ScDat
        {
            // ðåçóëüòàòû ñêàíèðîâàíèÿ
            public ScannerAll.BCId ci;      // òèï øòðèõ-êîäà
            public string s;                // øòðèõ-êîä
            public DateTime dScan;          // äàòà-âðåìÿ ñêàíèðîâàíèÿ

            // âûäðàëè èç øòðèõ-êîäà
            public int nParty;              // ïàðòèÿ
            public string sDataIzg;         // äàòà èçãîòîâëåíèÿ (ñèìâîëüíî)
            public DateTime dDataIzg;       // äàòà èçãîòîâëåíèÿ
            public FRACT fEmk;              // åìêîñòü â øòóêàõ (äëÿ øòó÷íîãî) èëè 
                                            // âåñ óïàêîâêè (äëÿ âåñîâîãî); 0 - åäèíè÷íûé òîâàð

            public int nTara;               // êðàòêèé êîä òàðû(N(2))
            public FRACT fVes;              // âåñ
            public int nMestPal;            // êîëè÷åñòâî ìåñò íà ïàëåòòå

            // tmc
            public int nSysN;


            public int nMest;               // êîëè÷åñòâî ìåñò
            public FRACT fVsego;            // âñåãî øòóê /âåñ
            public int nEmkSht;             // åìêîñòü â øòóêàõ (äëÿ âåñîâîãî)


            // áóäåò íóæíî -???
            //public int nKolSht;             // êîëè÷åñòâî (øòóêè)
            //public float nKolVes;           // êîëè÷åñòâî (âåñ)
            // áóäåò íóæíî -???

            public bool bFindNSI;           // óäàëîñü íàéòè â ÍÑÈ

            //--- íàêîïëåííûå äàííûå
            public FRACT fKolE_alr;         // óæå ââåäåíî åäèíèö äàííîãî êîäà (ìåñò = 0)
            public int nKolM_alr;           // óæå ââåäåíî ìåñò äàííîãî êîäà
            public FRACT fMKol_alr;         // óæå ââåäåíî êîëè÷åñòâî ïðîäóêöèè (ìåñò != 0)
            //--- íàêîïëåííûå äàííûå (òî÷íîå ñîâïàäåíèå)
            public FRACT fKolE_alrT;        // óæå ââåäåíî åäèíèö äàííîãî êîäà (ìåñò = 0)
            public int nKolM_alrT;          // óæå ââåäåíî ìåñò äàííîãî êîäà
            public FRACT fMKol_alrT;        // óæå ââåäåíî êîëè÷åñòâî ïðîäóêöèè (ìåñò != 0)

            //--- çàÿâêà - íàêîïëåííûå äàííûå
            public FRACT fKolE_zvk;         // åäèíèö äàííîãî êîäà âñåãî
            public FRACT fKolE_zvk_ost;     // åäèíèö äàííîãî êîäà åùå îñòàëîñü (ìåñò = 0) ïî çàÿâêå
            public int nKolM_zvk;           // ìåñò äàííîãî êîäà  ïî çàÿâêå
            public int nKolM_zvk_ost;       // ìåñò äàííîãî êîäà  åùå îñòàëîñü ïî çàÿâêå
            public FRACT fMKol_zvk;         // êîëè÷åñòâî (ìåñò != 0)

            // àäðåñà
            public System.Data.DataRow drEd;            // êóäà ñóììèðîâàòü åäèíèöû â ÒÒÍ
            public System.Data.DataRow drMest;          // êóäà ñóììèðîâàòü ìåñòà â ÒÒÍ

            // ñòðîêè èç çàÿâêè
            public System.Data.DataRow drTotKey;        // çàÿâêà íà ìåñòà ñ êîíêðåòíîé ïàðòèåé
            public System.Data.DataRow drPartKey;       // çàÿâêà íà ìåñòà ñ ëþáîé ïàðòèåé
            public System.Data.DataRow drTotKeyE;       // çàÿâêà íà åäèíè÷êè ñ êîíêðåòíîé ïàðòèåé
            public System.Data.DataRow drPartKeyE;      // çàÿâêà íà åäèíè÷êè ñ ëþáîé ïàðòèåé

            public System.Data.DataRow drMC;            // ñòðîêà â ñïðàâî÷íèêå ìàòöåííîñòåé
            // èç ñïðàâî÷íèêà ìàòöåííîñòåé
            public string sKMC;             // ïîëíûé êîä
            public int nKrKMC;              // êðàòêèé êîä
            public string sN;               // íàèìåíîâàíèå
            public int nSrok;               // ñðîê ðåàëèçàöèè (÷àñû)
            public bool bVes;               // ïðèçíàê âåñîâîãî
            public string sEAN;             // EAN-êîä ïðîäóêöèè
            public string sGrK;             // ãðóïïîâîé êîä ïðîäóêöèè
            public FRACT fEmk_s;            // äëÿ âîññòàíîâëåíèÿ åìêîñòè ïðè ïåðåêëþ÷åíèÿõ ìåñò=0
            public string sParty;

            // ïðîèñõîæäåíèå ñòðîêè
            //public NSI.DESTINPROD nDest;                // ÷òî èç çàÿâêè çàêðûâàåòñÿ (îáùàÿ èëè òî÷íàÿ ÷àñòü)

            // ðåçóëüòàò êîíòðîëÿ ïî äàííîìó êîäó-åìêîñòè
            public int nDocCtrlResult;

            public ScDat(ScannerAll.BarcodeScannerEventArgs e)
            {
                ci = e.nID;                         // òèï øòðèõ-êîäà
                s = e.Data;                         // øòðèõ-êîä
                dScan = DateTime.MinValue;

                nParty = AppC.EMPTY_INT;
                sDataIzg = "";
                dDataIzg = DateTime.MinValue;

                nMest = 0;
                nMestPal = 0;
                fEmk = 0;
                fVsego = 0;
                fVes = 0;

                nEmkSht = AppC.EMPTY_INT;

                bFindNSI = false;

                drEd = null;
                drMest = null;
                drMC = null;

                fKolE_alr = 0;
                nKolM_alr = 0;
                fMKol_alr = 0;

                fKolE_alrT = 0;
                nKolM_alrT = 0;
                fMKol_alrT = 0;

                fKolE_zvk = 0;       // åäèíèö äàííîãî êîäà âñãî
                fKolE_zvk_ost = 0;   // åäèíèö äàííîãî êîäà åùå îñòàëîñü (ìåñò = 0) ïî çàÿâêå
                nKolM_zvk = 0;       // ìåñò äàííîãî êîäà  ïî çàÿâêå
                nKolM_zvk_ost = 0;   // ìåñò äàííîãî êîäà  åùå îñòàëîñü ïî çàÿâêå
                fMKol_zvk = 0;       // êîëè÷åñòâî (ìåñò != 0)

                drTotKey = null;     // çàÿâêà íà ìåñòà ñ êîíêðåòíîé ïàðòèåé
                drPartKey = null;    // çàÿâêà íà ìåñòà ñ ëþáîé ïàðòèåé
                drTotKeyE = null;    // çàÿâêà íà åäèíè÷êè ñ êîíêðåòíîé ïàðòèåé
                drPartKeyE = null;   // çàÿâêà íà åäèíè÷êè ñ ëþáîé ïàðòèåé

                sKMC = "";
                nKrKMC = AppC.EMPTY_INT;
                sN = "<Íåèçâåñòíî>";
                nSrok = 0;
                nTara = 0;
                bVes = false;
                sEAN = "";
                sGrK = "";
                fEmk_s = 0;
                sParty = "";

                //nDest = NSI.DESTINPROD.GENCASE;
                nDocCtrlResult = AppC.RC_CANCEL;


                nSysN = 0;
            }

            // ïîëó÷èòü äàííûå èç ñïðàâî÷íèêà ïî EAN èëè êîäó
            public bool GetFromNSI(string s, DataRow dr)
            {
                bFindNSI = false;
                
                if (dr != null)
                {
                    drMC = dr;
                    sN = dr["SNM"].ToString();
                    sKMC = (string)dr["KMT"];
                    nKrKMC = int.Parse(sKMC);
                    bFindNSI = true;

                    bVes = false;

                }
                else
                {
                    sN = sKMC + "-íåò â ñïðàâî÷íèêå";
                }
                return (bFindNSI);
            }
        }


        public struct FuncKey
        {
            public int nF;
            public int nKeyValue;
            public Keys kMod;
            public FuncKey(int f, int v, Keys m)
            {
                nF = f;
                nKeyValue = v;
                kMod = m;
            }
        }
    }


    public class KMTScan
    {
        public int nType;
        public int nSysN;
        public string sKMT;
        public int nParty;
        public DateTime dV;
        public DateTime dG;
        public FRACT fEmk;
        public string sN;

        public KMTScan(string s)
        {
            try
            {
                nType = int.Parse(s.Substring(0, 2));
                nSysN = int.Parse(s.Substring(2, 9));
                sKMT = s.Substring(11, 10);
                nParty = int.Parse(s.Substring(21, 4));
                dV = DateTime.ParseExact(s.Substring(25, 6), "yyMMdd", null);
                fEmk = FRACT.Parse(s.Substring(31, 7));
            }
            catch { }
        }
        public KMTScan(DataRow dr)
        {
            try
            {
                nType = 11;
                sKMT = (string)dr["KMT"];
                sN = (string)dr["SNM"];
                fEmk = (FRACT)dr["EMK"];
                nSysN = (int)dr["SYSN"];
                nParty = (int)dr["NP"];
                dV = DateTime.ParseExact((string)dr["DVR"], "yyyyMMdd", null);
            }
            catch { }
        }


    }
}