public PivotLayoutProvider(PivotDataProvider provider)
        {
            if (provider == null)
            {
                throw new ArgumentNullException("provider");
            }

            m_Provider = provider;
        }
        /// <summary>
        /// Экспорт в Microsoft Excel.
        /// </summary>
        /// <param name="provider">Provider.</param>
        /// <returns>Возращает строку с xml в формате "Spreadsheet".</returns>
        static public string ExportToExcel(PivotDataProvider provider)
        {
            pivotDataProvider = provider;
            document = new XmlDocument();
            
            WriteHeaders();
            
            //<DocumentProperties>
            WriteDocumentProperties();
            
            //<Styles>
            WriteDefaultStyles();

            string cubeName = provider.Provider.CellSet_Description.CubeName;
            //<Worksheet>
            worksheet = document.CreateElement("s", "Worksheet", spreadsheetNamespace);
            worksheet.SetAttribute("Protected", spreadsheetNamespace, true.GetHashCode().ToString());
            worksheet.SetAttribute("Name", spreadsheetNamespace, cubeName);
            workbook.AppendChild(worksheet);

            //<Table>
            table = document.CreateElement("s", "Table", spreadsheetNamespace);
            table.SetAttribute("StyleID", spreadsheetNamespace, tableStyle);
            worksheet.AppendChild(table);

            //Количество строк в области колонок:
            int colRowsCount = 0;
            if(pivotDataProvider.Provider.CellSet_Description.Axes.Count > 0 &&
               pivotDataProvider.Provider.CellSet_Description.Axes[0].Positions.Count > 0)
            {
                colRowsCount = pivotDataProvider.Provider.CellSet_Description.Axes[0].Positions[0].Members.Count;
            }
            //количество колонок в области строк:
            int rowColumnsCount = 0;
            if (pivotDataProvider.Provider.CellSet_Description.Axes.Count > 1 &&
                pivotDataProvider.Provider.CellSet_Description.Axes[1].Positions.Count > 0)
            {
                rowColumnsCount = pivotDataProvider.Provider.CellSet_Description.Axes[1].Positions[0].Members.Count;
            }

            //количество колонок в области колонок:
            int colColumnsCount = pivotDataProvider.ColumnsArea.ColumnsCount;
            
            //Задать ширину колонок:
            SetColumnsWidth(rowColumnsCount, colColumnsCount);

            WriteFilters();
            WriteColumns(rowColumnsCount + 1);
            WriteRows(colColumnsCount);

            //<WorksheetOptions>
            SetWorksheetOptions();
            
            return document.OuterXml.Replace("amp;#", "#");
        }
 public override String ExportToExcel()
 {
     String result = String.Empty;
     try
     {
         CellSetData res = RefreshQuery();
         PivotDataProvider pivotProvider = new PivotDataProvider(new CellSetDataProvider(res));
         result = ExportHelper.ExportToExcel(pivotProvider);
     }
     catch
     {
         result = string.Empty;
     }
     return result;
 }
        private String ExportToExcel(String schema)
        {
            InvokeResultDescriptor result = new InvokeResultDescriptor();
            String res = String.Empty;
            try
            {
                String sessionId = String.Empty;
                String connection = String.Empty;
                try
                {
                    MdxQueryArgs args = XmlSerializationUtility.XmlStr2Obj<MdxQueryArgs>(schema);
                    if (args != null)
                    {
                        sessionId = args.SessionId;
                        connection = args.Connection;
                        DefaultQueryExecuter queryExecuter = new DefaultQueryExecuter(GetConnection(args.Connection));
                        if (args.Queries.Count > 0)
                        {
                            res = queryExecuter.GetCellSetDescription(args.Queries[0], ref sessionId);
                        }
                    }
                }
                catch (AdomdConnectionException connection_ex)
                {
                    result.Content = connection_ex.Message;
                    result.ContentType = InvokeContentType.Error;
                }
                catch (AdomdErrorResponseException response_ex)
                {
                    result.Content = response_ex.Message;
                    result.ContentType = InvokeContentType.Error;
                }
                catch (AdomdUnknownResponseException unknown_ex)
                {
                    result.Content = unknown_ex.Message;
                    result.ContentType = InvokeContentType.Error;
                }
                catch (InvalidOperationException invalid_ex)
                {
                    result.Content = invalid_ex.Message;
                    result.ContentType = InvokeContentType.Error;
                }

                if (!String.IsNullOrEmpty(res))
                {
                    CellSetData cs = CellSetData.Deserialize(res);
                    PivotDataProvider pivotProvider = new PivotDataProvider(new CellSetDataProvider(cs));
                    res = ExportHelper.ExportToExcel(pivotProvider);
                }

                result.Content = res;
                if (UseCompress)
                {
                    // Архивация строки
                    String compesed = ZipCompressor.CompressAndConvertToBase64String(res);
                    result.Content = compesed;
                    result.IsArchive = true;
                }
                result.ContentType = InvokeContentType.MultidimData;
                result.Headers.Add(new Header(InvokeResultDescriptor.SESSION_ID, sessionId));
                result.Headers.Add(new Header(InvokeResultDescriptor.CONNECTION_ID, connection));
            }
            catch (Exception)
            {
                throw;
            }
            return InvokeResultDescriptor.Serialize(result);
        }
        public void Initialize(CellSetDataProvider provider)
        {
            // Ячейка с фокусом содержит элемент из предыдущего CellSetDataProvider. По таплу ныжно найти ей соответствие в новом CellSetDataProvider
            if (FocusedCellView != null)
            {
                if (provider != null)
                {
                    CellInfo info = provider.GetCellInfo(FocusedCellView.CellDescr.Axis0_Coord, FocusedCellView.CellDescr.Axis1_Coord);
                    IDictionary<String, MemberInfo> tuple = FocusedCellView.GetTuple();
                    if(info != null && info.CompareByTuple(tuple))
                    {
                        // Соответствие сразу найдено (в идеале)
                    }
                    else
                    {
                        info = provider.GetCellByTuple(tuple);
                    }
                    FocusedCellView = info;
                }
                else
                    FocusedCellView = null;
            }

            bool stick = false;
            // Пытаемся получить ячейку, которая в текущий момент верхняя левая
            // и сравнить ее с новой ячейкой с теми же координатами. Если ячейки совпадают, то позицию не обнуляем чтобы на экране осталась текущая область
            if (m_CellSetProvider != null &&
                m_CellSetProvider.CellSet_Description != null)
            {
                CellInfo cell_old = m_CellSetProvider.GetCellInfo(ColumnsArea_FirstVisible_Coordinate.Column, RowsArea_FirstVisible_Coordinate.Row);
                if (cell_old != null)
                {
                    if (provider != null &&
                        provider.CellSet_Description != null)
                    {
                        CellInfo cell_new = provider.GetCellInfo(ColumnsArea_FirstVisible_Coordinate.Column, RowsArea_FirstVisible_Coordinate.Row);
                        if (cell_new != null)
                        { 
                            // Сверяем по координатам
                            stick = cell_new.CompareByTuple(cell_old.GetTuple());
                        }
                    }
                }
            }

            //// Если в старой позиции уже находится другая ячейка, то отображаем ячейку с фокусом
            //if (!stick)
            //{
            //    GoToFocusedCell();
            //    //ColumnsArea_FirstVisible_Coordinate.Column = 0;
            //    //RowsArea_FirstVisible_Coordinate.Row = 0;
            //    //m_VerticalScroll.Value = 0;
            //    //m_HorizontalScroll.Value = 0;
            //}

            m_SelectionManager.ClearSelection();

            //m_MembersWidthes.Clear();
            //m_MembersHeightes.Clear();

            ColumnsArea_LovestMemberControls.Clear();
            RowsArea_LovestMemberControls.Clear();
            m_MemberControls_Dict.Clear();

            DateTime start = DateTime.Now;
            //System.Diagnostics.Debug.WriteLine("PivotGrid initializing start: " + start.TimeOfDay.ToString());

            bool new_OlapData = m_CellSetProvider != provider;
            m_CellSetProvider = provider;
            m_LayoutProvider = null;

            if (provider != null)
            {
                PivotDataProvider pivotProvider = new PivotDataProvider(provider);
                m_LayoutProvider = new PivotLayoutProvider(pivotProvider);
            }

            if (m_AnalyticInfo == null)
                m_AnalyticInfo = new PivotDataAnalizer(this);
            else
            {
                m_AnalyticInfo.ClearMembersAnalytic();
                if (new_OlapData)
                    m_AnalyticInfo.BuildCellsAnalytic();
            }

            Refresh(RefreshType.BuildEndRefresh);

            // Если в старой позиции уже находится другая ячейка, то отображаем ячейку с фокусом
            if (!stick)
            {
                GoToFocusedCell();
            }
            DateTime stop = DateTime.Now;
            //System.Diagnostics.Debug.WriteLine("PivotGrid initializing stop: " + stop.TimeOfDay.ToString());
            //System.Diagnostics.Debug.WriteLine("PivotGrid initializing time: " + (stop - start).ToString());
        }