private static XtraBinding CreateXtraBindingSource(XOTableContext TableContext, IControllerProvider ControllerProvider, XtraBindingChildProperties ChildProperties)
        {
            object dataSource = ControllerProvider.GetDataSource(TableContext.XOTable);

            DataAvail.Data.DataAdapter.IDataAdapter dataAdapter = ControllerProvider.GetDataAdapter(TableContext.XOTable);

            DataAvail.XtraBindings.XtraBindingOperation oper = new DataAvail.XtraBindings.XtraBindingOperation(dataSource, dataAdapter, ControllerProvider.GetObjectCalculator(TableContext.XOTable));

            XtraBinding xtraBinding = null;

            if (TableContext.ShownChildrenRelations.Count() > 0)
            {
                xtraBinding = new DataAvail.XtraBindings.XtraBindingContainer(dataSource, oper);

                foreach (XORelation rel in TableContext.ShownChildrenRelations)
                {
                    DataAvail.XtraBindings.XtraBinding childBinding = CreateXtraBindingSource(rel.ChildTable.CreateTableChildContext(TableContext.Fields.First(p=>p.Name == rel.ParentField.Name)), ControllerProvider, new XtraBindingChildProperties(
                        xtraBinding, rel.ParentTable.Name, rel.ParentField.Name, rel.ChildTable.Name, rel.ChildField.Name));

                    ((XtraBindingContainer)xtraBinding).Children.Add((XtraBindingChild)childBinding);
                }
            }
            else if (ChildProperties != null)
            {
                xtraBinding = new DataAvail.XtraBindings.XtraBindingChild(dataSource, oper, ChildProperties);
            }
            else
            {
                xtraBinding = new XtraBinding(dataSource, oper);
            }

            return xtraBinding;
        }
        public void AddAppItemContext(XOTableContext TableContext, bool SetCurrent)
        {
            _items.Add(TableContext);

            if (SetCurrent)
                SetCurrentAppItemContext(TableContext);
        }
        protected override void Build(XOTableContext AppItemContext)
        {
            base.Build(AppItemContext);

            _searchButton = new DevExpress.XtraEditors.SimpleButton() { Name = "searchButton", Text = "Искать" };

            this.AddControl(_searchButton, _searchButton.Name, "Поиск");
        }
        public void SetCurrentAppItemContext(XOTableContext TableContext)
        {
            if (CurrentTableContext != TableContext)
            {
                _current = TableContext;

                OnTableContextChanged();
            }
        }
        internal void CalculatorReset(XOTableContext TableContext, int SourceIndex)
        {
            _xtraBindingCalculator.SetAppItemContext(TableContext);

            _xtraBindingCalculator.BindingSourceItem = null;

            if (SourceIndex != -1)
                _xtraBindingCalculator.BindingSourceItem = this[SourceIndex];
        }
        public Controller AddController(XOTableContext TableContext, Func<XtraBinding, XOTableContext, Controller> CreateControllerInstanceFunc)
        {
            if (CreateControllerInstanceFunc == null)
                CreateControllerInstanceFunc = (p, x) => new Controller(p, x);

            Controller controller = DataAvail.Controllers.XtraBindingCreator.CreateController(TableContext, ControllerProvider, CreateControllerInstanceFunc);

            _controllers.Add(controller);

            return controller;
        }
        protected override void Build(XOTableContext TableContext)
        {
            ((System.ComponentModel.ISupportInitialize)(this.gridControl1)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.gridView1)).BeginInit();
            this.SuspendLayout();

            base.Build(TableContext);

            ((System.ComponentModel.ISupportInitialize)(this.gridControl1)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.gridView1)).EndInit();
            this.ResumeLayout(false);
        }
        internal XOTableContext GetTableContext(XContext XContext, XOTable XOTable)
        {
            XOTableContext tableContext = this[XContext, XOTable];

            if (tableContext == null)
            {
                tableContext = new XOTableContext(XOTable, XContext);

                _tablesContext.Add(tableContext);
            }

            return tableContext;
        }
        protected virtual void Build(XOTableContext TableContext)
        {
            _defaultTableContext = TableContext;

            this.SuspendLayout();

            foreach (XOFieldContext fieldContext in TableContext.Fields)
            {
                BuildField(fieldContext);
            }

            foreach (XORelation childRelation in _defaultTableContext.ShownChildrenRelations)
            {
                BuildChildRelation(childRelation);
            }

            this.ResumeLayout();
        }
        internal ObjectProperties(XOTableContext TableContext, IDictionary<string, object> FieldValues)
        {
            tableContext = TableContext;

            /*
            objectName = XOTableContext.Name;

            pkField = XOTableContext.PkFieldName;// AppItemContext.Container.PKField.FieldName;

            Caption = XOTableContext.Caption;

            ReadOnly = XOTableContext.IsCanEdit;//!AppItemContext.IsCanEdit;

            _fields = XOTableContext.Fields.Select(p => p.Name).ToArray(); ;// AppItemContext.Fields.Select(p => p.FieldName).ToArray();
             */

            foreach (string fieldName in Fields)
            {
                SetValue(fieldName, FieldValues[fieldName]);
            }
        }
        public DataAvail.XtraBinding.Calculator.IObjectCalculator GetObjectCalculator(XOTableContext XtraObjectProperties)
        {
            return _objectCalculatorManager != null ? _objectCalculatorManager.GetObjectCalculator(XtraObjectProperties) : null;

        }
        public void CalculatorReset(XOTableContext TableContext)
        {
            if (_bindingSource.IsCalculatorInitialized)
            {
                _bindingSource.CalculatorReset(TableContext, BindingSource.Position);

                if (BindingSource.Position != -1)
                    CalculateInitialize();
            }
        }
 public object GetDataSource(XOTableContext XtraObjectProperties)
 {
     return _dataSet.Tables[XtraObjectProperties.Name];
 }
 public DataAvail.Data.DataAdapter.IDataAdapter GetDataAdapter(XOTableContext XtraObjectProperties)
 {
     return DataAdapter.GetDataAdapter(XtraObjectProperties);
 }
 public void SetAppItemContext(XOTableContext TableContext)
 {
     _tableContext = TableContext;
 }
 private ControllerDynamicContext GetDynamicContextByItem(XOTableContext XOTableContext)
 {
     return null;
 }
        private static void CalculateChildrenRelationsWithFilters(XOTableContext TableContext, DataAvail.XtraBindings.Calculator.ObjectProperties Item, string FieldName)
        {
            XORelation rel = TableContext.FkItemRelation;

            if (rel != null && rel.DefaultValues != null)
            {
                foreach (KeyValuePair<string, object> kvp in rel.DefaultValues)
                {
                    Item.SetValue(kvp.Key, kvp.Value);
                    Item.SetReadOnly(kvp.Key, true);
                }
            }
        }
 private static void CalculateDefaultValues(XOTableContext TableContext, DataAvail.XtraBindings.Calculator.ObjectProperties Item)
 {
     foreach (XOField field in TableContext.Fields.Select(p=>p.XOField).Where(p=>p.DefaultValue != null))
     {
         Item.SetValue(field.Name, field.DefaultValue);
     }
 }
 public static Controller CreateController(XOTableContext TableContext, IControllerProvider ControllerProvider, Func<XtraBinding, XOTableContext, Controller> CreateControllerInstanceFunc)
 {
     return CreateControllerInstanceFunc.Invoke(CreateXtraBindingSource(TableContext, ControllerProvider, null), TableContext);
 }
        public XOFieldContext(XOTableContext XTable, XOField XOField)
        {
            _xOTable = XTable;

            _xOField = XOField;
        }
 public Controller AddController(XOTableContext TableContext)
 {
     return AddController(TableContext, null);
 }
 public ControllerDynamicContext(XOTableContext XOTableContext)
 {
     AddAppItemContext(XOTableContext, true);
 }
 public Controller(XtraBinding XtraBinding, XOTableContext XOTableContext)
     : this(XtraBinding, new ControllerDynamicContext(XOTableContext))
 { }
        /*
        private XOTableContext _xtraObjectProperties;

        DataAvail.Data.Function.Function _selectLastInsertedPkCommand;

        internal static DataAvail.Data.DataAdapter.IDataAdapter GetDataAdapter(XOTableContext XtraObjectProperties)
        {
            return new DataAdapter(XtraObjectProperties);
        }

        //Is auto generetade primary key
        private readonly bool _isPKAutoGenerated = false;

        private DataAvail.Data.DbContext.IDbContextObjectCreator DbContextObjectCreator
        {
            get { return DataAvail.Data.DbContext.DbContext.CurrentContext.ObjectCreator; }
        }

        public XOTableContext XtraObjectProperties
        {
            get { return _xtraObjectProperties; }
        }

        protected override bool IsPrimaryKeyAutoGenerated
        {
            get
            {
                return _isPKAutoGenerated;
            }
        }


        private string GetInsertCommandText()
        {
            return string.Format("INSERT INTO {0} ({1}) VALUES ({2})",
                XtraObjectProperties.ObjectSourceUpdate,
                GetInsertFunctionParameters().Select(p => p.Name.ToUpper()).ToString(","),
                GetInsertFunctionParameters().Select(p => DataAvail.Data.DbContext.DbContext.CurrentContext.ParameterValuePrefix + p.Name.ToUpper()).ToString(","));
        }

        private string GetUpdateCommandText()
        {
            var updateCommandTextParams = GetUpdateFunctionParameters();

            if (!DataAvail.Data.DbContext.DbContext.CurrentContext.IsPkIncludedIntoUpdate)
                updateCommandTextParams = updateCommandTextParams.Where(p => !p.IsPK);

            return string.Format("UPDATE {0} SET {1} WHERE {2} = {3}",
                XtraObjectProperties.ObjectSourceUpdate,
                updateCommandTextParams.Select(p => DataAvail.Data.DbContext.DbContext.CurrentContext.ParameterValuePrefix + p.Name.ToUpper())
                .ToString(updateCommandTextParams.Select(p => p.Name.ToUpper()), null, "=", ","),
                GetUpdateFunctionParameters().Where(p => p.IsPK).Select(p => p.FieldName.ToUpper()).First(),
                GetUpdateFunctionParameters().Where(p => p.IsPK).Select(p => DataAvail.Data.DbContext.DbContext.CurrentContext.ParameterValuePrefix + p.FieldName.ToUpper()).First());
        }

        private string GetDeleteCommandText()
        {
            return string.Format("DELETE FROM {0} WHERE {1} = {2}",
                XtraObjectProperties.ObjectSourceUpdate,
                GetDeleteFunctionParameters().Select(p => p.Name.ToUpper()).ToString(","),
                GetDeleteFunctionParameters().Select(p => DataAvail.Data.DbContext.DbContext.CurrentContext.ParameterValuePrefix + p.Name.ToUpper()).ToString(","));
        }

        private IEnumerable<XOField> GetInsertFunctionParameters()
        {
            return XtraObjectProperties.Fields.Where(p => (p.IsMapped && (!p.IsPK || !_isPKAutoGenerated)));
        }

        private IEnumerable<XOField> GetUpdateFunctionParameters()
        {
            return XtraObjectProperties.Fields.Where(p => p.IsMapped);
        }

        private IEnumerable<XOField> GetDeleteFunctionParameters()
        {
            return XtraObjectProperties.Fields.Where(p => p.IsPK);
        }

        void InsertFun_commandExecuted(object sender, DataAvail.Data.Function.CommandExecutedEventArgs args)
        {
            object retVal = _selectLastInsertedPkCommand.Execute();

            args.executionResult = retVal;
        }
         */


        internal static DataAvail.Data.DataAdapter.IDataAdapter GetDataAdapter(XOTableContext XtraObjectProperties)
        {
            return null;
        }
        internal DataAdapter(
                XOTableContext AppItemContext)
            : base(DataAvail.Data.DbContext.DbContext.CurrentContext.ObjectCreator.Connection,
            AppItemContext.IsUseDefInsertCommand ? DataAvail.Data.DbContext.DbContext.CurrentContext.ObjectCreator.CreateCommand() : null,
            AppItemContext.IsUseDefUpdateCommand ? DataAvail.Data.DbContext.DbContext.CurrentContext.ObjectCreator.CreateCommand() : null,
            AppItemContext.IsUseDefDeleteCommand ? DataAvail.Data.DbContext.DbContext.CurrentContext.ObjectCreator.CreateCommand() : null)
        {
            /*
            _xtraObjectProperties = XtraObjectProperties;

            _isPKAutoGenerated = false;//nimpl

            if (InsertFun != null)
            {
                if (!XtraObjectProperties.IsUseDefInsertCommand)
                {
                    InsertFun.Initialize(
                        this.DbContextObjectCreator.Connection,
                        this.GetInsertCommandText(),
                        System.Data.CommandType.Text,
                        this.GetInsertFunctionParameters(),
                        new DataAvail.XOP.XOFieldMappingRules(null, InsertFun.ParamCreator));

                    if (_isPKAutoGenerated)
                        InsertFun.commandExecuted += new DataAvail.Data.Function.CommandExecutedHandler(InsertFun_commandExecuted);

                    _selectLastInsertedPkCommand = this.DbContextObjectCreator.CreateCommand();
                    _selectLastInsertedPkCommand.Initialize(this.DbContextObjectCreator.Connection,
                        DataAvail.Data.DbContext.DbContext.CurrentContext.GetIdentityCommandText(XtraObjectProperties.ObjectSourceUpdate), System.Data.CommandType.Text);
                }
                else
                {
                    InsertFun.Initialize(
                       this.DbContextObjectCreator.Connection,
                       XtraObjectProperties.Functions.createFunction.funcName,
                       System.Data.CommandType.StoredProcedure,
                       XtraObjectProperties.Functions.createFunction.funcParams,
                       new DataAvail.XtraObjectProperties.XOFFunctionParamMappingRules(null, InsertFun.ParamCreator));
                }
            }

            if (this.UpdateFun != null)
            {
                if (DataAvail.Utils.EnumFlags.IsContain(XtraObjectProperties.UseCommands, DataAvail.Utils.EditModeType.Edit))
                {
                    UpdateFun.Initialize(
                        this.DbContextObjectCreator.Connection,
                        this.GetUpdateCommandText(),
                        System.Data.CommandType.Text,
                        this.GetUpdateFunctionParameters(),
                        new DataAvail.XOP.XOFieldMappingRules(null, UpdateFun.ParamCreator));
                }
                else
                {
                    UpdateFun.Initialize(
                 this.DbContextObjectCreator.Connection,
                 XtraObjectProperties.Functions.updateFunction.funcName,
                 System.Data.CommandType.StoredProcedure,
                 XtraObjectProperties.Functions.updateFunction.funcParams,
                 new DataAvail.XtraObjectProperties.XOFFunctionParamMappingRules(null, UpdateFun.ParamCreator));
                }
            }

            if (this.DeleteFun != null)
            {
                if (DataAvail.Utils.EnumFlags.IsContain(XtraObjectProperties.UseCommands, DataAvail.Utils.EditModeType.Delete))
                {
                    DeleteFun.Initialize(
                        this.DbContextObjectCreator.Connection,
                        this.GetDeleteCommandText(),
                        System.Data.CommandType.Text,
                        this.GetDeleteFunctionParameters(),
                        new DataAvail.XOP.XOFieldMappingRules(null, DeleteFun.ParamCreator));
                }
                else
                {
                    DeleteFun.Initialize(
                  this.DbContextObjectCreator.Connection,
                  XtraObjectProperties.Functions.deleteFunction.funcName,
                  System.Data.CommandType.StoredProcedure,
                  XtraObjectProperties.Functions.deleteFunction.funcParams,
                  new DataAvail.XtraObjectProperties.XOFFunctionParamMappingRules(null, DeleteFun.ParamCreator));
                }
            }
             */
        }