void BuildFromItemWrappers(PivotAreaContainer container, List<AreaItemWrapper> wrappers)
        {
            if (container != null)
            {
                container.Clear();

                if (wrappers != null)
                {
                    container.ItemsListChanged -= new EventHandler(AreaContainer_ItemsListChanged);
                    foreach (AreaItemWrapper wrapper in wrappers)
                    {
                        AreaItemControl ctrl = null;
                        CustomTreeNode nodeInTree = FindCustomNode(wrapper);

                        Values_AreaItemWrapper values_item = wrapper as Values_AreaItemWrapper;
                        if (values_item != null)
                        {
                            ctrl = new Values_AreaItemControl();
                        }

                        Measure_AreaItemWrapper measures_item = wrapper as Measure_AreaItemWrapper;
                        if (measures_item != null)
                        {
                            ctrl = new Measure_AreaItemControl(measures_item);
                        }

                        CalculatedMember_AreaItemWrapper calcMember_item = wrapper as CalculatedMember_AreaItemWrapper;
                        if (calcMember_item != null)
                        {
                            ctrl = new CalculatedMember_AreaItemControl(calcMember_item);
                        }

                        CalculatedNamedSet_AreaItemWrapper calculatedSet_item = wrapper as CalculatedNamedSet_AreaItemWrapper;
                        if (calculatedSet_item != null)
                        {
                            ctrl = new CalculateNamedSet_AreaItemControl(calculatedSet_item);
                        }

                        NamedSet_AreaItemWrapper set_item = wrapper as NamedSet_AreaItemWrapper;
                        if (set_item != null)
                        {
                            ctrl = new NamedSet_AreaItemControl(set_item);
                        }

                        Level_AreaItemWrapper level_item = wrapper as Level_AreaItemWrapper;
                        if (level_item != null)
                        {
                            ctrl = new Level_AreaItemControl(level_item);
                        }

                        Hierarchy_AreaItemWrapper hierarchy_item = wrapper as Hierarchy_AreaItemWrapper;
                        if (hierarchy_item != null)
                        {
                            ctrl = new Hierarchy_AreaItemControl(hierarchy_item);
                        }

                        Kpi_AreaItemWrapper kpi_item = wrapper as Kpi_AreaItemWrapper;
                        if (kpi_item != null)
                        {
                            ctrl = new Kpi_AreaItemControl(kpi_item);
                        }

                        if (ctrl != null)
                        {
                            if (nodeInTree != null)
                            {
                                ctrl.UserData = nodeInTree;
                                ctrl.Icon = nodeInTree.Icon;
                                nodeInTree.UseBoldText = true;
                            }

                            container.AddItem(ctrl);
                            ctrl.ContextMenuCreated += new EventHandler(ctrl_ContextMenuCreated);

                            FilteredItemControl filtered_item = ctrl as FilteredItemControl;
                            if (filtered_item != null)
                            {
                                filtered_item.ShowFilter += new EventHandler(FilteredItem_ShowFilter);
                                filtered_item.CancelFilter += new EventHandler(FilteredItem_CancelFilter);
                            }
                        }
                    }
                    container.ItemsListChanged += new EventHandler(AreaContainer_ItemsListChanged);
                }
            }
        }
        void m_CubeBrowser_DragCompleted(object sender, DragNodeArgs<DragCompletedEventArgs> e)
        {
            try
            {
                if (e.Args.Canceled == false)
                {
                    TreeViewItem node = e.Node;

                    // Если кидаем в область MDX запроса
                    if (MDXQueryIsReadyToDrop)
                    {
                        String str = m_ServerExplorer.CubeBrowser.GetNodeString(node as CustomTreeNode);
                        if (!String.IsNullOrEmpty(str))
                        {
                            m_MdxQuery.Text += " " + str;
                        }
                        MDXQueryIsReadyToDrop = false;
                    }
                    else
                    {
                        // Если тягается измерение, то подменяем этот узел на первый из узлов иерархий
                        DimensionTreeNode dimNode = node as DimensionTreeNode;
                        if (dimNode != null)
                        {
                            HierarchyTreeNode hierarchyNode = null;

                            // Для начала ищем иерархию среди дочерних
                            foreach (TreeViewItem child in dimNode.Items)
                            {
                                hierarchyNode = child as HierarchyTreeNode;
                                if (hierarchyNode != null)
                                {
                                    node = hierarchyNode;
                                    break;
                                }
                            }
                            if (hierarchyNode == null)
                            {
                                // раз иерархии не нашли среди дочерних, то возможно средидочерних есть папки, в которые иерархия может быть вложена
                                // Значит пытаемся найти рекурсивно
                                hierarchyNode = FindHierarchy(dimNode);
                                if (hierarchyNode == null)
                                    return;
                                else
                                    node = hierarchyNode;
                            }
                        }

                        Members_FilterWrapper custom_MemberFilter = null;

                        // Убиваем конкурентов :D
                        if (m_RowsAreaContainer.IsReadyToDrop ||
                            m_ColumnsAreaContainer.IsReadyToDrop ||
                            m_FilterAreaContainer.IsReadyToDrop ||
                            m_DataAreaContainer.IsReadyToDrop)
                        {
                            // Если таскается элемент, то в случае если в данной области есть узел для иерархии или уровня, то элемент добавляется в фильтр
                            var memberNode = node as MemberLiteTreeNode;
                            if (memberNode != null && memberNode.Info != null)
                            {
                                PivotAreaContainer currentContainer = null;
                                // Убиваем конкурентов во всех областях кроме данной :D
                                if (m_RowsAreaContainer.IsReadyToDrop)
                                {
                                    currentContainer = m_RowsAreaContainer;
                                    m_ColumnsAreaContainer.RemoveItem(FindConcurent(m_ColumnsAreaContainer, node), false);
                                    m_FilterAreaContainer.RemoveItem(FindConcurent(m_FilterAreaContainer, node), false);
                                    m_DataAreaContainer.RemoveItem(FindConcurent(m_DataAreaContainer, node), false);
                                }
                                if (m_ColumnsAreaContainer.IsReadyToDrop)
                                {
                                    currentContainer = m_ColumnsAreaContainer;
                                    m_RowsAreaContainer.RemoveItem(FindConcurent(m_RowsAreaContainer, node), false);
                                    m_FilterAreaContainer.RemoveItem(FindConcurent(m_FilterAreaContainer, node), false);
                                    m_DataAreaContainer.RemoveItem(FindConcurent(m_DataAreaContainer, node), false);
                                }
                                if (m_FilterAreaContainer.IsReadyToDrop)
                                {
                                    currentContainer = m_FilterAreaContainer;
                                    m_ColumnsAreaContainer.RemoveItem(FindConcurent(m_ColumnsAreaContainer, node), false);
                                    m_RowsAreaContainer.RemoveItem(FindConcurent(m_RowsAreaContainer, node), false);
                                    m_DataAreaContainer.RemoveItem(FindConcurent(m_DataAreaContainer, node), false);
                                }
                                if (m_DataAreaContainer.IsReadyToDrop)
                                {
                                    currentContainer = m_DataAreaContainer;
                                    m_ColumnsAreaContainer.RemoveItem(FindConcurent(m_ColumnsAreaContainer, node), false);
                                    m_RowsAreaContainer.RemoveItem(FindConcurent(m_RowsAreaContainer, node), false);
                                    m_FilterAreaContainer.RemoveItem(FindConcurent(m_FilterAreaContainer, node), false);
                                }
                                if (currentContainer != null)
                                {
                                    // Находим конкурента в данной области
                                    var concurent = FindConcurent(currentContainer, node);
                                    var filtered_concurent = concurent as FilteredItemControl;
                                    if (filtered_concurent != null && filtered_concurent.FilteredWrapper != null &&
                                        (filtered_concurent is Hierarchy_AreaItemControl  || // Если конкурентом является иерархиия то это нормально
                                        (filtered_concurent is Level_AreaItemControl && ((Level_AreaItemControl)filtered_concurent).Level != null && ((Level_AreaItemControl)filtered_concurent).Level.UniqueName == memberNode.Info.LevelName)) // Если конкурентом является уровень, то это должен быть тот же уровень что и у элемента
                                    )
                                    {
                                        bool isDublicate = false;
                                        // Ищем такой же элемент в фильтре
                                        foreach (var item in filtered_concurent.FilteredWrapper.CompositeFilter.MembersFilter.SelectedInfo)
                                        {
                                            if (item.UniqueName == memberNode.Info.UniqueName && item.SelectState == SelectStates.Selected_Self)
                                                isDublicate = true;
                                        }
                                        if (!isDublicate)
                                        {
                                            // Добавляем сами руками в FilterSet. Он превильно сгенерируется только при закрытии диалога с фильтром
                                            if(String.IsNullOrEmpty(filtered_concurent.FilteredWrapper.CompositeFilter.MembersFilter.FilterSet))
                                            {
                                                filtered_concurent.FilteredWrapper.CompositeFilter.MembersFilter.FilterSet = "{" + memberNode.Info.UniqueName + "}";
                                            }
                                            else
                                            {
                                                String str = filtered_concurent.FilteredWrapper.CompositeFilter.MembersFilter.FilterSet.Trim();
                                                if(str.EndsWith("}"))
                                                {
                                                    str = str.Substring(0, str.Length - 1);
                                                }
                                                str += ", " + memberNode.Info.UniqueName + "}";
                                                filtered_concurent.FilteredWrapper.CompositeFilter.MembersFilter.FilterSet = str;
                                            }

                                            var member_settings = new MemberChoiceSettings(memberNode.Info, SelectStates.Selected_Self);
                                            filtered_concurent.FilteredWrapper.CompositeFilter.MembersFilter.SelectedInfo.Add(member_settings);
                                        }
                                        filtered_concurent.FilteredWrapper.CompositeFilter.MembersFilter.IsUsed = true;
                                        filtered_concurent.Refresh();
                                        if (m_FilterDialogs.ContainsKey(concurent))
                                        {
                                            ModalDialog dialog = m_FilterDialogs[concurent];
                                            if (dialog != null)
                                            {
                                                var filterControl = dialog.Content as FilterBuilderControl;
                                                if (filterControl != null)
                                                {
                                                    // Переинициализировать контрол выбора элементов измерения в фильтре при открытии
                                                    filterControl.MemberChoiceIsInitialized = false;
                                                }
                                            }
                                        }

                                        RefreshMdxQuery();
                                        return;
                                    }
                                    else
                                    {
                                        // Удаляем данного конкурента, т.к. он не поддерживает фильтр
                                        currentContainer.RemoveItem(concurent, false);
                                    }

                                    // Добавляем новый узел для иерархии
                                    // Ищем иерархию для данного элемента
                                    var hierarchyNode = m_ServerExplorer.CubeBrowser.FindHierarchyNode(memberNode.Info.HierarchyUniqueName);
                                    if (hierarchyNode != null)
                                    {
                                        custom_MemberFilter = new Members_FilterWrapper();
                                        var member_settings = new MemberChoiceSettings(memberNode.Info, SelectStates.Selected_Self);
                                        custom_MemberFilter.SelectedInfo.Add(member_settings);
                                        custom_MemberFilter.FilterSet = "{" + memberNode.Info.UniqueName + "}";
                                        node = hierarchyNode;
                                    }
                                }
                            }
                            else
                            {
                                AreaItemControl concurent = FindConcurent(m_RowsAreaContainer, node);
                                m_RowsAreaContainer.RemoveItem(concurent, false);

                                concurent = FindConcurent(m_ColumnsAreaContainer, node);
                                m_ColumnsAreaContainer.RemoveItem(concurent, false);

                                concurent = FindConcurent(m_FilterAreaContainer, node);
                                m_FilterAreaContainer.RemoveItem(concurent, false);

                                concurent = FindConcurent(m_DataAreaContainer, node);
                                m_DataAreaContainer.RemoveItem(concurent, false);
                            }
                        }

                        #region Узлы для вычисляемых элементов
                        CalculatedMemberTreeNode calcMemberNode = node as CalculatedMemberTreeNode;
                        if (calcMemberNode != null && calcMemberNode.Info != null)
                        {
                            // Вычисляемые элементы могут кидаться только в область данных
                            AreaItemControl ctrl = new CalculatedMember_AreaItemControl(new CalculatedMember_AreaItemWrapper(calcMemberNode.Info), calcMemberNode.Icon);
                            ctrl.ContextMenuCreated += new EventHandler(ctrl_ContextMenuCreated);
                            ctrl.UserData = node;


                            if (m_DataAreaContainer.IsReadyToDrop)
                            {
                                int count = m_DataAreaContainer.Items.Count;

                                // В случае, если в области данных стало более одного объекта, то добавляем специальный узел Values в область колонок 
                                if (count == 1)
                                {
                                    AreaItemControl value_ctrl = new Values_AreaItemControl();
                                    value_ctrl.ContextMenuCreated += new EventHandler(ctrl_ContextMenuCreated);
                                    m_ColumnsAreaContainer.ItemsListChanged -= new EventHandler(AreaContainer_ItemsListChanged);
                                    m_ColumnsAreaContainer.AddItem(value_ctrl);
                                    m_ColumnsAreaContainer.ItemsListChanged += new EventHandler(AreaContainer_ItemsListChanged);
                                }

                                m_DataAreaContainer.AddItem(ctrl);
                                calcMemberNode.UseBoldText = true;
                            }
                        }
                        #endregion Узлы для вычисляемых элементов

                        #region Узлы для именованных наборов
                        CalculatedNamedSetTreeNode calculatedSetNode = node as CalculatedNamedSetTreeNode;
                        if (calculatedSetNode != null && calculatedSetNode.Info != null)
                        {
                            // Set(ы) могут кидаться только в области строк и столбцов
                            AreaItemControl ctrl = new CalculateNamedSet_AreaItemControl(new CalculatedNamedSet_AreaItemWrapper(calculatedSetNode.Info), calculatedSetNode.Icon);
                            ctrl.ContextMenuCreated += new EventHandler(ctrl_ContextMenuCreated);
                            ctrl.UserData = node;

                            if (m_RowsAreaContainer.IsReadyToDrop)
                            {
                                m_RowsAreaContainer.AddItem(ctrl);
                                calculatedSetNode.UseBoldText = true;
                            }

                            if (m_ColumnsAreaContainer.IsReadyToDrop)
                            {
                                m_ColumnsAreaContainer.AddItem(ctrl);
                                calculatedSetNode.UseBoldText = true;
                            }
                        }

                        NamedSetTreeNode setNode = node as NamedSetTreeNode;
                        if (setNode != null)
                        {
                            NamedSetInfo setInfo = setNode.Info as NamedSetInfo;
                            if (setInfo != null)
                            {
                                // Set(ы) могут кидаться только в области строк и столбцов
                                AreaItemControl ctrl = new NamedSet_AreaItemControl(new NamedSet_AreaItemWrapper(setInfo), setNode.Icon);
                                ctrl.ContextMenuCreated += new EventHandler(ctrl_ContextMenuCreated);
                                ctrl.UserData = node;

                                if (m_RowsAreaContainer.IsReadyToDrop)
                                {
                                    m_RowsAreaContainer.AddItem(ctrl);
                                    setNode.UseBoldText = true;
                                }

                                if (m_ColumnsAreaContainer.IsReadyToDrop)
                                {
                                    m_ColumnsAreaContainer.AddItem(ctrl);
                                    setNode.UseBoldText = true;
                                }
                            }
                        }
                        #endregion Узлы для именованных наборов

                        #region Узлы метаданных (InfoBaseTreeNode)
                        InfoBaseTreeNode info_node = node as InfoBaseTreeNode;
                        if (info_node != null)
                        {
                            HierarchyInfo hierarchyInfo = info_node.Info as HierarchyInfo;
                            LevelInfo levelInfo = info_node.Info as LevelInfo;
                            MeasureInfo measureInfo = info_node.Info as MeasureInfo;
                            KpiInfo kpiInfo = info_node.Info as KpiInfo;

                            // Иерархии и уровни можно кидать только в области: строк, столбцов, фильтров
                            if (hierarchyInfo != null || levelInfo != null)
                            {
                                FilteredItemControl ctrl = null;
                                if (hierarchyInfo != null)
                                    ctrl = new Hierarchy_AreaItemControl(new Hierarchy_AreaItemWrapper(hierarchyInfo), info_node.Icon);
                                if (levelInfo != null)
                                    ctrl = new Level_AreaItemControl(new Level_AreaItemWrapper(levelInfo), info_node.Icon);

                                ctrl.ShowFilter += new EventHandler(FilteredItem_ShowFilter);
                                ctrl.CancelFilter += new EventHandler(FilteredItem_CancelFilter);
                                ctrl.ContextMenuCreated += new EventHandler(ctrl_ContextMenuCreated);
                                ctrl.UserData = node;
                                if(custom_MemberFilter != null)
                                {
                                    ctrl.FilteredWrapper.CompositeFilter.MembersFilter = custom_MemberFilter;
                                    ctrl.FilteredWrapper.CompositeFilter.MembersFilter.IsUsed = true;
                                    ctrl.Refresh();
                                }

                                if (m_RowsAreaContainer.IsReadyToDrop)
                                {
                                    m_RowsAreaContainer.AddItem(ctrl);
                                    info_node.UseBoldText = true;
                                }

                                if (m_ColumnsAreaContainer.IsReadyToDrop)
                                {
                                    m_ColumnsAreaContainer.AddItem(ctrl);
                                    info_node.UseBoldText = true;
                                }

                                if (m_FilterAreaContainer.IsReadyToDrop)
                                {
                                    m_FilterAreaContainer.AddItem(ctrl);
                                    info_node.UseBoldText = true;
                                }
                            }

                            // меры и Kpi могут кидаться только в область данных
                            if (measureInfo != null ||
                                kpiInfo != null)
                            {
                                AreaItemControl ctrl = null;
                                if (measureInfo != null)
                                    ctrl = new Measure_AreaItemControl(new Measure_AreaItemWrapper(measureInfo), info_node.Icon);
                                if (kpiInfo != null)
                                {
                                    KpiControlType type = KpiControlType.Value;
                                    if (node is KpiStatusTreeNode)
                                        type = KpiControlType.Status;
                                    if (node is KpiTrendTreeNode)
                                        type = KpiControlType.Trend;
                                    if (node is KpiGoalTreeNode)
                                        type = KpiControlType.Goal;

                                    ctrl = new Kpi_AreaItemControl(new Kpi_AreaItemWrapper(kpiInfo, type), info_node.Icon);
                                }

                                if (ctrl != null)
                                {
                                    ctrl.ContextMenuCreated += new EventHandler(ctrl_ContextMenuCreated);
                                    ctrl.UserData = node;

                                    if (m_DataAreaContainer.IsReadyToDrop)
                                    {
                                        int count = m_DataAreaContainer.Items.Count;

                                        // В случае, если в области данных стало более одного объекта, то добавляем специальный узел Values в область колонок 
                                        if (count == 1)
                                        {
                                            AreaItemControl value_ctrl = new Values_AreaItemControl();
                                            value_ctrl.ContextMenuCreated += new EventHandler(ctrl_ContextMenuCreated);
                                            m_ColumnsAreaContainer.ItemsListChanged -= new EventHandler(AreaContainer_ItemsListChanged);
                                            m_ColumnsAreaContainer.AddItem(value_ctrl);
                                            m_ColumnsAreaContainer.ItemsListChanged += new EventHandler(AreaContainer_ItemsListChanged);
                                        }

                                        m_DataAreaContainer.AddItem(ctrl);
                                        info_node.UseBoldText = true;
                                    }
                                }
                            }
                        }
                        #endregion Узлы метаданных (InfoBaseTreeNode)
                    }

                }
            }
            finally
            {
                m_RowsAreaContainer.IsReadyToDrop = false;
                m_ColumnsAreaContainer.IsReadyToDrop = false;
                m_FilterAreaContainer.IsReadyToDrop = false;
                m_DataAreaContainer.IsReadyToDrop = false;
            }
        }